abstract_tcp_server_cp.h File Reference

#include <winsock2.h>
#include <rpc.h>
#include <string>
#include <map>
#include <boost/shared_ptr.hpp>
#include "misc_log_ex.h"
#include "syncobj.h"
#include "profile_tools.h"
#include "net_utils_base.h"
#include "pragma_comp_defs.h"
#include "abstract_tcp_server_cp.inl"

Include dependency graph for abstract_tcp_server_cp.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	epee::net_utils::cp_server_impl< TProtocol >

Namespaces
namespace	epee
namespace	epee::net_utils

Macros
#define	ENABLE_PROFILING
#define	ELECTRONEUM_DEFAULT_LOG_CATEGORY   "net"
#define	LEVIN_DEFAULT_DATA_BUFF_SIZE   2000

Typedefs
typedef std::map< SOCKET, boost::shared_ptr< connection< TProtocol > > >	epee::net_utils::connections_container

Functions
	connection (typename TProtocol::config_type &ref_config)
connection< TProtocol > &	operator= (const connection< TProtocol > &obj)
bool	init_buffers ()
bool	query_shutdown ()
	~connection ()
virtual bool	handle_send (const void *ptr, size_t cb)
else	if (0==res)
PRAGMA_WARNING_POP bool	epee::net_utils::worker_thread_member ()
bool	epee::net_utils::add_new_connection (SOCKET new_sock, long ip_from, int port_from)
bool	epee::net_utils::shutdown_connection (connection< TProtocol > *pconn)

Variables
return	true
SOCKET	epee::net_utils::m_listen_socket
HANDLE	epee::net_utils::m_completion_port
connections_container	epee::net_utils::m_connections
critical_section	epee::net_utils::m_connections_lock
int	epee::net_utils::m_port
volatile LONG	epee::net_utils::m_stop
bool	epee::net_utils::m_initialized
volatile LONG	epee::net_utils::m_worker_thread_counter
TProtocol::config_type	epee::net_utils::m_config

Macro Definition Documentation

ELECTRONEUM_DEFAULT_LOG_CATEGORY

#define ELECTRONEUM_DEFAULT_LOG_CATEGORY   "net"

Definition at line 46 of file abstract_tcp_server_cp.h.

ENABLE_PROFILING

#define ENABLE_PROFILING

Definition at line 40 of file abstract_tcp_server_cp.h.

LEVIN_DEFAULT_DATA_BUFF_SIZE

#define LEVIN_DEFAULT_DATA_BUFF_SIZE   2000

Definition at line 48 of file abstract_tcp_server_cp.h.

Function Documentation

connection()

resize_send_buff::connection

(

typename TProtocol::config_type &

ref_config

)

Definition at line 188 of file abstract_tcp_server_cp.h.

            {
                if(m_psend_data->TotalBuffBytes >= new_size)
                    return true;

Here is the caller graph for this function:

handle_send()

virtual bool resize_send_buff::handle_send ( const void * ptr, size_t cb )

virtual

Definition at line 234 of file abstract_tcp_server_cp.h.

if()

else resize_send_buff::if

(

0

= = res

)

Definition at line 265 of file abstract_tcp_server_cp.h.

{
namespace net_utils
{
 
    template<class TProtocol>
    class cp_server_impl//: public abstract_handler
    {
    public:
        cp_server_impl(/*abstract_handler* phandler = NULL*/);
        virtual ~cp_server_impl();
 
        bool init_server(int port_no);
        bool deinit_server();
        bool run_server(int threads_count = 0);
        bool send_stop_signal();
        bool is_stop_signal();
        virtual bool on_net_idle(){return true;}
        size_t get_active_connections_num();
        typename TProtocol::config_type& get_config_object(){return m_config;}
    private:
        enum overlapped_operation_type
        {
            op_type_recv,
            op_type_send,
            op_type_stop
        };
 
        struct io_data_base
        {
            OVERLAPPED m_overlapped;
            WSABUF DataBuf;
            overlapped_operation_type m_op_type;
            DWORD TotalBuffBytes;
            volatile LONG m_is_in_use;
            char Buffer[1];
        };
 
PRAGMA_WARNING_PUSH
PRAGMA_WARNING_DISABLE_VS(4355)
        template<class TProtocol>
        struct connection: public net_utils::i_service_endpoint
        {
            connection(typename TProtocol::config_type& ref_config):m_sock(INVALID_SOCKET), m_tprotocol_handler(this, ref_config, context), m_psend_data(NULL), m_precv_data(NULL), m_asked_to_shutdown(0), m_connection_shutwoned(0)
            {
            }
 
            //connection():m_sock(INVALID_SOCKET), m_tprotocol_handler(this, m_dummy_config, context), m_psend_data(NULL), m_precv_data(NULL), m_asked_to_shutdown(0), m_connection_shutwoned(0)
            //{
            //}
 
            connection<TProtocol>& operator=(const connection<TProtocol>& obj)
            {
                return *this;
            }
 
            bool init_buffers()
            {
                m_psend_data = (io_data_base*)new char[sizeof(io_data_base) + LEVIN_DEFAULT_DATA_BUFF_SIZE-1];
                m_psend_data->TotalBuffBytes = LEVIN_DEFAULT_DATA_BUFF_SIZE;
                m_precv_data = (io_data_base*)new char[sizeof(io_data_base) + LEVIN_DEFAULT_DATA_BUFF_SIZE-1];
                m_precv_data->TotalBuffBytes = LEVIN_DEFAULT_DATA_BUFF_SIZE;
                return true;
            }
            
            bool query_shutdown()
            {
                if(!::InterlockedCompareExchange(&m_asked_to_shutdown, 1, 0))
                {
                    m_psend_data->m_op_type = op_type_stop;
                    ::PostQueuedCompletionStatus(m_completion_port, 0, (ULONG_PTR)this, &m_psend_data->m_overlapped);
                }
                return true;
            }
 
            //bool set_config(typename TProtocol::config_type& config)
            //{
            //  this->~connection();
            //  new(this) connection<TProtocol>(config);
            //  return true;
            //}
            ~connection()
            {
                if(m_psend_data)
                    delete m_psend_data;
 
                if(m_precv_data)
                    delete m_precv_data;
            }
            virtual bool handle_send(const void* ptr, size_t cb)
            {
                PROFILE_FUNC("[handle_send]");
                if(m_psend_data->TotalBuffBytes < cb)
                    resize_send_buff((DWORD)cb);
                
                ZeroMemory(&m_psend_data->m_overlapped, sizeof(OVERLAPPED));
                m_psend_data->DataBuf.len = (u_long)cb;//m_psend_data->TotalBuffBytes;
                m_psend_data->DataBuf.buf = m_psend_data->Buffer;
                memcpy(m_psend_data->DataBuf.buf, ptr, cb);
                m_psend_data->m_op_type = op_type_send;
                InterlockedExchange(&m_psend_data->m_is_in_use, 1);
                DWORD bytes_sent = 0;
                DWORD flags = 0;
                int res = 0;
                {
                    PROFILE_FUNC("[handle_send] ::WSASend");
                    res = ::WSASend(m_sock, &(m_psend_data->DataBuf), 1, &bytes_sent, flags, &(m_psend_data->m_overlapped), NULL);
                }
                
                if(res == SOCKET_ERROR )
                {
                    int err = ::WSAGetLastError();
                    if(WSA_IO_PENDING == err )
                        return true;
                    }
                    LOG_ERROR("BIG FAIL: WSASend error code not correct, res=" << res << " last_err=" << err);
                    ::InterlockedExchange(&m_psend_data->m_is_in_use, 0);
                    query_shutdown();
                    //closesocket(m_psend_data);
                    return false;
                }else if(0 == res)
                {
                    ::InterlockedExchange(&m_psend_data->m_is_in_use, 0);
                    if(!bytes_sent || bytes_sent != cb)
                    {
                        int err = ::WSAGetLastError();
                        LOG_ERROR("BIG FAIL: WSASend immediatly complete? but bad results, res=" << res << " last_err=" << err);
                        query_shutdown();
                        return false;
                    }else
                    {
                        return true;
                    }
                }
 
                return true;
            }
            bool resize_send_buff(DWORD new_size)
            {
                if(m_psend_data->TotalBuffBytes >= new_size)
                    return true;
 
                delete m_psend_data;
                m_psend_data = (io_data_base*)new char[sizeof(io_data_base) + new_size-1];
                m_psend_data->TotalBuffBytes = new_size;
                LOG_PRINT("Connection buffer resized up to " << new_size, LOG_LEVEL_3);
                return true;
            }
 
 
            SOCKET m_sock;
            net_utils::connection_context_base context;
            TProtocol m_tprotocol_handler;
            typename TProtocol::config_type m_dummy_config;
            io_data_base* m_precv_data;
            io_data_base* m_psend_data;
            HANDLE m_completion_port;
            volatile LONG m_asked_to_shutdown;          
            volatile LONG m_connection_shutwoned;           
        };
PRAGMA_WARNING_POP
 
        bool worker_thread_member();
        static unsigned CALLBACK worker_thread(void* param);
 
        bool add_new_connection(SOCKET new_sock, long ip_from, int port_from);
        bool shutdown_connection(connection<TProtocol>* pconn);
 
 
        typedef std::map<SOCKET, boost::shared_ptr<connection<TProtocol> > > connections_container;
        SOCKET m_listen_socket;
        HANDLE m_completion_port;
        connections_container m_connections;
        critical_section m_connections_lock;
        int    m_port;
        volatile LONG m_stop;
        //abstract_handler* m_phandler;
        bool m_initialized;
        volatile LONG m_worker_thread_counter;
        typename TProtocol::config_type m_config;
    };
}
}
#include "abstract_tcp_server_cp.inl"
 
 
#endif //_LEVIN_SERVER_H_

Here is the caller graph for this function:

init_buffers()

bool resize_send_buff::init_buffers

(

)

Definition at line 201 of file abstract_tcp_server_cp.h.

operator=()

connection< TProtocol > & resize_send_buff::operator=

(

const connection< TProtocol > &

obj

)

Definition at line 196 of file abstract_tcp_server_cp.h.

Here is the caller graph for this function:

query_shutdown()

bool resize_send_buff::query_shutdown

(

)

Definition at line 210 of file abstract_tcp_server_cp.h.

~connection()

resize_send_buff::~connection

(

)

Definition at line 226 of file abstract_tcp_server_cp.h.

Variable Documentation

true

return true

Definition at line 280 of file abstract_tcp_server_cp.h.