epee::net_utils::abstract_tcp_server< THandler > Class Template Reference

#include <abstract_tcp_server.h>

Public Member Functions
	abstract_tcp_server ()
bool	init_server (int port_no)
bool	deinit_server ()
bool	run_server ()
bool	send_stop_signal ()
THandler::config_type &	get_config_object ()

Detailed Description

template<class THandler>
class epee::net_utils::abstract_tcp_server< THandler >

Definition at line 77 of file abstract_tcp_server.h.

Constructor & Destructor Documentation

abstract_tcp_server()

template<class THandler >

epee::net_utils::abstract_tcp_server< THandler >::abstract_tcp_server

Definition at line 162 of file abstract_tcp_server.h.

                                                      :m_listen_socket(INVALID_SOCKET), 
                                                         m_initialized(false), 
                                                         m_stop_server(0), m_port(0), m_threads_count(0)
    {
 
    }

Member Function Documentation

deinit_server()

template<class THandler >

bool epee::net_utils::abstract_tcp_server< THandler >::deinit_server

Definition at line 215 of file abstract_tcp_server.h.

    {
 
        if(!m_initialized)
            return true;
 
        if(INVALID_SOCKET != m_listen_socket)
        {
            shutdown(m_listen_socket, SD_BOTH);
            int res = closesocket(m_listen_socket);
            if(SOCKET_ERROR == res)
            {
                int err = ::WSAGetLastError();
                LOG_ERROR("Failed to closesocket(), err = " << err << " \"" << socket_errors::get_socket_error_text(err) <<"\"");
            }
            m_listen_socket = INVALID_SOCKET;
        }
 
        int res = ::WSACleanup();
        if(SOCKET_ERROR == res)
        {
            int err = ::WSAGetLastError();
            LOG_ERROR("Failed to WSACleanup(), err = " << err << " \"" << socket_errors::get_socket_error_text(err) <<"\"");
        }
        m_initialized = false;
 
        return true;
    }

get_config_object()

template<class THandler >

THandler::config_type& epee::net_utils::abstract_tcp_server< THandler >::get_config_object ( )

inline

Definition at line 87 of file abstract_tcp_server.h.

{return m_config;}

init_server()

template<class THandler >

bool epee::net_utils::abstract_tcp_server< THandler >::init_server

(

int

port_no

)

Definition at line 171 of file abstract_tcp_server.h.

    {
        m_port = port_no;
        WSADATA wsad = {0};
        int err = ::WSAStartup(MAKEWORD(2,2), &wsad);
        if ( err != 0  || LOBYTE( wsad.wVersion ) != 2 || HIBYTE( wsad.wVersion ) != 2 )
        {
            LOG_ERROR("Could not find a usable WinSock DLL, err = " << err << " \"" << socket_errors::get_socket_error_text(err) <<"\"");
            return false;
        }
 
        m_initialized = true;
 
        m_listen_socket = ::WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
        if(INVALID_SOCKET == m_listen_socket)
        {
            err = ::WSAGetLastError();
            LOG_ERROR("Failed to create socket, err = " << err << " \"" << socket_errors::get_socket_error_text(err) <<"\"");
            return false;
        }
 
        int opt = 1;
        setsockopt (m_listen_socket, SOL_SOCKET,SO_REUSEADDR, reinterpret_cast<char*>(&opt), sizeof(int));
 
        sockaddr_in adr = {0};
        adr.sin_family = AF_INET;
        adr.sin_addr.s_addr = htonl(INADDR_ANY);
        adr.sin_port = (u_short)htons(port_no);
 
        err = bind(m_listen_socket, (const sockaddr*)&adr, sizeof(adr ));
        if(SOCKET_ERROR == err )
        {
            err = ::WSAGetLastError();
            LOG_PRINT("Failed to Bind, err = " << err << " \"" << socket_errors::get_socket_error_text(err) <<"\"", LOG_LEVEL_2);
            deinit_server();
            return false;
        }
 
        ::InterlockedExchange(&m_stop_server, 0);
 
        return true;
    }

run_server()

template<class THandler >

bool epee::net_utils::abstract_tcp_server< THandler >::run_server

Definition at line 252 of file abstract_tcp_server.h.

    {
        int err = listen(m_listen_socket, 10000);
        if(SOCKET_ERROR == err )
        {
            err = ::WSAGetLastError();
            LOG_ERROR("Failed to listen, err = " << err << " \"" << socket_errors::get_socket_error_text(err) <<"\"");
            return false;
        }
        
        LOG_PRINT("Listening port "<< m_port << "...." , LOG_LEVEL_2);
 
        while(!m_stop_server)
        {
            sockaddr_in adr_from = {0};
            int adr_len = sizeof(adr_from);
            fd_set read_fs = {0};
            read_fs.fd_count = 1;
            read_fs.fd_array[0] = m_listen_socket;
            TIMEVAL tv = {0};
            tv.tv_usec = 100;
            int select_res = select(0, &read_fs, NULL, NULL, &tv);
            if(!select_res)
                continue;
            SOCKET new_sock = WSAAccept(m_listen_socket, (sockaddr *)&adr_from, &adr_len, NULL, NULL);
            LOG_PRINT("Accepted connection on socket=" << new_sock, LOG_LEVEL_2);
            invoke_connection(new_sock, adr_from.sin_addr.s_addr, adr_from.sin_port);
        }
 
        deinit_server();
 
#define ABSTR_TCP_SRV_WAIT_COUNT_MAX 5000
#define ABSTR_TCP_SRV_WAIT_COUNT_INTERVAL 1000
        
        int wait_count = 0;
 
        while(m_threads_count && wait_count*1000 < ABSTR_TCP_SRV_WAIT_COUNT_MAX)
        {
            ::Sleep(ABSTR_TCP_SRV_WAIT_COUNT_INTERVAL);
            wait_count++;
        }
        LOG_PRINT("abstract_tcp_server exit with wait count=" << wait_count*ABSTR_TCP_SRV_WAIT_COUNT_INTERVAL << "(max=" << ABSTR_TCP_SRV_WAIT_COUNT_MAX <<")", LOG_LEVEL_0);
 
        return true;
    }

send_stop_signal()

template<class THandler >

bool epee::net_utils::abstract_tcp_server< THandler >::send_stop_signal

Definition at line 245 of file abstract_tcp_server.h.

    {
        InterlockedExchange(&m_stop_server, 1);
        return true;
    }

---

The documentation for this class was generated from the following file:

• /home/abuild/rpmbuild/BUILD/electroneum-4.0.0.0/contrib/epee/include/net/abstract_tcp_server.h