C:/Active/libraries/cxutils/2.0/src/cxutils/networking/tcplistensocket.cpp

Go to the documentation of this file.

#include "cxutils/networking/tcplistensocket.h"
#include "cxutils/networking/tcpserver.h"
#include "cxutils/networking/socket.h"
#include <string.h>
#include <iostream>

using namespace std;

#ifdef WIN32
unsigned int CxUtils::TcpListenSocket::mWinsockInitCount = 0;
#else
#include <netinet/tcp.h>
#endif


using namespace CxUtils;

TcpListenSocket::TcpListenSocket()
{
    mSocket =  0;
    mServiceLength = 0;
    memset(&mService, 0, sizeof(struct sockaddr_in));
    mPort = 0;
    mGoodSocket = false;
    mComputer = 0;
    mpHP = NULL;
    mNetworkInterface = -1;
#ifdef WIN32
    //  In windows you must initialize
    //  the winsock dll
    if(mWinsockInitCount == 0)
    {
        WSADATA wsaData;
        // Initialize Winsock
        WSAStartup(MAKEWORD(2,2), &wsaData);

        // Increase static counter
        mWinsockInitCount++;
    }
    else
    {
        mWinsockInitCount++;
    }
#endif
}


TcpListenSocket::~TcpListenSocket()
{
    Shutdown();
#ifdef WIN32
    mWinsockInitCount--;
    if(mWinsockInitCount == 0)
    {
        // Deinitialize the ws2_32.dll
        // from winsock libraries
        // this must be called.
        WSACleanup();
    }
#endif
}


bool TcpListenSocket::SetNetworkInterface(const int num)
{
    mNetworkInterface = num;
    return true;
}


bool TcpListenSocket::SetNetworkInterface(const IP4Address& ipAddress)
{
    int num = Socket::GetNetworkInterface(ipAddress);
    if(num >= 0)
    {
        return SetNetworkInterface(num);
    }
    return false;
}


int TcpListenSocket::InitializeSocket(const unsigned short port,
                                      const unsigned int queuesize,
                                      const unsigned int stimeout,
                                      const unsigned int rtimeout,
                                      const int nonblocking)
{
#ifdef WIN32
    SOCKET listenSocket;
#else
    int listenSocket;
#endif
    int result = 0;

    // Close any previous socket we were listening on.
    Shutdown();

    listenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

    if(listenSocket > 0) 
    {
        //  Set blocking/non-blocking options
        if(nonblocking > 0) 
        {
#ifdef WIN32
            u_long noblock = 1;
            if(ioctlsocket(listenSocket, FIONBIO, &noblock) == SOCKET_ERROR) 
            {
                mGoodSocket = false;
                return 0;
            }
#else
            unsigned int noblock = 1;
            if(ioctl(listenSocket, FIONBIO, &noblock) == -1) 
            {
                cout << "Non Blocking Failure!\n";
                mGoodSocket = false;
                return 0;
            }
#endif
        }

        /*  Copy the port number and set the
            service information for the socket. */
        mPort = port;
        memset(&this->mService, 0, sizeof(struct sockaddr_in) );
        this->mServiceLength = sizeof(mService);

        this->mService.sin_family = AF_INET;                    //  AF_INET for TCP communication
        this->mService.sin_port = htons(mPort);                 //  Convert port number to network byte order.
        this->mService.sin_addr.s_addr = htonl(INADDR_ANY);     //  Set network address to listen on.
        /*
        if(mNetworkInterface >= 0)
        {
            IP4Address::List myHostnames;
            Socket::GetHostAddresses(myHostnames);
            if(mNetworkInterface < (int)(myHostnames.size()))
            {
                this->mService.sin_addr.s_addr = *((long *)gethostbyname(myHostnames[mNetworkInterface].mString.c_str())->h_addr);
            }
        }
        */

        // Bind the socket to the port and service.
        if( bind(listenSocket, (struct sockaddr *)& this->mService, sizeof(mService)) >= 0 ) 
        {
            //  Setup incomming connections for listening on the socket.
            if(listen(listenSocket, queuesize) < 0) 
            {
                /*  On a failure close the socket
                    and return false. */
                #ifdef WIN32
                    closesocket(listenSocket);
                #else
                    close(listenSocket);
                #endif

                Shutdown();  //  Ensure defaults are set.
                result = false;
                return result;
            }
            else
            {
                /*  If we get to this point, set the default send and
                    receive timeout options for the socket. */
#ifdef WIN32
                setsockopt(listenSocket, SOL_SOCKET, SO_RCVTIMEO , (char *)&rtimeout, sizeof(int));
                setsockopt(listenSocket, SOL_SOCKET, SO_SNDTIMEO , (char *)&stimeout, sizeof(int));
                int nodelay = 1;
                setsockopt(listenSocket, IPPROTO_TCP, TCP_NODELAY, (char *)&nodelay, sizeof(int));
#else
                setsockopt(listenSocket, SOL_SOCKET, SO_RCVTIMEO, &rtimeout, sizeof(int));
                setsockopt(listenSocket, SOL_SOCKET, SO_SNDTIMEO, &stimeout, sizeof(int));
                int nodelay = 1;
                setsockopt(listenSocket, IPPROTO_TCP, TCP_NODELAY,  &nodelay, sizeof(int));
#endif
                /*  Everything has been initialized ok, so copy the
                    data from the temporary listenSocket to our
                    final socket destination (mSocket). */
                memcpy(&this->mSocket, &listenSocket, sizeof(int));
                result = 1;
            }
        }
    }

#ifdef WIN32
    int value;

    value = WSAGetLastError();
#endif

    /*  If we failed to create
        the socket, then lets close/clear out
        what has been done */
    if(!result) 
    {
        Shutdown();
        mGoodSocket = false;
    }
    else 
    {
        mGoodSocket = true;
    }

    return result;
}


void TcpListenSocket::Shutdown()
{
#ifdef WIN32
    shutdown(mSocket, 1);
    closesocket(mSocket);
#else
    if(mSocket > 0)
    {
        if(shutdown(mSocket, 1) == 0)
        {
            mSocket = 0;
        }
    }
    if(mSocket > 0)
    {
        close(mSocket);
    }
#endif
    mSocket = 0;
    this->mGoodSocket = false;
    mServiceLength = 0;
    memset(&mService, 0, sizeof(struct sockaddr_in));
    mPort = 0;
    mpHP = NULL;
    mComputer = 0;
}

int TcpListenSocket::AwaitConnection(TcpServer& socket) const
{
    int tSocket;    // Temporary file descriptor

    int tSendAddrLength = sizeof(struct sockaddr_in);
    struct sockaddr tSendAddr;

    socket.Shutdown();

    /*  Only valid sockets and TCP Listen sockets
        can perform an await connection */
    if( !IsValid() )
        return 0;

    tSocket = -1;

    //  Try an accept an incomming connection attempt.
#ifdef WIN32
    tSocket = (int)accept(mSocket,
                         (struct sockaddr *) &tSendAddr,
                         &tSendAddrLength);
#else
    tSocket = accept(mSocket,
                     (struct sockaddr *) &tSendAddr,
                     (socklen_t *)&tSendAddrLength);
#endif

    if(tSocket == -1)
        return 0;

    socket.mGoodSocket = true;
    socket.mSocket = tSocket;
    socket.mService = this->mService;
    socket.mServiceLength = this->mServiceLength;
    socket.mSocketType = Socket::TCPServer;
    struct sockaddr_in inSocket;
    memcpy(&inSocket, &tSendAddr, sizeof(struct sockaddr_in));
    socket.mClientAddress = std::string(inet_ntoa(inSocket.sin_addr));

    return 1;
}

TcpServer *TcpListenSocket::AwaitConnection() const
{
    int tSocket;    // Temporary file descriptor

    int tSendAddrLength = sizeof(struct sockaddr_in);
    struct sockaddr tSendAddr;

    /*  Only valid sockets and TCP Listen sockets
        can perform an await connection */
    if( !IsValid() )
        return NULL;

    tSocket = -1;

    //  Try an accept an incomming connection attempt.
#ifdef WIN32
    tSocket = (int)accept(mSocket,
                         (struct sockaddr *) &tSendAddr,
                         &tSendAddrLength);
#else
    tSocket = accept(mSocket,
                     (struct sockaddr *) &tSendAddr,
                     (socklen_t *)&tSendAddrLength);
#endif

    if(tSocket == -1)
        return NULL;

    TcpServer *newSocket = new TcpServer();
    newSocket->mGoodSocket = true;
    newSocket->mSocket = tSocket;
    newSocket->mService = this->mService;
    newSocket->mServiceLength = this->mServiceLength;
    newSocket->mSocketType = Socket::TCPServer;
    struct sockaddr_in inSocket;
    memcpy(&inSocket, &tSendAddr, sizeof(struct sockaddr_in));
    newSocket->mClientAddress = std::string(inet_ntoa(inSocket.sin_addr));

    return newSocket;
}

/*  End of File */