CRioTCP Class Reference

#include <RioTCP.h>

Public Member Functions
	CRioTCP ()
	~CRioTCP ()
RioResult	Connect (const char *MachineName, const unsigned short TCPport)
RioResult	Connect (const char *MachineName)
RioResult	InitServer (const unsigned short TCPport)
RioResult	AcceptConnection (const SOCKET sock, int TimeOut=0)
RioResult	CloseSocket ()
RioResult	Disconnect ()
RioResult	Call (const unsigned int Class, const unsigned int Method, const unsigned int ParameterSize, const char *Parameter, unsigned int *ResultSize, char **Result)
RioResult	WaitConnection (SOCKET *sock)
RioResult	ReceiveCall (unsigned int *Class, unsigned int *Method, char *Parameter, unsigned int ParameterSize)
RioResult	SendResult (const char *Result, const unsigned int ResultSize)
RioResult	SendCallError (const int Status)
bool	isConnected ()
Data Fields
struct sockaddr_in	m_RemoteAddress
Private Member Functions
bool	ReceiveSocket (VOID *buffer, const unsigned int nBytes)
bool	SendSocket (const VOID *buffer, const unsigned int nBytes)
bool	ReceiveHeader (RioTCPHeader *Header)
bool	SendMessage (const RioTCPHeader *Header, const void *Data)
Private Attributes
SOCKET	m_Socket
bool	m_connected
int	m_Mode
CMutex *	m_Mutex

---

Detailed Description

Definition at line 65 of file RioTCP.h.

---

Constructor & Destructor Documentation

CRioTCP::CRioTCP

(

)

Definition at line 60 of file RioTCP.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - Constructor] Start" << endl;
    #endif

    m_Socket    = INVALID_SOCKET;
    m_connected = false;
    m_Mode      = ModeInvalid;
    m_Mutex     = NULL;

    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - Constructor] Finish" << endl;
    #endif
}

CRioTCP::~CRioTCP

(

)

Definition at line 76 of file RioTCP.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - Destructor] Single" << endl;
    #endif
}

---

Member Function Documentation

RioResult CRioTCP::AcceptConnection	(	const SOCKET	sock,
		int	TimeOut = 0
	)

Definition at line 697 of file RioTCP.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - AcceptConnection] Start" << endl;
    #endif

    // Check if not initialized
    if(m_connected)
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - AcceptConnection] Finish1" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_CONNECTED;
    }

    /*
    // set process priority to real-time
    if( SetPriorityClass( GetCurrentProcess(),
                          REALTIME_PRIORITY_CLASS ) == FALSE
      )
    {
    m_log << "AcceptConnection(): "
          << "Failed to set process priority to real-time " << endl;
    return ERROR_RIOTCP_SYS_REALTIME;
    }
    */

    //### init mode of this instance of RioTCP
    m_Mode = ModeServer;

    #ifdef WINDOWS
    // WINDOWS32 implementation
    // Initialize Windows Socket library
    WSADATA winSockInfo;
    if( WSAStartup( MAKEWORD( 2,0 ),&winSockInfo )!= 0 )
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - AcceptConnection] Finish2" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_LIBRARY;
    }
    #endif

    RioTCPHeader Header;

    // Update socket info
    m_Socket = sock;

    // Configura o socket para abortar se a conexao fechar depois de um tempo,
    // se nao houver resposta de uns dos pontos da conexao depois de um certo
    // intervalo de tempo (TimeOut segundos e 0 microsegundos), se TimeOut for
    // diferente de 0, ao receber mensagens dos clientes. Se TimeOut for 0, nao
    // existira limite, e o servidor podera esperar para sempre por mensagens
    // do cliente.
    struct timeval timeout;

    if( TimeOut != 0 )
    {
        timeout.tv_sec = TimeOut;
        timeout.tv_usec = 0;

        // Tempo maximo de espera ao receber as mensagens.
        if( setsockopt( sock, SOL_SOCKET, SO_RCVTIMEO, &timeout,
                        sizeof( timeout ) ) < 0 )
        {
            closesocket( sock );
            delete m_Mutex;
            m_Mutex = 0;
            Rioperror( "RioTCP setsockopt" );

            #ifdef RIO_DEBUG1
            RioErr << "### [RioTCP - Connect2] Finish7" << endl;
            #endif

            return ERROR_RIOTCP + ERROR_SOCKET_OPTIONS;
        }
    }
    // Configura o socket para abortar se a conexao fechar depois de um tempo,
    // se nao houver resposta de uns dos pontos da conexao depois de um certo
    // intervalo de tempo (TCPTIMEOUTSECONDS segundos e 0 microsegundos), ao
    // enviar mensagens ao cliente (respostas as requisicoes).
    timeout.tv_sec = TCPTIMEOUTSECONDS;
    timeout.tv_usec = 0;

    if( setsockopt( m_Socket, SOL_SOCKET, SO_SNDTIMEO, &timeout, 
                    sizeof( timeout ) ) < 0 )
    {
            m_Socket = INVALID_SOCKET;

            #ifdef RIO_DEBUG1
            RioErr << "### [RioTCP - AcceptConnection] Finish3" << endl;
            #endif

            return ERROR_RIOTCP + ERROR_SOCKET_OPTIONS;
    }

    // Receive Connection message
    if( ReceiveHeader(&Header) )
    {
        if( (Header.Tag == RioTCPTag) &&
            (Header.Command == RioTCPCommandConnect) )
        {
            if(Header.Version == RioTCPVersion)
            {
                // Accept connection
                Header.Command  = RioTCPCommandAccept;
                Header.Status   = S_OK;
                Header.DataSize = 0;
                SendMessage(&Header,NULL);
                m_connected     = true;
                m_Mode          = ModeServer;

                #ifdef RIO_DEBUG1
                RioErr << "### [RioTCP - AcceptConnection] Finish4" << endl;
                #endif

                return S_OK;

            }
            else
            {
                // Reject connection if there is a version mismatch
                Header.Command  = RioTCPCommandReject;
                Header.Status   = ERROR_RIOTCP + ERROR_INVALID_VERSION;
                Header.DataSize = 0;
                SendMessage(&Header,NULL);
                m_Socket        = INVALID_SOCKET;

                #ifdef RIO_DEBUG1
                RioErr << "### [RioTCP - AcceptConnection] Finish5" << endl;
                #endif

                return ERROR_RIOTCP + ERROR_INVALID_VERSION;
            }
        }
        else
        {
            m_Socket = INVALID_SOCKET;

            #ifdef RIO_DEBUG1
            RioErr << "### [RioTCP - AcceptConnection] Finish6" << endl;
            #endif

            return ERROR_RIOTCP + ERROR_RIO_PROTOCOL;
        }
    }
    else
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - AcceptConnection] Finish7" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_RECEIVE;
    }
}

RioResult CRioTCP::Call	(	const unsigned int	Class,
		const unsigned int	Method,
		const unsigned int	ParameterSize,
		const char *	Parameter,
		unsigned int *	ResultSize,
		char **	Result
	)

Definition at line 943 of file RioTCP.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - Call] Start" << endl;
    #endif

    //closing indica se Call foi chamada para fechar uma sess�o, stream ou
    //object. � utilizado pra que n�o se trave no mutex abaixo pois se esta
    //chamada n�o receber resposta o aplicativo deve prosseguir assim mesmo.
    bool closing = false;
    // Result is set to null if an error occurs
    *Result = NULL;
    *ResultSize = 0;

    // Check if  connected
    if( !m_connected )
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Call] Finish1" << endl;
        #endif

        #ifdef RIO_DEBUG2
        RioErr << "[RioTCP - Call] Error: Not connected!" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_NOTCONNECTED;
    }

    // Check if in client mode
    if( m_Mode != ModeClient )
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Call] Finish2" << endl;
        #endif

        #ifdef RIO_DEBUG2
        RioErr << "[RioTCP - Call] Error: Not client!" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_NOT_CLIENT;
    }

    // Make sure there is only one client call at a time
    // If close Object/Stream/Session don't wait
    if( !( ( ( Class == RioClassSessionManager ) &&
             ( Method == RioMethodSessionManagerClose )
           ) ||
           ( ( Class == RioClassStreamManager  ) &&
             ( Method == RioMethodStreamManagerClose  )
           ) ||
           ( ( Class == RioClassObjectManager  ) &&
             ( Method == RioMethodObjectManagerClose  )
           )
         )
      )
        m_Mutex->Wait();
    else
        closing = true;

    RioTCPHeader Header;

    Header.Tag      = RioTCPTag;
    Header.Version  = RioTCPVersion;
    Header.Command  = RioTCPCommandCall;
    Header.Status   = S_OK;
    Header.Class    = Class;
    Header.Method   = Method;
    Header.DataSize = DataSize;

    // Send message with data
    if( !SendMessage( &Header, (void*) Parameter ) )
    {
        if( !closing )
            m_Mutex->Release();

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Call] Finish3" << endl;
        #endif

        #ifdef RIO_DEBUG2
        RioErr << "[RioTCP - Call] Error socket send!" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_SEND;
    }

    // receive reply header
    if( !ReceiveHeader( &Header ) )
    {
        if( !closing )
            m_Mutex->Release();

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Call] Finish4" << endl;
        #endif

        #ifdef RIO_DEBUG2
        RioErr << "[RioTCP - Call] Error socket receive 1" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_RECEIVE;
    }

    if( Header.Command == RioTCPCommandCallError )
    {
        if( !closing )
            m_Mutex->Release();

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Call] Finish5" << endl;
        #endif

        #ifdef RIO_DEBUG2
        RioErr << "[RioTCP - Call] Call error(header): "
               << GetErrorDescription( Header.Status) << endl;
        #endif

        return Header.Status;
    }

    if( Header.Command != RioTCPCommandResult )
    {
        if( !closing )
            m_Mutex->Release();

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Call] Finish6" << endl;
        #endif

        #ifdef RIO_DEBUG2
        RioErr << "[RioTCP - Call] Error: Rio Protocol error 1." << endl;
        #endif

        return ERROR_RIOTCP + ERROR_RIO_PROTOCOL;
    }

    unsigned int Rsize = Header.DataSize;

    if( Rsize <= 0 )
    {
        if( !closing )
            m_Mutex->Release();

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Call] Finish7" << endl;
        #endif

        #ifdef RIO_DEBUG2
        RioErr << "[RioTCP - Call] Error: Rio Protocol error 2." << endl;
        #endif

        return ERROR_RIOTCP + ERROR_RIO_PROTOCOL;
    }
    /*if( Rsize > ResultSize )
    {
        if( !closing )
            m_Mutex->Release();

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Call] Finish8" << endl;
        #endif

        #ifdef RIO_DEBUG2
        RioErr << "[RioTCP - Call] Error: Rio Protocol error 3." << endl;
        #endif

        return ERROR_RIOTCP + ERROR_RIO_PROTOCOL;
    }*/
    // Agora, alocamos o buffer na funcao, para podermos receber mensagens de
    // tamanhos variados.
    *ResultSize = Rsize;
    *Result = ( char * ) malloc( Rsize * sizeof( char ) );
    if( *Result == NULL )
    {
        if( !closing )
            m_Mutex->Release();

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Call] Finish9" << endl;
        #endif

        #ifdef RIO_DEBUG2
        RioErr << "[RioTCP - Call] Error: insufficient memory." << endl;
        #endif

        return ERROR_RIOTCP + ERROR_MEMORY;
    }

    //if( !ReceiveSocket( Result, Rsize ) )
    if( !ReceiveSocket( *Result, Rsize ) )
    {
        //delete[] ResultBuffer;
        if( !closing )
            m_Mutex->Release();

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Call] Finish10" << endl;
        #endif

        #ifdef RIO_DEBUG2
        RioErr << "[RioTCP - Call] Error: socket receive 2." << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_RECEIVE;
    }

    // If close Object/Stream/Session don't release
    if( !closing )
        m_Mutex->Release();

    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - Call] Finish11" << endl;
    #endif

    return S_OK;
}

RioResult CRioTCP::CloseSocket

(

)

Definition at line 856 of file RioTCP.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - CloseSocket] Start" << endl;
    #endif

    // Check if  connected
    if(!m_connected)
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - CloseSocket] Finish1" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_NOTCONNECTED;
    }

    //### if server then might need to break waiting accept
    //    shutdown won't do this, use real close
    if( m_Mode == ModeClient )
        closesocket( m_Socket );
    else
        close( m_Socket );

    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - CloseSocket] Finish2" << endl;
    #endif

    return S_OK;

}

RioResult CRioTCP::Connect

(

const char *

MachineName

)

Definition at line 84 of file RioTCP.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - Connect1] Start" << endl;
    #endif

    // Check if not connected yet
    if(m_connected)
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect1] Finish1" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_CONNECTED;
    }

    m_Mutex = new CMutex;
    if( m_Mutex == 0 )
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect1] Finish2" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_MEMORY;
    }
    if( !(m_Mutex->IsOpen()) )
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect1] Finish3" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_CREATE_MUTEX;
    }

    SOCKET sock;

    #ifdef WINDOWS
    // WINDOWS32 implementation
        // Initialize Windows Socket library
        WSADATA winSockInfo;
        if( WSAStartup( MAKEWORD( 2,0 ),&winSockInfo )!= 0 )
        {
            #ifdef RIO_DEBUG1
            RioErr << "### [RioTCP - Connect1] Finish4" << endl;
            #endif

            return ERROR_RIOTCP + ERROR_SOCKET_LIBRARY;
        }
    #endif

    sock = socket( AF_INET, SOCK_STREAM, 0 );
    if( sock == INVALID_SOCKET )
    {
        delete m_Mutex;
        m_Mutex = 0;

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect1] Finish5" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_CREATE;
    }

    // Faz com que o socket seja exclusivo do processo, e nao seja passado 
    // para um outro processo criado pelo processo que abriu o socket.
    
    if( fcntl( sock, F_SETFD, FD_CLOEXEC ) < 0 )
    {
        close( sock );
        delete m_Mutex;
        m_Mutex = 0;
        RioErr << " RioTCP - Error setting socket as exclusive.. " << endl;

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect1] Finish6" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_OPTIONS;
    }

    // Configura o socket para abortar se a conexao fechar depois de um tempo,
    // se nao houver resposta de uns dos pontos da conexao depois de um certo
    // intervalo de tempo (TCPTIMEOUTSECONDS segundos e 0 microsegundos).
    
    struct timeval timeout;
    timeout.tv_sec = TCPTIMEOUTSECONDS;
    timeout.tv_usec = 0;
   
    // Tempo maximo de espera ao receber as mensagens. 
    if( setsockopt( sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, 
                    sizeof( timeout ) ) < 0 )
    {
        closesocket( sock );
        delete m_Mutex;
        m_Mutex = 0;
        Rioperror( "RioTCP setsockopt" );

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect1] Finish7" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_OPTIONS;
    }

    // Tempo maximo de espera ao enviar as mensagens. 
    if( setsockopt( sock, SOL_SOCKET, SO_SNDTIMEO, &timeout, 
                    sizeof( timeout ) ) < 0 )
    {
        closesocket( sock );
        delete m_Mutex;
        m_Mutex = 0;
        Rioperror( "RioTCP setsockopt" );

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect1] Finish8" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_OPTIONS;
    }
    
    // Get host IP address for server from host name
    struct hostent* hostaddress;
    hostaddress = gethostbyname(ServerName);

    if( hostaddress == NULL )
    {
        delete m_Mutex;
        m_Mutex = 0;
        closesocket( sock );

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect1] Finish9" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_HOST_NOTFOUND;
    }

    // Make TCP connection to server
    SOCKADDR_IN RemoteAddress;
    memset( &RemoteAddress,0x00,sizeof( RemoteAddress ) );
    RemoteAddress.sin_family = AF_INET;
    memcpy ((char*)&RemoteAddress.sin_addr,
            hostaddress->h_addr_list[0],
            hostaddress->h_length);
    RemoteAddress.sin_port = htons( RioTCPport );
 
    if( connect( sock,(SOCKADDR*) &RemoteAddress,sizeof( RemoteAddress ) )
            == SOCKET_ERROR )
    {
        closesocket( sock );
        delete m_Mutex;
        m_Mutex = 0;
        Rioperror( "RioTCP Connect 1" );

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect1] Finish10" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_CONNECT;
    }

    m_Socket = sock;


    // Fill connect Message fields
    RioTCPHeader      Header;
    Header.Tag      = RioTCPTag;
    Header.Version  = RioTCPVersion;
    Header.Command  = RioTCPCommandConnect;
    Header.Status   = S_OK;
    Header.Class    = 0;
    Header.Method   = 0;
    Header.DataSize = 0;

    if(!SendMessage(&Header,NULL))
    {
        m_Socket = INVALID_SOCKET;
        closesocket (sock);
        delete m_Mutex;
        m_Mutex = 0;

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect1] Finish11" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_SEND;
    }

    if(!ReceiveHeader(&Header))
    {
        m_Socket = INVALID_SOCKET;
        closesocket (sock);
        delete m_Mutex;
        m_Mutex = 0;

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect1] Finish12" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_RECEIVE;
    }

    if( Header.Command != RioTCPCommandAccept )
    {
        m_Socket = INVALID_SOCKET;
        delete m_Mutex;
        m_Mutex = 0;
        closesocket(sock);
        if( Header.Command == RioTCPCommandReject )
        {
            if(Header.Status != S_OK)
            {
                #ifdef RIO_DEBUG1
                RioErr << "### [RioTCP - Connect1] Finish13" << endl;
                #endif

                return Header.Status;
            }
        }

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect1] Finish14" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_REFUSED_CONNECTION;
    }

    m_connected = true;
    m_Mode = ModeClient;

    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - Connect1] Finish15" << endl;
    #endif

    return S_OK;
}

RioResult CRioTCP::Connect	(	const char *	MachineName,
		const unsigned short	TCPport
	)

Definition at line 322 of file RioTCP.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - Connect2] Start" << endl;
    #endif

    // Check if not connected yet
    if( m_connected )
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect2] Finish1" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_CONNECTED;
    }

    #ifdef RIO_DEBUG2
    RioErr << "### [RioTCP - Connect2] Creating mutex" << endl;
    #endif

    m_Mutex = new CMutex;
    if( m_Mutex == 0 )
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect2] Finish2" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_MEMORY;
    }

    #ifdef RIO_DEBUG2
    RioErr << "### [RioTCP - Connect2] Checking if mutex is open" << endl;
    #endif

    if( !( m_Mutex->IsOpen() ) )
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect2] Finish3" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_CREATE_MUTEX;
    }

    #ifdef RIO_DEBUG2
    RioErr << "### [RioTCP - Connect2] Creating socket" << endl;
    #endif

    SOCKET sock;

    #ifdef WINDOWS
    // WINDOWS32 implementation
        // Initialize Windows Socket library
        WSADATA winSockInfo;
        if( WSAStartup( MAKEWORD( 2, 0 ), &winSockInfo ) != 0 )
        {
            #ifdef RIO_DEBUG1
            RioErr << "### [RioTCP - Connect2] Finish4" << endl;
            #endif

            return ERROR_RIOTCP + ERROR_SOCKET_LIBRARY;
        }
    #endif

    sock = socket( AF_INET, SOCK_STREAM, 0 );
    if( sock == INVALID_SOCKET )
    {
        delete m_Mutex;
        m_Mutex = 0;
        RioErr << " RioTCP - Error creating socket .. " << endl;

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect2] Finish5" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_CREATE;
    }
    
    // Faz com que o socket seja exclusivo do processo, e nao seja passado 
    // para um outro processo criado pelo processo que abriu o socket.
    
    if( fcntl( sock, F_SETFD, FD_CLOEXEC ) < 0 )
    {
        close( sock );
        delete m_Mutex;
        m_Mutex = 0;
        RioErr << " RioTCP - Error setting socket as exclusive.. " << endl;

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect2] Finish6" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_OPTIONS;
    }

    // Configura o socket para abortar se a conexao fechar depois de um tempo,
    // se nao houver resposta de uns dos pontos da conexao depois de um certo
    // intervalo de tempo (TCPTIMEOUTSECONDS segundos e 0 microsegundos).
    
    struct timeval timeout;
    timeout.tv_sec = TCPTIMEOUTSECONDS;
    timeout.tv_usec = 0;
   
    // Tempo maximo de espera ao receber as mensagens. 
    if( setsockopt( sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, 
                    sizeof( timeout ) ) < 0 )
    {
        closesocket( sock );
        delete m_Mutex;
        m_Mutex = 0;
        Rioperror( "RioTCP setsockopt" );

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect2] Finish7" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_OPTIONS;
    }

    // Tempo maximo de espera ao enviar as mensagens. 
    if( setsockopt( sock, SOL_SOCKET, SO_SNDTIMEO, &timeout, 
                    sizeof( timeout ) ) < 0 )
    {
        closesocket( sock );
        delete m_Mutex;
        m_Mutex = 0;
        Rioperror( "RioTCP setsockopt" );

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect2] Finish8" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_OPTIONS;
    }

    #ifdef RIO_DEBUG2
    RioErr << "### [RioTCP - Connect2] Resolving host name" << endl;
    #endif

    // Get host IP address for server from host name
    struct hostent* hostaddress;
    hostaddress = gethostbyname( ServerName );

    if( hostaddress == NULL )
    {
        delete m_Mutex;
        m_Mutex = 0;
        closesocket( sock );

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect2] Finish9" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_HOST_NOTFOUND;
    }

    #ifdef RIO_DEBUG2
    RioErr << "### [RioTCP - Connect2] Making TCP connection to server... " << endl;
    #endif

    // Make TCP connection to server
    SOCKADDR_IN RemoteAddress;
    memset( &RemoteAddress,0x00,sizeof( RemoteAddress ) );
    RemoteAddress.sin_family = AF_INET;
    memcpy((char*)&RemoteAddress.sin_addr,
            hostaddress->h_addr_list[0],
            hostaddress->h_length);

    #ifdef RIO_DEBUG2
    RioErr << "### [RioTCP - Connect2] Port: " << TCPport << endl;
    #endif

    RemoteAddress.sin_port = htons( TCPport );

    if( connect( sock,(SOCKADDR*) &RemoteAddress,sizeof( RemoteAddress ) )
            == SOCKET_ERROR )
    {
        closesocket (sock);
        delete m_Mutex;
        m_Mutex = 0;
        RioErr << " RioTCP - Error connecting socket ... " << endl;
        Rioperror( "RioTCP Connect 2" );

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect2] Finish10" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_CONNECT;
    }

    m_Socket = sock;

    // Fill connect Message fields
    RioTCPHeader      Header;
    Header.Tag      = RioTCPTag;
    Header.Version  = RioTCPVersion;
    Header.Command  = RioTCPCommandConnect;
    Header.Status   = S_OK;
    Header.Class    = 0;
    Header.Method   = 0;
    Header.DataSize = 0;

    #ifdef RIO_DEBUG2
    RioErr << "### [RioTCP - Connect2] Sending TCP Message" << endl;
    #endif
    
    if( !SendMessage( &Header, NULL ) )
    {
        m_Socket = INVALID_SOCKET;
        closesocket (sock);
        delete m_Mutex;
        m_Mutex = 0;

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect2] Finish11" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_SEND;
    }

    #ifdef RIO_DEBUG2
    RioErr << "### [RioTCP - Connect2] Receiving TCP Header" << endl;
    #endif

    if( !ReceiveHeader( &Header ) )
    {
        m_Socket = INVALID_SOCKET;
        closesocket (sock);
        delete m_Mutex;
        m_Mutex = 0;

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect2] Finish12" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_RECEIVE;
    }

    #ifdef RIO_DEBUG2
    RioErr << "### [RioTCP - Connect2] Analysing Header" << endl;
    #endif

    if( Header.Command != RioTCPCommandAccept )
    {
        m_Socket = INVALID_SOCKET;
        delete m_Mutex;
        m_Mutex = 0;
        closesocket (sock);
        if( Header.Command == RioTCPCommandReject )
        {
            if( Header.Status != S_OK )
            {
                #ifdef RIO_DEBUG1
                RioErr << "### [RioTCP - Connect2] Finish13" << endl;
                #endif

                return Header.Status;
            }
        }

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Connect2] Finish14" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_REFUSED_CONNECTION;
    }

    m_connected = true;
    m_Mode = ModeClient;

    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - Connect2] Finish15" << endl;
    #endif

    return S_OK;
}

RioResult CRioTCP::Disconnect

(

)

Definition at line 887 of file RioTCP.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - Disconnect] Start" << endl;
    #endif

    // Check if  connected
    if( !m_connected )
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - Disconnect] Finish1" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_NOTCONNECTED;
    }

    // If client mode send disconnect message before closing socket
    if(m_Mode == ModeClient)
    {
        m_Mutex->Wait();
        RioTCPHeader Header;

        Header.Tag      = RioTCPTag;
        Header.Version  = RioTCPVersion;
        Header.Command  = RioTCPCommandDisconnect;
        Header.Status   = S_OK;
        Header.Class    = 0;
        Header.Method   = 0;
        Header.DataSize = 0;
        SendMessage( &Header, NULL );
        delete m_Mutex;
        m_Mutex = 0;
    }

    closesocket( m_Socket );

    #ifdef WINDOWS
    // WINDOWS32 implementation
        // Clean up windows socket library
        WSACleanup();
    #endif

    m_Socket = INVALID_SOCKET;
    m_Mode = ModeInvalid;
    m_connected = false;

    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - Disconnect] Finish2" << endl;
    #endif

    return S_OK;
}

RioResult CRioTCP::InitServer

(

const unsigned short

TCPport

)

Definition at line 600 of file RioTCP.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - InitServer] Start" << endl;
    #endif

    // Check if not initialized
    if( m_connected )
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - InitServer] Finish1" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_CONNECTED;
    }

    SOCKET sock;

    #ifdef WINDOWS
    // WINDOWS32 implementation
    // setup winsock
    WSADATA winSockInfo;
    if( WSAStartup( MAKEWORD( 2, 0 ),&winSockInfo )!= 0 )
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - InitServer] Finish2" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_LIBRARY;
    }
    #endif

    // Create socket for receiving connections from clients
    sock = socket( AF_INET,SOCK_STREAM,0 );
    if(sock == INVALID_SOCKET)
    {
        RioErr << "RioTCP: IF SOCK" << endl;

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - InitServer] Finish3" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_CREATE;
    }

    // ### set SO_REUSEADDR option so can reopen even if old sessions exist
    int flag = 1;
    int rc = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag));

    if( rc != 0)
        RioErr << "RioTCP: Error on setsockopt (sock, SOL_SOCKET,"
               << "SO_REUSEADDR, ...): " << rc << endl;

    // bind socket to port.
    SOCKADDR_IN ourAddress;
    memset( &ourAddress,0x00, sizeof( ourAddress ) );
    ourAddress.sin_family       = AF_INET;
    ourAddress.sin_addr.s_addr  = htonl( INADDR_ANY );
    ourAddress.sin_port         = htons( TCPport );
    if( bind( sock,(SOCKADDR*) &ourAddress,sizeof( ourAddress ) )
            == SOCKET_ERROR )
    {
        RioErr << "RioTCP: ERRO BIND: " << strerror( errno ) << endl;

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - InitServer] Finish4" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_BIND;
    }
    if( listen( sock, SOMAXCONN )!= 0 )
    {
        RioErr << "RioTCP: ERRO LISTEN" << endl;

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - InitServer] Finish5" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_LISTEN;
    }

    m_connected = true;
    m_Mode = ModeServerMaster;
    m_Socket = sock;

    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - InitServer] Finish6" << endl;
    #endif

    return S_OK;
}

bool CRioTCP::isConnected

(

void

)

Definition at line 1696 of file RioTCP.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - isConnected] Single" << endl;
    #endif

    return m_connected;
}

RioResult CRioTCP::ReceiveCall	(	unsigned int *	Class,
		unsigned int *	Method,
		char *	Parameter,
		unsigned int	ParameterSize
	)

Definition at line 1166 of file RioTCP.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - ReceiveCall] Start" << endl;
    #endif

    //  // Parameter is set to null if an error occurs
    //  *Parameter = 0;
    //  *ParameterSize = 0;

    // Check if  connected
    if( !m_connected )
    {
        RioErr << "ERROR_RIOTCP + ERROR_NOTCONNECTED " << endl;

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - ReceiveCall] Finish1" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_NOTCONNECTED;
    }

    // Check if in server mode
    if( m_Mode != ModeServer )
    {
        RioErr << "ERROR_RIOTCP + ERROR_NOT_SERVER " << endl;

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - ReceiveCall] Finish2" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_NOT_SERVER;
    }

    RioTCPHeader Header;
    if( ReceiveHeader( &Header ) )
    {
        if( ( Header.Tag == RioTCPTag             ) &&
            ( Header.Version == RioTCPVersion     ) &&
            ( Header.Command == RioTCPCommandCall )
          )
        {
            if( Header.DataSize > 0 )
            {
                if( Header.DataSize > ParameterSize )
                {
                    #ifdef RIO_DEBUG1
                    RioErr << "### [RioTCP - ReceiveCall] Finish3" << endl;
                    #endif

                    return ERROR_RIOTCP + ERROR_RIO_PROTOCOL;
                }
                if( !ReceiveSocket( Parameter, Header.DataSize ) )
                {
                    #ifdef RIO_DEBUG1
                    RioErr << "### [RioTCP - ReceiveCall] Finish4" << endl;
                    #endif

                    return ERROR_RIOTCP + ERROR_SOCKET_RECEIVE;
                }
            }
            else
            {
                //*Parameter = 0;
                //*ParameterSize = 0;
            }

            *Class  = Header.Class;
            *Method = Header.Method;

            #ifdef RIO_DEBUG1
            RioErr << "### [RioTCP - ReceiveCall] Finish5" << endl;
            #endif

            return S_OK;
        }
        else
        {
            // test added to know when the user --------------------
            // disconnected or it was an error
            if( ( Header.Tag == RioTCPTag ) &&
                ( Header.Version == RioTCPVersion ) &&
                ( Header.Command == RioTCPCommandDisconnect ) )
            {
                #ifdef RIO_DEBUG1
                RioErr << "### [RioTCP - ReceiveCall] Finish6" << endl;
                #endif

                return ERROR_RIOTCP + ERROR_CLOSED_CONNECTION;
            }
            else
            {
                #ifdef RIO_DEBUG1
                RioErr << "### [RioTCP - ReceiveCall] Finish7" << endl;
                #endif

                return ERROR_RIOTCP + ERROR_RIO_PROTOCOL;
            }
            // ----------------------------------------------------------------
        }
    }
    else
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - ReceiveCall] Finish8" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_RECEIVE;
    }
}

bool CRioTCP::ReceiveHeader

(

RioTCPHeader *

Header

)

[private]

Definition at line 1575 of file RioTCP.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - ReceiveHeader] Start" << endl;
    #endif

    RioTCPHeader LocalHeader;

    bool result = ReceiveSocket(&LocalHeader,TCPHeaderSize);

    if( result )
    {
        // Convert network byte order of header to host byte order
        Header->Tag      = ntohl(LocalHeader.Tag);
        Header->Version  = ntohl(LocalHeader.Version);
        Header->Command  = ntohl(LocalHeader.Command);
        Header->Status   = ntohl(LocalHeader.Status);
        Header->Class    = ntohl(LocalHeader.Class);
        Header->Method   = ntohl(LocalHeader.Method);
        Header->DataSize = ntohl(LocalHeader.DataSize);

    // ### debug
    #if 0
        RioErr << "ReceiveHeader: "
               << "Tag: " << Header->Tag
               << " Version:" << Header->Version
               << " Command:" << Header->Command
               << " Status:" << Header->Status
               << " Class:" << Header->Class
               << " Method:" << Header->Method
               << " DataSize:" << Header->DataSize << endl;
    #endif

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - ReceiveHeader] Finish1" << endl;
        #endif

        return true;
    }
    else
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - ReceiveHeader] Finish2" << endl;
        #endif

        return false;
    }

}

bool CRioTCP::ReceiveSocket	(	VOID *	buffer,
		const unsigned int	nBytes
	)			[private]

Definition at line 1473 of file RioTCP.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - ReceiveSocket] Start" << endl;
    #endif

    unsigned int  TotalBytes = 0;
    char          *buf = (char*)buffer;
    int            n = 0;

    // Message can be received in several packets
    // Keep reading socket until expected number of bytes arrive
    // or an error occurs
    while( TotalBytes < nBytes )
    {
        n = recv(m_Socket,buf+TotalBytes,nBytes-TotalBytes,0);

        if( ( n == SOCKET_ERROR ) || ( n == 0 ) )
        {
            #ifdef RIO_DEBUG1
            if( n < 0 )
                RioErr << "CRioTCP::ReceiveSocket rc " << n << " errno "
                       << strerror(errno) << endl;

            RioErr << "### [RioTCP - ReceiveSocket] Finish1" << endl;
            #endif
            
            return false;
        }

        TotalBytes+=n;
    }
    
    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - ReceiveSocket] Finish2" << endl;
    #endif

    return true;
}

RioResult CRioTCP::SendCallError

(

const int

Status

)

Definition at line 1337 of file RioTCP.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - SendCallError] Start" << endl;
    #endif

    // Check if  connected
    if( !m_connected )
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - SendCallError] Finish1" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_NOTCONNECTED;
    }

    // Check if in server mode
    if( m_Mode != ModeServer )
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - SendCallError] Finish2" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_NOT_SERVER;
    }

    RioTCPHeader Header;
    Header.Tag      = RioTCPTag;
    Header.Version  = RioTCPVersion;
    Header.Command  = RioTCPCommandCallError;
    Header.Status   = Status;
    // Class and method not necessary on call error message
    Header.Class    = 0;
    Header.Method   = 0;
    Header.DataSize = 0;

    if( SendMessage( &Header,NULL ) )
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - SendCallError] Finish3" << endl;
        #endif

        return S_OK;
    }
    else
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - SendCallError] Finish4" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_SEND;
    }
}

bool CRioTCP::SendMessage	(	const RioTCPHeader *	Header,
		const void *	Data
	)			[private]

Definition at line 1626 of file RioTCP.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - SendMessage] Start" << endl;
    #endif

    bool rc = true;
    unsigned char *SendData;

    // We copy the message to a Local Buffer where header and data are
    // stored continuously and thus can be sent on a single send() call
    // This add an additional copy of data.
    // We do this because sending Header and Data on two separate send()
    // calls cause a large latency between both messages (reason unknown)
    // Ideally we would like a send () function that could gather data
    // from non contiguous regions of memory and send them on the same
    // network packet.
 
    RioTCPHeader MessageHeader;
    MessageHeader.Tag      = htonl(Header->Tag);
    MessageHeader.Version  = htonl(Header->Version);
    MessageHeader.Command  = htonl(Header->Command);
    MessageHeader.Status   = htonl(Header->Status);
    MessageHeader.Class    = htonl(Header->Class);
    MessageHeader.Method   = htonl(Header->Method);
    MessageHeader.DataSize = htonl(Header->DataSize);

    // Aloca espaco na memoria para a mensagem a ser enviada.

    SendData = new unsigned char[ TCPHeaderSize + Header->DataSize ];

    if( SendData == NULL )
    {
        RioErr << "### [RioTCP - SendMessage] insufficient memory" << endl;  
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - SendMessage] Finish1" << endl;
        #endif
        return false;
    }

    // Copia o Header para o buffer.
    memcpy( SendData, &MessageHeader, sizeof( RioTCPHeader ) * 
                                      sizeof( unsigned char ) );
    // Copia os dados para o buffer.
    if( Header->DataSize > 0 )
        memcpy( SendData + sizeof( RioTCPHeader ), Data, Header->DataSize );

    // ### debugging
    #if 0
    RioErr << "SendMessage: "
           << " Command " << Header->Command
           << " Status "  << (int *) Header->Status
           << " Class "   << Header->Class
           << " Method "  << Header->Method
           << " DataSize " << Header->DataSize << endl;
    #endif

    rc = SendSocket( SendData, TCPHeaderSize + Header->DataSize );
    // Libera a memoria usada pela mensagem

    delete[] SendData;

    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - SendMessage] Finish2" << endl;
    #endif

    return rc;
}

RioResult CRioTCP::SendResult	(	const char *	Result,
		const unsigned int	ResultSize
	)

Definition at line 1281 of file RioTCP.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - SendResult] Start" << endl;
    #endif

    // Check if  connected
    if(!m_connected)
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - SendResult] Finish1" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_NOTCONNECTED;
    }

    // Check if in server mode
    if(m_Mode != ModeServer)
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - SendResult] Finish2" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_NOT_SERVER;
    }

    RioTCPHeader Header;
    Header.Tag      = RioTCPTag;
    Header.Version  = RioTCPVersion;
    Header.Command  = RioTCPCommandResult;
    Header.Status   = S_OK;
    // Class and method not necessary on call result message
    Header.Class    = 0;
    Header.Method   = 0;
    Header.DataSize = ResultSize;

    if(SendMessage(&Header,(void*) Result))
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - SendResult] Finish3" << endl;
        #endif

        return S_OK;
    }
    else
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - SendResult] Finish4" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_SOCKET_SEND;
    }
}

bool CRioTCP::SendSocket	(	const VOID *	buffer,
		const unsigned int	nBytes
	)			[private]

Definition at line 1515 of file RioTCP.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - SendSocket] Start" << endl;
    #endif

    unsigned int TotalBytes = 0;
    const char *buf = (const char*)buffer;
    int n;

    // Message can be sent in several packets
    // Keep writing socket until expected number of bytes are sent
    // or an error occurs

    while( TotalBytes < nBytes )
    {
        n = send( m_Socket,buf+TotalBytes,nBytes-TotalBytes,MSG_NOSIGNAL );
        if( n == SOCKET_ERROR )

        {
            if( errno == EINTR )
            {
                 TotalBytes+=n;
                 continue;
            }
            else
            {
                Rioperror( "RioTCP - receivesocket error " );
                RioErr << "RioTCP - receivesocket valor de n: " << n << endl;

                if( errno == EPIPE )
                    m_connected = false;

                #ifdef RIO_DEBUG1
                RioErr << "### [RioTCP - SendSocket] Finish1" << endl;
                #endif

                return false;
            }
        }
        else
        {
            if( errno == EINTR )
            {
                 TotalBytes+=n;
                 continue;
            }
        }
        TotalBytes+=n;
    }

    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - SendSocket] Finish2" << endl;
    #endif

    return true;
}

RioResult CRioTCP::WaitConnection

(

SOCKET *

sock

)

Definition at line 1392 of file RioTCP.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - WaitConnection] Start" << endl;
    #endif

    // Check if  connected
    if( !m_connected )
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - WaitConnection] Finish1" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_NOTCONNECTED;
    }

    // Check if in server master mode
    if( m_Mode != ModeServerMaster )
    {
        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - WaitConnection] Finish2" << endl;
        #endif

        return ERROR_RIOTCP + ERROR_NOT_SERVER;
    }

    struct sockaddr_in remoteAddress;
    SOCKET ConnectedSocket;

    // added to get remote client address --------------------------
    int remoteAddressl;

    remoteAddressl = sizeof( remoteAddress );
    memset( &remoteAddress, 0, sizeof( remoteAddressl ));
    remoteAddress.sin_family = AF_INET;
    // ------------------------------------------------------------------------

    // Wait for client connection
    ConnectedSocket = accept( m_Socket, (struct sockaddr *)&remoteAddress,
                             (socklen_t *)&remoteAddressl);

    if( ConnectedSocket == INVALID_SOCKET )
    {
        int error = errno; // Armazena o erro retornado pelo accept.

        RioErr << "[RioTCP - WaitConnection] Erro " << error << " ("
               << strerror( error ) << " retornado ao executar o accept!"
               << endl;

        #ifdef RIO_DEBUG1
        RioErr << "### [RioTCP - WaitConnection] Finish3" << endl;
        #endif

        // Verifica se o erro e ou nao critico.
        if( ( error == EBADF ) || ( error == EFAULT ) || ( error == EINTR ) ||
            ( error == EINVAL ) || ( error == ENOTSOCK ) ||
            ( error == EOPNOTSUPP ) )
            return ERROR_RIOTCP + ERROR_SOCKET_ACCEPT_CRITICAL;
        else
            return ERROR_RIOTCP + ERROR_SOCKET_ACCEPT;
    }

    #ifdef RIO_DEBUG2
    RioErr << "[RioTCP] Nova conex�o de host vindo de "
           << inet_ntoa( remoteAddress.sin_addr ) << ":"
           << htons( remoteAddress.sin_port ) << endl;
    #endif

    //A atribui��o abaixo � v�lida no C++ (n�o preciso do memcpy)
    m_RemoteAddress = remoteAddress;

    *sock = ConnectedSocket;

    #ifdef RIO_DEBUG1
    RioErr << "### [RioTCP - WaitConnection] Finish4" << endl;
    #endif

    return S_OK;
}

---

Field Documentation

bool CRioTCP::m_connected [private]

Definition at line 69 of file RioTCP.h.

int CRioTCP::m_Mode [private]

Definition at line 70 of file RioTCP.h.

CMutex* CRioTCP::m_Mutex [private]

Definition at line 71 of file RioTCP.h.

struct sockaddr_in CRioTCP::m_RemoteAddress

Definition at line 110 of file RioTCP.h.

SOCKET CRioTCP::m_Socket [private]

Definition at line 68 of file RioTCP.h.

---

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

• RioTCP.h
• RioTCP.cpp