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

Go to the documentation of this file.

#include "cxutils/networking/udpserver.h"
#include <string.h>
#include <limits.h>
#include <iostream>

#ifdef WIN32
#else
#include <errno.h>
#endif

using namespace std;
using namespace CxUtils;

UdpServer::UdpServer()
{
    mPort = 0;
    mComputer = 0;
    mHP = NULL;
    memset((void *)&mService, 0, sizeof(struct sockaddr_in));
    memset((void *)&mSendAddr, 0, sizeof(struct sockaddr_in));
    memset((void *)&mRecvAddr, 0, sizeof(struct sockaddr_in));
    mSocketType = UDPServer;
}

UdpServer::~UdpServer()
{
    Shutdown();
}

void UdpServer::Shutdown()
{
    if(mSocket)
    {
#ifdef WIN32
        closesocket(mSocket);
#else
        close(mSocket);        
#endif
        mSocket = 0;
    }
    Socket::Shutdown();
    mPort = 0;
    mComputer = 0;
    this->mSocketType = UDPServer;
    memset((void *)&mService, 0, sizeof(struct sockaddr_in));
    memset((void *)&mSendAddr, 0, sizeof(struct sockaddr_in));
    memset((void *)&mRecvAddr, 0, sizeof(struct sockaddr_in));
}


int UdpServer::InitializeSocket(const unsigned short port)
{
    //  Close any previous socket
    Shutdown();
    // Clear out settings.
    memset((void *)&mService, 0, sizeof(struct sockaddr_in));
    memset((void *)&mSendAddr, 0, sizeof(struct sockaddr_in));
    memset((void *)&mRecvAddr, 0, sizeof(struct sockaddr_in));

    // Create a UDP Socket
    mSocket = (int)socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    mPort = port;

    if(mSocket > 0)
    {
        mRecvAddr.sin_family = AF_INET;
        mRecvAddr.sin_port = htons(mPort);
        mRecvAddr.sin_addr.s_addr = htonl(INADDR_ANY);
        
        int bufferSize = 262144;
        int on = 1;

        if( bind(mSocket, (struct sockaddr *) &mRecvAddr, sizeof(mRecvAddr)) >= 0)
        {
            int code = 0;

            if(mNetworkInterface >= 0)
            {
                IP4Address::List myHostnames;
                GetHostAddresses(myHostnames);
                if(mNetworkInterface < (int)(myHostnames.size()))
                {
                    mRecvAddr.sin_addr.s_addr = *((long *)gethostbyname(myHostnames[mNetworkInterface].mString.c_str())->h_addr);
                    mRecvAddress = IP4Address(myHostnames[mNetworkInterface]);
                    setsockopt(mSocket, IPPROTO_IP, IP_MULTICAST_IF, (const char*) &mRecvAddr, sizeof(mRecvAddr));
                }
            }

            int options = 0;
            options |= setsockopt(mSocket, SOL_SOCKET, SO_RCVBUF, (char *)&bufferSize, (int)sizeof(bufferSize));
            options |= setsockopt(mSocket, SOL_SOCKET, SO_SNDBUF, (char *)&bufferSize, (int)sizeof(bufferSize));

            if(options != 0)
            {
                cout << "UDP ERROR: Failed to set UDP socket options.\n";
                Shutdown();
                return 0;
            }

            mServiceLength = sizeof(mService);
            //  We have a valid socket
            mGoodSocket = true;
            memcpy(&mService, &mRecvAddr, sizeof(mRecvAddr));
            memcpy(&this->mSendAddr, (struct sockaddr *)(&mService), sizeof(mSendAddr));
        }
        else
        {
            //cout << "UDP ERROR: bind failued on socket. ERRNO: " << errno << "-" << strerror(errno) << "\n";
            Shutdown();
        }        
    }

    return mGoodSocket;

}
/*
{
    int s;
    sockaddr_in recvaddr;

    //  Close any previous socket
    Shutdown();

    memset((void *)&mService, 0, sizeof(struct sockaddr_in));

    s = (int)socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

    if(s > 0)
    {
        recvaddr.sin_family = AF_INET;
        recvaddr.sin_port = htons(port);
        recvaddr.sin_addr.s_addr = htonl(INADDR_ANY);
        if(mNetworkInterface >= 0)
        {
            IP4Address::List myHostnames;
            GetHostAddresses(myHostnames);
            if(mNetworkInterface < (int)(myHostnames.size()))
            {
                recvaddr.sin_addr.s_addr = *((long *)gethostbyname(myHostnames[mNetworkInterface].mString.c_str())->h_addr);
                mRecvAddress = IP4Address(myHostnames[mNetworkInterface]);
            }
        }

        int sndsize = 262144;

        //  Don't allow multiple UDP Servers on single host (causes problems with unicast receiving).
        //setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on));
        setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&sndsize, sizeof(sndsize));

        if( bind(s, (struct sockaddr *) &recvaddr, sizeof(recvaddr)) >= 0)
        {
            mSocket = s;
            mPort = port;
            mServiceLength = sizeof(mService);
            //  We have a valid socket
            mGoodSocket = true;
            memcpy(&mService, &recvaddr, sizeof(recvaddr));
            memcpy(&this->mSendAddr, (struct sockaddr *)(&mService), sizeof(mSendAddr));
            memcpy(&this->mRecvAddr, (struct sockaddr *)(&mService), sizeof(mRecvAddr));
        }
        else
        {
            printf( "UDP ERROR: %s\n", strerror( errno ) );
            Shutdown();
        }
    }

    return mGoodSocket;

}
*/

int UdpServer::InitializeMulticastSocket(const unsigned short port,
                                         const IP4Address& multicastGroup,
                                         const bool allowReuse)
{
    //  Close any previous socket
    Shutdown();
    // Clear out settings.
    memset((void *)&mService, 0, sizeof(struct sockaddr_in));
    memset((void *)&mSendAddr, 0, sizeof(struct sockaddr_in));
    memset((void *)&mRecvAddr, 0, sizeof(struct sockaddr_in));

    // Create a UDP Socket
    mSocket = (int)socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    mPort = port;

    if(mSocket > 0)
    {
        mRecvAddr.sin_family = AF_INET;
        mRecvAddr.sin_port = htons(mPort);
        mRecvAddr.sin_addr.s_addr = htonl(INADDR_ANY);
        
        int bufferSize = 262144;
        int on = 1;

        // Don't allow multiple UDP Servers on single host (causes problems with unicast receiving).
        if(allowReuse == true && setsockopt(mSocket, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on)) < 0)
        {
            cout << "UDP ERROR: setsockopt failed SO_REUSEADDR. ERRNO: " << errno << "-" << strerror(errno) << "\n";
            Shutdown();
            return 0;
        }

        if(bind(mSocket, (struct sockaddr *) &mRecvAddr, sizeof(mRecvAddr)) >= 0)
        {
            struct ip_mreq mreq;
            int code = 0;

            if(mNetworkInterface >= 0)
            {
                IP4Address::List myHostnames;
                GetHostAddresses(myHostnames);
                if(mNetworkInterface < (int)(myHostnames.size()))
                {
                    // This makes sure we use the approprite NIC
                    //setsockopt(mSocket, IPPROTO_IP, IP_MULTICAST_IF, (const char*) &mRecvAddr, sizeof(mRecvAddr));
                    mRecvAddr.sin_addr.s_addr = *((long *)gethostbyname(myHostnames[mNetworkInterface].mString.c_str())->h_addr);
                    mRecvAddress = IP4Address(myHostnames[mNetworkInterface]);
                    mreq.imr_interface.s_addr = inet_addr(mRecvAddress.mString.c_str());
                }
                else
                {
                    mreq.imr_interface.s_addr = htonl(INADDR_ANY);
                }
            }
            else
            {
                mreq.imr_interface.s_addr = htonl(INADDR_ANY);
            }

            mreq.imr_multiaddr.s_addr = inet_addr(multicastGroup.mString.c_str());

            int options = 0;
            options |= setsockopt(mSocket, SOL_SOCKET, SO_RCVBUF, (char *)&bufferSize, (int)sizeof(bufferSize));
            options |= setsockopt(mSocket, SOL_SOCKET, SO_SNDBUF, (char *)&bufferSize, (int)sizeof(bufferSize));
            options |= setsockopt(mSocket, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *)&mreq, sizeof(mreq));

            if(options != 0)
            {
#ifdef WIN32
                int errorCode = WSAGetLastError();
                cout << "UDP ERROR: " << errorCode << "\n";
#else
                cout << "UDP ERROR: Failed to set UDP socket options.\n";
#endif
                Shutdown();
                return 0;
            }

            mServiceLength = sizeof(mService);
            //  We have a valid socket
            mGoodSocket = true;
            memcpy(&mService, &mRecvAddr, sizeof(mRecvAddr));
            memcpy(&this->mSendAddr, (struct sockaddr *)(&mService), sizeof(mSendAddr));
        }
        else
        {
            //cout << "UDP ERROR: bind failued on socket. ERRNO: " << errno << "-" << strerror(errno) << "\n";
            Shutdown();
        }        
    }

    return mGoodSocket;

}


int UdpServer::RecvToBuffer(char *buffer,
                            const unsigned int length,
                            const long int timeOutMilliseconds,
                            IPAddress* ipAddress,
                            unsigned short* port) const
{
    if(!IsValid())
    {
        return 0;
    }

    if(!Socket::IsIncommingData(this, timeOutMilliseconds))
    {
        return 0;
    }

    int rcvd = 0;

    sockaddr *r, *s;

    r = (sockaddr *)(&mRecvAddr);
    s = (sockaddr *)(&mSendAddr);
    memset(r, 0, sizeof(struct sockaddr));
    int recvlen = sizeof(struct sockaddr);

#ifdef WIN32
    rcvd =  recvfrom(mSocket,
                     buffer, 
                     length, 
                     0,
                     (struct sockaddr *)r, 
                     &recvlen);
#else
    rcvd =  recvfrom(mSocket, 
                     buffer, 
                     length, 
                     0,
                    (struct sockaddr *)r, 
                    (socklen_t *)&recvlen);
#endif

    //  By default set the send address to who
    //  data was last received from.
    if(rcvd > 0)
    {
        memcpy(s, r, sizeof(struct sockaddr));
        if(port || ipAddress)
        {
            struct sockaddr_in in;
            memcpy(&in, &mRecvAddr, sizeof(struct sockaddr_in));
            if(ipAddress && dynamic_cast<IP4Address*>(ipAddress))
            {
                *((IP4Address*)(ipAddress)) = std::string(inet_ntoa(in.sin_addr)); 
            }
            if(port)
            {
                *port = (unsigned short)ntohs(in.sin_port);
            }
        }
    }
    else
    {
        rcvd = 0;
    }

    return rcvd;
}


/*  End of File */