sendfile_operation_default.ipp

Go to the documentation of this file.

/*
    restinio
*/
 
/*!
    sendfile routine.
*/
 
#include <cstdio>
 
namespace restinio
{
 
namespace impl
{
 
//
// sendfile_operation_runner_t
//
 
//! A runner of sendfile operation
template < typename Socket >
class sendfile_operation_runner_t final
    :   public sendfile_operation_runner_base_t< Socket >
{
    public:
        using base_type_t = sendfile_operation_runner_base_t< Socket >;
 
        sendfile_operation_runner_t( const sendfile_operation_runner_t & ) = delete;
        sendfile_operation_runner_t( sendfile_operation_runner_t && ) = delete;
        sendfile_operation_runner_t & operator = ( const sendfile_operation_runner_t & ) = delete;
        sendfile_operation_runner_t & operator = ( sendfile_operation_runner_t && ) = delete;
 
        // Reuse construstors from base.
        using base_type_t::base_type_t;
 
 
        virtual void
        start() override
        {
            const auto n =
                std::fseek(
                    this->m_file_descriptor,
                    //eao197: suppress warning from a compiler if restinio::file_offset_t
                    //is not long.
                    static_cast<long>(this->m_next_write_offset),
                    SEEK_SET );
 
            if( 0 == n )
            {
                this->init_next_write();
            }
            else
            {
                this->m_after_sendfile_cb(
                    make_error_code( std::ferror( this->m_file_descriptor ) ),
                    this->m_transfered_size );
                return;
            }
        }
 
        /*!
         * @note
         * This method is noexcept since v.0.6.0.
         */
        void
        init_next_write() noexcept
        {
            const auto desired_size =
                std::min< file_size_t >( this->m_remained_size, this->m_chunk_size );
 
            const auto n =
                std::fread(
                    this->m_buffer.get(),
                    1,
                    desired_size,
                    this->m_file_descriptor );
 
            if( desired_size != n )
            {
                this->m_after_sendfile_cb(
                    make_error_code( std::ferror( this->m_file_descriptor ) ),
                    this->m_transfered_size );
            }
            else
            {
                // If asio_ns::async_write fails we'll call m_after_sendfile_cb.
                try
                {
                    asio_ns::async_write(
                        this->m_socket,
                        asio_ns::const_buffer{
                            this->m_buffer.get(),
                            static_cast< std::size_t >( desired_size ) },
                        asio_ns::bind_executor(
                            this->m_executor,
                            make_async_write_handler() ) );
                }
                catch( ... )
                {
                    this->m_after_sendfile_cb(
                        make_asio_compaible_error(
                            asio_convertible_error_t::async_write_call_failed ),
                        this->m_transfered_size );
                }
            }
        }
 
    private:
        std::unique_ptr< char[] > m_buffer{ new char [ this->m_chunk_size ] };
 
        //! Helper method for making a lambda for async_write completion handler.
        auto
        make_async_write_handler() noexcept
        {
            return [ this, ctx = this->shared_from_this() ]
                // NOTE: this lambda is noexcept since v.0.6.0.
                ( const asio_ns::error_code & ec, std::size_t written ) noexcept
                {
                    if( !ec )
                    {
                        this->m_remained_size -= written;
                        this->m_transfered_size += written;
                        if( 0 == this->m_remained_size )
                        {
                            this->m_after_sendfile_cb( ec, this->m_transfered_size );
                        }
                        else
                        {
                            this->init_next_write();
                        }
                    }
                    else
                    {
                        this->m_after_sendfile_cb( ec, this->m_transfered_size );
                    }
                };
        }
};
 
} /* namespace impl */
 
} /* namespace restinio */