Udp Class Reference

#include <socketlib.h>

Collaboration diagram for Udp:

Public Member Functions
	Udp ()
int32_t	socketOpen ()
	Open UDP socket. More...
int32_t	setupClient ()
int32_t	setupClient (string a, uint16_t p)
int32_t	setupClientSimGen (string a, uint16_t p)
int32_t	setupClientAcstb (string a, uint16_t p)
int32_t	setupServer (uint16_t port, float timeout_sec)
int32_t	send (string package2send)
int32_t	receiveLoop ()
int32_t	receiveOnce ()
int32_t	close ()

Public Attributes
string	receivedData

Private Member Functions
int32_t	openServer ()
int32_t	errorStatus (string functionName)

Private Attributes
SocketOptions	sok
int32_t	iretn = 0

Constructor & Destructor Documentation

Udp::Udp

(

)

        {
    // default values (for Matlab)
    //sok.address     = "127.0.0.1";
    //sok.port        = 8888;

    //sok("127.0.0.1",8888);
    //sok {"127.0.0.1",8888};
    //iretn = init();
}

Member Function Documentation

int32_t Udp::openServer ( )

private

int32_t Udp::errorStatus ( string  functionName )

private

                                           {

#ifdef COSMOS_WIN_OS
    errno = WSAGetLastError();
    std::cout << functionName << " failed with error code :" << errno <<  " (" << strerror(errno) << ")" << std::endl;
    std::cout << "Check the Windows Sockets Error Codes to get more information: http://msdn.microsoft.com/en-us/library/windows/desktop/ms740668%28v=vs.85%29.aspx" << std::endl;
#else
    std::cout << functionName << " failed with error code :" << errno <<  " (" << strerror(errno) << ")" << std::endl;
#endif

    // return negative error number
    return -errno;
    //exit(EXIT_FAILURE);
}

int32_t Udp::socketOpen

(

)

Open UDP socket.

Open a UDP socket and configure it for the specified use. Various flags are set, and the socket is bound, if necessary. Support is provided for the extra steps necessary for MS Windows.

Returns

Zero, or negative error.

1. Join multicast

{
    socklen_t namelen;
    int32_t iretn;
    struct ip_mreq mreq;
    int on = 1;
    int debug = false; //turn on or off debug statements

#ifdef COSMOS_WIN_OS
    unsigned long nonblocking = 1;
    struct sockaddr_storage ss;
    int sslen;
    WORD wVersionRequested;
    WSADATA wsaData;
    static bool started=false;

    //Initialise winsock
    if (debug){std::cout << "\nInitialising Winsock...";}
    if (!started)
    {
        wVersionRequested = MAKEWORD( 1, 1 );
        //wVersionRequested = MAKEWORD( 2, 2 );
        //iretn = WSAStartup( wVersionRequested, &wsaData );

        if ( (iretn=WSAStartup(wVersionRequested,&wsaData)) != 0)
        {
            if (debug){printf("Failed. Error Code : %d",WSAGetLastError());
                return errno;
            }
        }
        if (debug){std::cout << "Initialised." << std::endl;}
    }
#endif

    //Create a socket
    if (sok.stream){
        if ((sok.handle = socket(AF_INET, SOCK_STREAM,0)) <0){
            {
                if (debug){
#ifdef COSMOS_WIN_OS
                    printf("Could not create socket stream: %d" , WSAGetLastError());
#else
                    printf("Could not create socket stream : %d" , errno);
#endif
                }
                return (-errno);
            }
        }
    } else {
        //default
        if ((sok.handle = socket(AF_INET, SOCK_DGRAM,0)) <0){
            {
                if (debug){
#ifdef COSMOS_WIN_OS
                    printf("Could not create socket : %d" , WSAGetLastError());
#else
                    printf("Could not create socket : %d" , errno);
#endif
                }
                return (-errno);
            }
        }
    }

    if (debug){std::cout << "Socket created" << std::endl;}

    if (sok.blocking == SOCKET_NONBLOCKING)
    {
        iretn = 0;
#ifdef COSMOS_WIN_OS
        if (ioctlsocket(sok.handle, FIONBIO, &nonblocking) != 0)
        {
            iretn = -WSAGetLastError();
        }
#else
        if (fcntl(sok.handle, F_SETFL,O_NONBLOCK) < 0)
        {
            iretn = -errno;
        }
#endif
        if (iretn < 0)
        {
            CLOSE_SOCKET(sok.handle);
            sok.handle = iretn;
            return iretn;
        }
    }

    // this defines the wait time for a response from a request
    if (sok.timeout)
    {
#ifdef COSMOS_WIN_OS
        int msectimeo = sok.timeout/1000;
        iretn = setsockopt(sok.handle,SOL_SOCKET,SO_RCVTIMEO,(const char *)&msectimeo,sizeof(msectimeo));
#else
        struct timeval tv;
        tv.tv_sec = sok.timeout/1000000;
        tv.tv_usec = sok.timeout%1000000;
        iretn = setsockopt(sok.handle,SOL_SOCKET,SO_RCVTIMEO,(char*)&tv,sizeof(tv));
#endif
    }

    //Prepare the sockaddr_in structure
    memset(&sok.server, 0, sizeof(struct sockaddr_in));
    sok.server.sin_family = AF_INET;
    sok.server.sin_port = htons(sok.port);

    switch (sok.role)
    {
    case SOCKET_LISTEN:
#ifdef COSMOS_MAC_OS
        if (setsockopt(sok.handle,SOL_SOCKET,SO_REUSEPORT,(char*)&on,sizeof(on)) < 0)
#else
        if (setsockopt(sok.handle,SOL_SOCKET,SO_REUSEADDR,(char*)&on,sizeof(on)) < 0)
#endif
        {
            CLOSE_SOCKET(sok.handle);
            sok.handle = -errno;
            return (-errno);
        }

        sok.server.sin_addr.s_addr = htonl(INADDR_ANY);

        //Bind
        if (::bind(sok.handle,(struct sockaddr *)&sok.server, sok.addrlen) < 0) //addrlen = sizeof(struct sockaddr_in)
        {
            if (debug){
#ifdef COSMOS_WIN_OS
                printf("Bind failed with error code : %d" , WSAGetLastError());
#endif
            }

            CLOSE_SOCKET(sok.handle);
            sok.handle = -errno;
            return (-errno);
        }
        if (debug){std::cout << "Bind done" << std::endl;}

        // If we bound to port 0, then find out what our assigned port is.
        if (!sok.port)
        {
            namelen = sizeof(struct sockaddr_in);
            if ((iretn = getsockname(sok.handle, (sockaddr*)&sok.server, &namelen)) == -1)
            {
                CLOSE_SOCKET(sok.handle);
                sok.handle = -errno;
                return (-errno);
            }
            sok.port = ntohs(sok.server.sin_port);
        }
        else
        {
            //>>
            //port = port;
        }

        if (sok.type == NetworkType::MULTICAST)
        {
            mreq.imr_multiaddr.s_addr = inet_addr(sok.address.c_str());
            mreq.imr_interface.s_addr = htonl(INADDR_ANY);
            if (setsockopt(sok.handle, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&mreq, sizeof(mreq)) < 0)
            {
                CLOSE_SOCKET(sok.handle);
                sok.handle = -errno;
                return (-errno);
            }
        }


        break;
    case SOCKET_JABBER:
        switch (sok.type)
        {
        case NetworkType::UDP:
            if ((iretn=setsockopt(sok.handle,SOL_SOCKET,SO_BROADCAST,(char*)&on,sizeof(on))) < 0)
            {
                CLOSE_SOCKET(sok.handle);
                sok.handle = -errno;
                return (-errno);
            }
            sok.server.sin_addr.s_addr = 0xffffffff;
            break;
        case NetworkType::MULTICAST:
#ifndef COSMOS_WIN_OS
            inet_pton(AF_INET,sok.address.c_str(),&sok.server.sin_addr);
#else
            sslen = sizeof(ss);
            WSAStringToAddressA((LPSTR)sok.address.c_str(),AF_INET,NULL,(struct sockaddr*)&ss,&sslen);
            sok.server.sin_addr = ((struct sockaddr_in *)&ss)->sin_addr;
#endif
            break;
        default:
            return (SOCKET_ERROR_PROTOCOL);
            break;
        }
        // >>
        //port = port;
        break;
        //------------------------------------------------------
    case SOCKET_TALK:
#ifndef COSMOS_WIN_OS
        inet_pton(AF_INET,sok.address.c_str(),&sok.server.sin_addr);
#else
        sslen = sizeof(ss);
        WSAStringToAddressA((LPSTR)sok.address.c_str(),AF_INET,NULL,(struct sockaddr*)&ss,&sslen);
        sok.server.sin_addr = ((struct sockaddr_in *)&ss)->sin_addr;
#endif
        //>>
        //port = port;

        if (sok.connect){
            if ((iretn=connect(sok.handle, (struct sockaddr *)&sok.server, sok.addrlen)) < 0)
            {
#ifdef COSMOS_WIN_OS
                iretn = WSAGetLastError();
                if (iretn != WSAEWOULDBLOCK)
                {
                    return (errno);
                }
#else
                iretn = errno;
                if (iretn != EINPROGRESS)
                {
                    return (errno);
                }
#endif
                COSMOS_SLEEP(1);
            }
        }


        break;
    }

    return 0;
}

int32_t Udp::setupClient

(

)

                        {
    return socketOpen();
}

int32_t Udp::setupClient	(	string	a,
		uint16_t	p
	)

                                            {
    // config
    sok.address = a;
    sok.port = p;

    return socketOpen();
}

int32_t Udp::setupClientSimGen	(	string	a,
		uint16_t	p
	)

                                                  {
    // config
    sok.address     = a;
    sok.port        = p;
    sok.blocking    = SOCKET_NONBLOCKING;
    sok.stream      = true;
    sok.timeout     = 0;
    sok.connect     = true;

    return socketOpen();
}

int32_t Udp::setupClientAcstb	(	string	a,
		uint16_t	p
	)

                                                 {
    // config
    sok.address     = a;
    sok.port        = p;
    sok.blocking    = SOCKET_NONBLOCKING;
    sok.stream      = true;
    sok.timeout     = 0;
    sok.connect     = true;

    return socketOpen();

}

int32_t Udp::setupServer	(	uint16_t	port,
		float	timeout_sec
	)

                                                        {
    // the sok.server does not need an ip because it runs on the
    // local computer (with preassigned ip)
    sok.port        = port;
    sok.type        = NetworkType::UDP;
    sok.role        = SOCKET_LISTEN;
    sok.blocking    = SOCKET_BLOCKING;
    sok.timeout     = timeout_sec*1000000;

    //    int socket_timeout = 0;
    //    if (timeout == 0){
    //        socket_timeout = SOCKET_RCVTIMEO;
    //    } else {
    //        socket_timeout = timeout;
    //    }

    if ((iretn=socketOpen()) < 0)
    {
        return (-errno);
    }
    return 0;
}

int32_t Udp::send

(

string

package2send

)

                                    {

    if (sendto(sok.handle,                      // socket
               package2send.c_str(),            // buffer to send
               strlen(package2send.c_str()),    // size of buffer
               0,                               // flags
               (struct sockaddr *)&sok.server,  // socket address
               sok.addrlen)                     // size of address to socket pointer //sizeof(struct sockaddr_in))
        < 0){

        return errorStatus("Udp::send");
    }
    //std::cout << "sent: " << package2send << std::endl;
    // return 0 on sucess
    return 0;
}

int32_t Udp::receiveLoop

(

)

                        {
    char buf[SOCKET_BUFFER_LENGTH];
    int recv_len;

    //keep listening for data
    std::cout << "Waiting for data...";

    while(1){

        //clear the buffer by filling null, it might have previously received data
        memset(buf,'\0', SOCKET_BUFFER_LENGTH);

        //try to receive some data, this is a blocking call
        if ((recv_len = recvfrom(sok.handle,
                                 buf,
                                 SOCKET_BUFFER_LENGTH,
                                 0,
                                 (struct sockaddr *) &sok.s_other,
                                 (socklen_t *)&sok.addrlen)) < 0){
            return errorStatus("Udp::receiveLoop");
        }

        if (recv_len > 0) {
            //print details of the client/peer and the data received
            std::cout << "Received packet from " << inet_ntoa(sok.server.sin_addr) << ":" << ntohs(sok.port) << std::endl;
            std::cout << "Data: " << buf << std::endl;
            recv_len = 0;
        }

        //now reply the client with the same data
        if (sendto(sok.handle,
                   buf,
                   recv_len,
                   0,
                   (struct sockaddr*) &sok.s_other,
                   sok.addrlen) < 0){
            return errorStatus("Udp::receiveLoop");
        }

    }


    return 0;
}

int32_t Udp::receiveOnce

(

)

                        {
    // collects the data from the Udp channel
    // and puts into the receivedData string
    // that is defined on the Udp class
    char buf[SOCKET_BUFFER_LENGTH];
    int recv_len = -1;

    //keep listening for data
    //std::cout << "Waiting for data...";

    //clear the buffer by filling null, it might have previously received data
    memset(buf,'\0', SOCKET_BUFFER_LENGTH);


    ElapsedTime ep;
    ep.print = false;
    ep.tic();
    float timeout = 5.0; // seconds
    double timer = -1.;

    // just to test timer
    //COSMOS_SLEEP(0.001);

    while ( (recv_len < 0) && (timer < timeout) ){
        // keep trying to receive message
        //receivedStatus = udp.receiveOnce();

        //try to receive some data
        recv_len = recvfrom(sok.handle,
                            buf,
                            SOCKET_BUFFER_LENGTH,
                            0,
                            (struct sockaddr *) &sok.s_other,
                            (socklen_t *)&sok.addrlen);

        timer = ep.toc();
        //std::cout << recv_len << " | " << timer << std::endl;
        //std::cout << " (udp rx: " << recv_len << " bytes | " << timer << " sec)" << std::endl;


        if (recv_len < 0)
        {
#ifdef COSMOS_WIN_OS
            if (WSAGetLastError() == 10035){
                //std::cout << "Resource temporarily unavailable. Continue." << std::endl;
                continue;
            }
#endif
            return errorStatus("Udp::receiveOnce");
            //continue;
        }

        if (recv_len > 0) {
            //print details of the client/peer and the data received
            //        std::cout << "Received packet from " << inet_ntoa(sok.server.sin_addr) << ":" << ntohs(sok.port) << std::endl;
            //        std::cout << "Data: " << buf << std::endl;

            //std::cout << std::endl << "<< udp rx: " << recv_len << " bytes | " << std::setprecision(3) << std::fixed << timer << " sec" << std::endl;

            recv_len = 0;
            timer = 0;
            receivedData = string(buf);
            return 0;
        }
        //
    }

    std::cout << "Failed to receive data in less than 5 sec. Elapsed time: " << ep.toc() << std::endl;
    return -1;
}

int32_t Udp::close

(

)

                  {

#ifdef COSMOS_WIN_OS
    closesocket(sok.handle);
    WSACleanup();
#endif

    return 0;
}

Member Data Documentation

SocketOptions Udp::sok

private

int32_t Udp::iretn = 0

private

string Udp::receivedData

---

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

• socketlib.h
• socketlib.cpp