UDP_Socket

#include "UDP_Socket.h"
#include <stdint.h>
#include <string>
#include <iostream>

UDP_Socket::UDP_Socket(void)
{
    timeout_set = false;
}

UDP_Socket::UDP_Socket(std::string IP_address_param, uint16_t port_param) :
    Socket(IP_address_param, port_param)
{
    timeout_set = false;
}

UDP_Socket::~UDP_Socket(void)
{
}


int UDP_Socket::create_socket()
{
    // Create a SOCKET for the server to listen for client connections
    listen_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

    // Check for errors to ensure that the socket is a valid socket.
    if (listen_socket == INVALID_SOCKET) {
        std::cerr << "Socket function failed with error: " << WSAGetLastError() << std::endl;
        //WSACleanup();
        return 1;
    }

    return 0;
}

int UDP_Socket::set_timeout(int s, int ms)
{
    //timeout.tv_sec = s;
    //timeout.tv_usec = us;
    timeout_set = true;

    time = 1000*s + ms;

    int result = setsockopt(listen_socket, SOL_SOCKET, SO_RCVTIMEO, (const char*) &time, sizeof(time));

    return result;
}


int UDP_Socket::bind_socket(std::string IP_address_param, uint16_t port_param)
{
    // The sockaddr_in structure specifies the address family,
    // IP address, and port for the socket that is being bound.
    service.sin_family = AF_INET;
    service.sin_addr.s_addr = inet_addr(IP_address_param.c_str());
    service.sin_port = htons(port_param);

    // Bind the socket.
    int iResult = bind(listen_socket, (SOCKADDR *) &service, sizeof (service));

    if (iResult == SOCKET_ERROR) {
        std::cerr << "Bind failed with error: " << WSAGetLastError() << std::endl;
        closesocket(listen_socket);

        return 1;
    }

    IP_address = IP_address_param;
    port = port_param;
    bound = true;

    return 0;
}


int UDP_Socket::bind_socket()
{
    // The sockaddr_in structure specifies the address family,
    // IP address, and port for the socket that is being bound.
    service.sin_family = AF_INET;
    service.sin_addr.s_addr = inet_addr(IP_address.c_str());
    service.sin_port = htons(port);

    // Bind the socket.
    int iResult = bind(listen_socket, (SOCKADDR *) &service, sizeof (service));
    if (iResult == SOCKET_ERROR) {
        std::cerr << "Bind failed with error: " << WSAGetLastError() << std::endl;
        closesocket(listen_socket);
        //WSACleanup();
        return 1;
    }

    bound = true;
    return 0;
}



int UDP_Socket::receive_from(char* buff, int len, std::string &sender_address, uint16_t &sender_port)
{
    /*if (timeout_set)
    {
        fd_set fds;
        int n;

        // Set up the file descriptor set.
        FD_ZERO(&fds);
        FD_SET(listen_socket, &fds) ;

        // Wait until timeout or data received.
        n = select(listen_socket, &fds, NULL, NULL, &timeout) ;
        if ( n == 0)
        {
            std::cerr << "Timeout at: " << *this << " socket in recieve_from function" << std::endl;
            return -1;
        }

        else if( n == -1 )
        {
            std::cerr << "Error at winsock2 select() function at " << *this << " socket in recieve_from function" << std::endl;
            return -2;
        }
    }*/

    sockaddr_in sender;
    int sender_len = sizeof(sender);

    // http://msdn.microsoft.com/en-us/library/windows/desktop/ms740121%28v=vs.85%29.aspx
    int return_value;
    try
    {
        return_value = recvfrom(listen_socket, buff, len, 0, (sockaddr*) &sender, &sender_len);
    } catch (...)
    {
        return return_value;
    }



    //std::cout << "Last error: " << WSAGetLastError() << std::endl;

    char* address = inet_ntoa(sender.sin_addr);
    sender_address = std::string(address);
    sender_port = ntohs(sender.sin_port);

    return return_value;
}


int UDP_Socket::send_to(const char* data, int len, UDP_Socket addr)
{
    sockaddr_in target;
    target.sin_family = AF_INET;
    target.sin_addr.s_addr = inet_addr(addr.get_IP_address().c_str());
    target.sin_port = htons(addr.get_port());
    int result = sendto(listen_socket, data, len, 0, (SOCKADDR *) &target, sizeof(target));
    return result;
}