ibrcommon/ibrcommon/net/udpsocket.cpp

Go to the documentation of this file.

/*
 * udpsocket.cpp
 *
 *  Created on: 02.03.2010
 *      Author: morgenro
 */

#include "ibrcommon/config.h"
#include "ibrcommon/net/udpsocket.h"
#include <sys/socket.h>
#include <errno.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <cassert>
#include <string.h>

#ifndef HAVE_BZERO
#define bzero(s,n) (memset((s), '\0', (n)), (void) 0)
#endif

namespace ibrcommon
{
        udpsocket::udpsocket(u_char proto) throw (SocketException)
        {
                // Create socket for listening for client connection requests.
                if ((_socket = ::socket(AF_INET, SOCK_DGRAM, proto)) < 0)
                {
                        throw SocketException("udpsocket: cannot create listen socket");
                }

                bzero(&_sockaddr, sizeof(_sockaddr));
                _sockaddr.sin_family = AF_INET;
        }

        udpsocket::~udpsocket()
        {
                if (_socket != 0)
                {
                        shutdown();
                        ::close(_socket);
                }
        }

        void udpsocket::shutdown()
        {
                //::shutdown(_socket, SHUT_RDWR);
                ::close(_socket);
        }

        int udpsocket::receive(char* data, size_t maxbuffer)
        {
                struct sockaddr_in clientAddress;
                socklen_t clientAddressLength = sizeof(clientAddress);

                // data waiting
                return recvfrom(_socket, data, maxbuffer, MSG_WAITALL, (struct sockaddr *) &clientAddress, &clientAddressLength);
        }

        int udpsocket::receive(char* data, size_t maxbuffer, std::string &address)
        {
                struct sockaddr_in clientAddress;
                socklen_t clientAddressLength = sizeof(clientAddress);

                // data waiting
                int ret = recvfrom(_socket, data, maxbuffer, MSG_WAITALL, (struct sockaddr *) &clientAddress, &clientAddressLength);

                char str[INET_ADDRSTRLEN];
                inet_ntop(AF_INET, &(clientAddress.sin_addr), str, INET_ADDRSTRLEN);

                address = std::string(str);

                return ret;
        }

        udpsocket::peer::peer(udpsocket &socket, const struct sockaddr_in &dest, const unsigned int port)
         : _socket(socket)
        {
                // destination parameter
                _destaddress.sin_family = AF_INET;

                // define the destination
                memcpy(&_destaddress.sin_addr, &dest.sin_addr, sizeof(_destaddress.sin_addr));
                _destaddress.sin_port = htons(port);
        }

        int udpsocket::peer::send(const char *data, const size_t length)
        {
                // Send converted line back to client.
                return ::sendto(_socket._socket, data, length, 0, (struct sockaddr *) &_destaddress, sizeof(_destaddress));
        }

        udpsocket::peer udpsocket::getPeer(const string address, const unsigned int port)
        {
                struct sockaddr_in destaddress;

                // convert given address
                if (inet_pton(AF_INET, address.c_str(), &destaddress.sin_addr) <= 0)
                {
                        throw SocketException("udpsocket: can not parse address " + address);
                }

                return udpsocket::peer(*this, destaddress, port);
        }
}