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

Go to the documentation of this file.

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

#ifdef WIN32
#else
#include <stdio.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <net/if.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#endif

using namespace CxUtils;

#ifdef WIN32
unsigned int Socket::mWinsockInitCount = 0;
#endif


Socket::Socket()
{
    mSocket =  0;
    mNetworkInterface = -1;
    mSocketType = Undefined;
    mServiceLength = 0;
    memset(&mService, 0, sizeof(struct sockaddr_in));
    mGoodSocket = false;

#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
}


Socket::Socket(const Socket& arg)
{
    mSocket =  0;
    mNetworkInterface = -1;
    mSocketType = Undefined;
    mServiceLength = 0;
    memset(&mService, 0, sizeof(struct sockaddr_in));
    mGoodSocket = false;

#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

    *this = arg;
}


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


void Socket::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;
    mServiceLength = 0;
    memset(&mService, 0, sizeof(struct sockaddr_in));
    this->mGoodSocket = false;
}


int Socket::Send(const Packet &packet) const
{
    return SendFromBuffer(((const char *)(packet.Ptr())), packet.Size());
}


int Socket::Send(const char* buffer, const unsigned int length) const
{
    return SendFromBuffer(buffer, length);
}


int Socket::Recv(Packet &packet, 
                 const unsigned int receiveSize, 
                 const long int timeOutMilliseconds,
                 IPAddress* ipAddress,
                 unsigned short* port) const
{
    int results = 0;
    packet.Clear(false);
    packet.Reserve(receiveSize);
    if( (results = RecvToBuffer((char *)(packet.Ptr()), 
                                receiveSize, 
                                timeOutMilliseconds,
                                ipAddress, 
                                port)) > 0) 
    {
        packet.SetLength((unsigned int)results);
        packet.SetWritePos(0);
        packet.SetReadPos(0);
        return results;
    }
    return results;
}


int Socket::Recv(char* buffer, const unsigned int length, 
                 const long int timeOutMilliseconds,
                 IPAddress* ipAddress,
                 unsigned short* port) const
{
    return RecvToBuffer(buffer, length, timeOutMilliseconds, ipAddress, port);
}


bool Socket::IsValid() const
{
    return mGoodSocket;
}


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


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


int Socket::GetNetworkInterface(const IP4Address& ipAddress)
{
    IP4Address::List hostnames;
    if(GetHostAddresses(hostnames))
    {
        IP4Address::List::iterator host;
        int num = 0;
        for(host = hostnames.begin(); host != hostnames.end(); host++)
        {
            if(*host == ipAddress)
            {
                return num;
            }
            num++;
        }
    }

    return -1;
}


int Socket::GetSocket() const
{
#ifdef WIN32
    return (int)mSocket;
#else
    return mSocket;
#endif
}

Socket::Type Socket::GetType() const
{
    return mSocketType;
}


int Socket::GetNetworkInterface() const { return mNetworkInterface; }


unsigned int Socket::GetHostAddresses(IP4Address::List& ipAddresses)
{
    ipAddresses.clear();

#ifdef WIN32
    bool result = false;
    char ac[512];
    if(Socket::mWinsockInitCount == 0)
    {
        Socket::InitializeSockets();
    }
    memset(ac, 0, 512);
    if(gethostname(ac, 512) == 0) 
    {
        struct hostent *phe = gethostbyname(ac);
        if(phe != 0) 
        {
            struct in_addr addr;
            for(int i = 0; phe->h_addr_list[i] != 0; i++) 
            {
                memcpy(&addr, phe->h_addr_list[i], sizeof(struct in_addr));
                ipAddresses.push_back( IP4Address(std::string(inet_ntoa(addr))));
            }
        }
    }
#else
    struct ifreq   buffer[32];
    struct ifconf  intfc;
    struct ifreq  *pIntfc;
    int            i, fd, num_intfc;

    intfc.ifc_len = sizeof(buffer);
    intfc.ifc_buf = (char*) buffer;

    if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
    {
        perror("socket() failed");
        return false;
    }

    if (ioctl(fd, SIOCGIFCONF, &intfc) < 0)
    {
        perror("ioctl SIOCGIFCONF failed");
        return false;
    }

    pIntfc    = intfc.ifc_req;
    num_intfc = intfc.ifc_len / sizeof(struct ifreq);

    for (i = 0; i < num_intfc; i++)
    {
        struct ifreq *item = &(pIntfc[i]);
        ipAddresses.push_back( IP4Address(std::string(inet_ntoa(((struct sockaddr_in *)&item->ifr_addr)->sin_addr))) );
    }
    close(fd);
#endif

    return (unsigned int)ipAddresses.size();
}


unsigned int Socket::GetNumNetworkConnections()
{
    IP4Address::List ipAddresses;
    return GetHostAddresses(ipAddresses);
}


bool Socket::IsHostAddress(const IP4Address& ipAddress)
{
    IP4Address::List ipAddresses;
    if(ipAddress.mData[0] == 127 && ipAddress.mData[1] == 0 && ipAddress.mData[2] == 0)
    {
        return true;
    }
    if(GetHostAddresses(ipAddresses))
    {
        for(unsigned int i = 0; i < (unsigned int)ipAddresses.size(); i++)
        {
            if(ipAddresses[i] == ipAddress)
            {
                return true;
            }
        }
    }
    return false;
}


int Socket::IsIncommingData(const Socket *sock, const long int tms)
{
    if(!sock || !sock->mGoodSocket)
        return 0;

    if(tms == 0)
        return 1;

#ifdef WIN32
    fd_set fds;
    timeval tval;

    //  Populate a timeval structure
    tval.tv_sec = 0;
    tval.tv_usec = tms*1000;

    fds.fd_array[0] = ((SOCKET)(sock->mSocket));
    fds.fd_count = 1;

    ::select(0, &fds, NULL, NULL, &tval);
    if(fds.fd_count != 1)
        return 0;

    return 1;
#else
    fd_set fds;
    int s;
    timeval tval;
    s = sock->mSocket;

    FD_ZERO(&fds);
    FD_SET(s, &fds);

    //  Populate a timeval structure
    tval.tv_sec = 0;
    tval.tv_usec = tms*1000;

    select(s + 1, &fds, (fd_set *)0, (fd_set *)0,
           (struct timeval *)&tval);
    if(FD_ISSET(s, &fds) != 0)   //  Is the file descripter set for s?
        return 1;

    return 0;
#endif

}


Socket &Socket::operator = (const Socket &arg)
{
    this->mSocket = arg.mSocket;
    this->mServiceLength = arg.mServiceLength;
    this->mSocketType = arg.mSocketType;
    memcpy(&this->mService, &arg.mService, sizeof(struct sockaddr_in));

    return *this;
}


void Socket::InitializeSockets()
{
#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
}


/*  End of File */