---

network_delivery_socket.cpp

Go to the documentation of this file.

/*
        $Id: network_delivery_socket.cpp,v 1.1 2001/02/15 13:18:52 mbn Exp $

        ------------------------------------------------------------------------
        ClanLib, the platform independent game SDK.

        This library is distributed under the GNU LIBRARY GENERAL PUBLIC LICENSE
        version 2. See COPYING for details.

        For a total list of contributers see CREDITS.

        ------------------------------------------------------------------------
*/

#ifdef WIN32
#pragma warning (disable:4786)
#endif

#include <API/Core/System/error.h>
#include "API/Core/System/cl_assert.h"
#include <Network/Generic/network_delivery_impl.h>
#include <Network/Generic/network_delivery_socket.h>

#include <string.h>
#include <errno.h>

// ClanLib network magic. This magic is the first DWORD sent across a socket.
// If the received DWORD doesn't match our magic, we can be sure it isn't a clanlib
// networking application on that port.
#define NETWORK_MAGIC 0x16042104

/******************************************************************************
                         Unix Socket implementation
******************************************************************************/

CL_UniformSocket::CL_UniformSocket(CL_ConnectionProvider *_provider)
{
        provider = _provider;
        is_connection_lost = false;
        sock = CL_INVALID_SOCKET;
        send_pos = 0;

        recv_state = expect_magic;
        cur_message = NULL;
        cur_message_size = -1;
}

CL_UniformSocket::~CL_UniformSocket()
{
        if (sock != CL_INVALID_SOCKET) closesocket(sock);
        provider->remove_connection(this);
}

bool CL_UniformSocket::read_avail()
{
        fd_set rfds;

        FD_ZERO(&rfds);
        FD_SET(sock, &rfds);

        timeval timeout;
        memset(&timeout, 0, sizeof(timeval));

        int retval = select(sock+1, &rfds, NULL, NULL, &timeout);
        if (retval == -1 || retval == 0) 
        {
                return false;
        }

        char buf[1024];

        int data_received = ::recv(
                sock,
                buf,
                1024,
                0);

        if (data_received == 0 || data_received == -1)
        {
                is_connection_lost = true;
                return false;
        }
        recv_buffer.append(buf, data_received);

        return true;
}

bool CL_UniformSocket::require_avail(unsigned int size)
{
        return recv_buffer.size() >= size;
}

bool CL_UniformSocket::get_avail(void *buf, unsigned int size)
{
        if (recv_buffer.size() < size) return false;

        memcpy(buf, recv_buffer.data(), size);
        recv_buffer.erase(0, size);

        return true;
}

bool CL_UniformSocket::init_socket(int init_socket)
{
        static int sol_tcp = -1;
        if (sol_tcp == -1) sol_tcp = getprotobyname("tcp")->p_proto;

        if (init_socket != CL_INVALID_SOCKET)
        {
                sock = init_socket;

        // set socket into non-blocking mode:
#ifdef WIN32
                u_long argp = 1;
                ioctlsocket(sock, FIONBIO, &argp);
#else
                fcntl(sock, F_SETFL, O_NONBLOCK);
#endif

                int value = 1;
                setsockopt(sock, sol_tcp, TCP_NODELAY, (const char *) &value, sizeof(int));
                write_int(NETWORK_MAGIC);
        }
        else
        {
                sock = socket(AF_INET, SOCK_STREAM, 0);
                if (sock == CL_INVALID_SOCKET) return false;

        // set socket into non-blocking mode:
#ifdef WIN32
                u_long argp = 1;
                ioctlsocket(sock, FIONBIO, &argp);
#else
                fcntl(sock, F_SETFL, O_NONBLOCK);
#endif

                int value = 1;
                setsockopt(sock, sol_tcp, TCP_NODELAY, (const char *) &value, sizeof(int));
        }

        return true;
}

bool CL_UniformSocket::peek()
{
        if (sock == CL_INVALID_SOCKET) return false;

        read_avail();
        send_avail();

        switch (recv_state)
        {
        case expect_magic:
                {
                        int found_magic;
                        if (get_avail(&found_magic, sizeof(int)) == false) return false;
                        found_magic = ntohl(found_magic);
                        if (found_magic != NETWORK_MAGIC)
                        {
                                is_connection_lost=true;
                        }
                        else recv_state = expect_packet_size;
                }

        case expect_packet_size:
                {
                        if (get_avail(&cur_message_size, sizeof(int)) == false) return false;
                        cur_message_size = ntohl(cur_message_size);
                        recv_state = expect_packet_data;
                }

        case expect_packet_data:
                {
                        if (!require_avail(cur_message_size)) return false;
                        cur_message = new char[cur_message_size];
                        get_avail(cur_message, cur_message_size);
                        recv_state = packet_finished;
                }

        case packet_finished:
                return true;

        default:
                throw CL_Error("Network protocol error.");
                return false;
        };

        return false;
}

CL_ConnectionPacket CL_UniformSocket::receive()
{
        if (peek() == false)
        {
                CL_ConnectionPacket ret;
                ret.size = 0;
                ret.data = NULL;
                return ret;
        }

        CL_ConnectionPacket ret;
        ret.size = cur_message_size;
        ret.data = cur_message;

        recv_state = expect_packet_size;

        return ret;
}

void CL_UniformSocket::send(CL_ConnectionPacket message)
{
        write_int(message.size);
        write_data(message.data, message.size);
}

bool CL_UniformSocket::connection_lost()
{
        return is_connection_lost;
}

unsigned long CL_UniformSocket::read_int()
{
        unsigned char data[4];
        int read = 0;
        while (read < 4)
        {
                int val = recv(sock, (char *) data+read, 4-read, 0);
                if (val == 0 || val == -1) 
                {
                        is_connection_lost = true;
                        return 0;
                }

                read += val;
        }

        return ntohl(*((unsigned long *) data));
}

void CL_UniformSocket::write_int(unsigned long value)
{
        unsigned long write_num = htonl(value);

        write_data(&write_num, sizeof(unsigned long));
}

void CL_UniformSocket::write_data(void *data, unsigned int size)
{
        send_buffer.push(std::string((char *) data, size));
        send_avail();
}
#include <iostream>
bool CL_UniformSocket::send_avail()
{
        if (send_buffer.empty()) return true;

        std::string &buf = send_buffer.front();
        int size = buf.size();
        int res = ::send(sock, buf.data()+send_pos, size-send_pos, 0);
        if (res == CL_SOCKET_ERROR)
        {
#ifdef WIN32
                if (WSAGetLastError() == WSAEWOULDBLOCK) return false;
#else
                if (errno == EAGAIN) return false;
#endif
        
                cl_info_debug(info_network, PRINT_SOCK_ERROR());
                is_connection_lost = true;
                return true;
        }

        send_pos += res;
        if (send_pos  == size)
        {
                send_buffer.pop();
                send_pos = 0;
        }

        return send_buffer.empty();
}

bool CL_UniformSocket::try_connect(unsigned long remote_ip_network_format, int port)
{
        sockaddr_in sock_addr;
        sock_addr.sin_family = AF_INET;
        sock_addr.sin_addr.s_addr = remote_ip_network_format;
        sock_addr.sin_port = htons(port);

        int res = ::connect(sock, (sockaddr *) &sock_addr, sizeof(sockaddr_in));

        fd_set fdfailure, fdwrite;
        FD_ZERO(&fdfailure);
        FD_ZERO(&fdwrite);
        FD_SET(sock, &fdfailure);
        FD_SET(sock, &fdwrite);
        res = ::select(sock+1, NULL, &fdwrite, &fdfailure, NULL);
        if (res > 0)
        {
                if (FD_ISSET(sock, &fdfailure)) // connection failed
                {
                        throw CL_Error("Connection refused");
                }

                write_int(NETWORK_MAGIC);

                return true;
        }
        else 
        {
//              cl_info_debug(info_network, PRINT_SOCK_ERROR());
                throw CL_Error(PRINT_SOCK_ERROR());
                return false;
        }
}

/******************************************************************************
                                        CL_UniformAcceptSocket implementation
******************************************************************************/

CL_UniformAcceptSocket::CL_UniformAcceptSocket(CL_ConnectionProvider *provider)
: CL_UniformSocket(provider)
{
        port = -1;
}

CL_UniformAcceptSocket::~CL_UniformAcceptSocket()
{
}

bool CL_UniformAcceptSocket::bind(int _port)
{
        if (!init_socket()) return false;

        sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_addr.s_addr = INADDR_ANY;
        addr.sin_port = htons(_port);

        // Bind the socket to the specified port
        int err = ::bind(sock, (sockaddr *) &addr, sizeof(sockaddr_in));        
        if (err == CL_SOCKET_ERROR) throw CL_Error(PRINT_SOCK_ERROR());

        // Call getsockname to determine allocated port-number,
        // since socket might have been created with _port==0 (any)
        socklen_t len = sizeof(sockaddr_in);
        err = getsockname(sock, (sockaddr *) &addr, &len);
        if (err == CL_SOCKET_ERROR) throw CL_Error(PRINT_SOCK_ERROR());

        port = ntohs(addr.sin_port);
        
        // Make the socket listen for incoming connection attempts
        err = listen(sock, 64);
        if (err == CL_SOCKET_ERROR) throw CL_Error(PRINT_SOCK_ERROR());

        return true;
}

bool CL_UniformAcceptSocket::peek()
{
        fd_set rfds;

        FD_ZERO(&rfds);
        FD_SET(sock, &rfds);

        timeval timeout;
        memset(&timeout, 0, sizeof(timeval));

        int retval = select(sock+1, &rfds, NULL, NULL, &timeout);
        cl_assert(retval != -1);

        if (retval == 0) return false;
        else return true;
}

CL_UniformSocket *CL_UniformAcceptSocket::accept()
{
        fd_set rfds;
        FD_ZERO(&rfds);
        FD_SET(sock, &rfds);

        timeval timeout;
        memset(&timeout, 0, sizeof(timeval));

        int retval = select(sock+1, &rfds, NULL, NULL, &timeout);
        if (retval == -1 || retval == 0) 
        {
                return NULL;
        }

        int res_sock = ::accept(sock, NULL, NULL);
        cl_assert(res_sock != CL_INVALID_SOCKET);

        CL_UniformSocket *ret = new CL_UniformSocket(provider);
        ret->init_socket(res_sock);

        return ret;
}

bool CL_UniformAcceptSocket::try_connect(unsigned long remote_ip_network_format, int port)
{
        cl_assert(false);

        return false;
}

CL_ConnectionPacket CL_UniformAcceptSocket::receive()
{
        cl_assert(false);
        CL_ConnectionPacket ret;
        return ret;
}

void CL_UniformAcceptSocket::send(CL_ConnectionPacket message)
{
        cl_assert(false);
}

bool CL_UniformAcceptSocket::connection_lost()
{
        cl_assert(false);
        return false;
}

/******************************************************************************
                                        CL_UniformUDPConnection implementation
******************************************************************************/

CL_UniformUDPConnection::CL_UniformUDPConnection()
{
        sock = CL_INVALID_SOCKET;
        port = -1;
}

CL_UniformUDPConnection::~CL_UniformUDPConnection()
{
        if (sock != CL_INVALID_SOCKET) closesocket(sock);
}

bool CL_UniformUDPConnection::bind(unsigned int _port)
{
        int res;

        sock = socket(AF_INET, SOCK_DGRAM, 0);
        if (sock == CL_INVALID_SOCKET) return false;

        sockaddr_in addr;
        memset(&addr, 0, sizeof(sockaddr_in));
        addr.sin_family = AF_INET;
        addr.sin_addr.s_addr = INADDR_ANY;
        addr.sin_port = htons(_port);

        res = ::bind(sock, (sockaddr *) &addr, sizeof(addr));
        if (res == -1) throw CL_Error(PRINT_SOCK_ERROR());

        int enable = 1;
        res = setsockopt(
                sock,
                SOL_SOCKET,
                SO_BROADCAST,
                (const char *) &enable,
                sizeof(int));

        if (res == -1)
        {
                cl_info(info_network, PRINT_SOCK_ERROR());
                closesocket(sock);
                return false;
        }

        // Call getsockname to determine allocated port-number,
        // since socket might have been created with _port==0 (any)
        socklen_t len = sizeof(sockaddr_in);
        res = getsockname(sock, (sockaddr *) &addr, &len);
        if (res == -1) throw CL_Error(PRINT_SOCK_ERROR());

        port = ntohs(addr.sin_port);

        return true;
}

bool CL_UniformUDPConnection::peek()
{
        if (sock == CL_INVALID_SOCKET) return false;

        fd_set rfds;

        FD_ZERO(&rfds);
        FD_SET(sock, &rfds);

        timeval timeout;
        memset(&timeout, 0, sizeof(timeval));

        int retval = select(sock+1, &rfds, NULL, NULL, &timeout);
        if (retval == -1) return false;

        return (retval > 0);
}

CL_UDPConnectionPacket CL_UniformUDPConnection::receive()
{
        char *receive_buf = new char[8096];

        sockaddr_in addr;
        memset(&addr, 0, sizeof(sockaddr_in));
        addr.sin_family = AF_INET;
        socklen_t len_addr = sizeof(addr);
        int res = ::recvfrom(sock, receive_buf, 8096, 0, (sockaddr *) &addr, &len_addr);
        cl_assert(res != CL_SOCKET_ERROR);

        CL_UDPConnectionPacket ret;
        ret.data = receive_buf;
        ret.size = res;
        ret.ip_addr = addr.sin_addr.s_addr;
        ret.port = ntohs(addr.sin_port);

        return ret;
}

void CL_UniformUDPConnection::send(CL_UDPConnectionPacket message)
{
        sockaddr_in addr;
        memset(&addr, 0, sizeof(sockaddr_in));
        addr.sin_family = AF_INET;
        addr.sin_addr.s_addr = message.ip_addr;
        addr.sin_port = htons(message.port);

        cl_assert(sock != CL_INVALID_SOCKET);
        cl_assert(message.size < 2000);

        int res = ::sendto(
                sock,
                (char *) message.data,
                message.size,
                0,
                (sockaddr *) &addr,
                sizeof(sockaddr_in));

        if (res == CL_SOCKET_ERROR)
        {
                cl_info(info_network, PRINT_SOCK_ERROR());
        }

        cl_assert(res != -1);
}

void CL_UniformUDPConnection::broadcast(CL_UDPConnectionPacket message)
{
        cl_assert(sock != CL_INVALID_SOCKET);
        cl_assert(message.size < 2000);

        sockaddr_in addr;
        memset(&addr, 0, sizeof(sockaddr_in));
        addr.sin_family = AF_INET;
        addr.sin_addr.s_addr = INADDR_BROADCAST;
        addr.sin_port = htons(message.port);

        int res = ::sendto(
                sock,
                (char *) message.data,
                message.size,
                0,
                (sockaddr *) &addr,
                sizeof(sockaddr_in));
                
        if (res == -1)
        {
                cl_info(info_network, PRINT_SOCK_ERROR());
        }

        cl_assert(res != -1);
}

unsigned int CL_UniformUDPConnection::get_port()
{
        return port;
}

// error messages under win32 are hell as usual:

#ifdef WIN32
const char *get_win32_sock_error(DWORD err)
{
        switch (err)
        {
        case WSAEACCES: return "Permission denied";
        case WSAEADDRINUSE: return "Address already in use";
        case WSAEADDRNOTAVAIL: return "Cannot assign requested address";
        case WSAEAFNOSUPPORT: return "Address family not supported by protocol family";
        case WSAEALREADY: return "Operation already in progress";
        case WSAECONNABORTED: return "Software caused connection abort";
        case WSAECONNREFUSED: return "Connection refused";
        case WSAECONNRESET: return "Connection reset by peer";
        case WSAEDESTADDRREQ: return "Destination address required";
        case WSAEFAULT: return "Bad address";
        case WSAEHOSTDOWN: return "Host is down";
        case WSAEHOSTUNREACH: return "No route to host";
        case WSAEINPROGRESS: return "Operation now in progress";
        case WSAEINTR: return "Interrupted function call";
        case WSAEINVAL: return "Invalid argument";
        case WSAEISCONN: return "Socket is already connected";
        case WSAEMFILE: return "Too many open files";
        case WSAEMSGSIZE: return "Message too long";
        case WSAENETDOWN: return "Network is down";
        case WSAENETRESET: return "Network dropped connection on reset";
        case WSAENETUNREACH: return "Network is unreachable";
        case WSAENOBUFS: return "No buffer space available";
        case WSAENOPROTOOPT: return "Bad protocol option";
        case WSAENOTCONN: return "Socket is not connected";
        case WSAENOTSOCK: return "Socket operation on non-socket";
        case WSAEOPNOTSUPP: return "Operation not supported";
        case WSAEPFNOSUPPORT: return "Protocol family not supported";
        case WSAEPROCLIM: return "Too many processes";
        case WSAEPROTONOSUPPORT: return "Protocol not supported";
        case WSAEPROTOTYPE : return "Protocol wrong type for socket";
        case WSAESHUTDOWN: return "Cannot send after socket shutdown";
        case WSAESOCKTNOSUPPORT: return "Socket type not supported";
        case WSAETIMEDOUT: return "Connection timed out";
//      case WSATYPE_NOT_FOUND: return "Class type not found";
        case WSAEWOULDBLOCK: return "Resource temporarily unavailable";
//      case WSAHOST_NOT_FOUND: return "Host not found";
        case WSANOTINITIALISED: return "Successful WSAStartup not yet performed";
        case WSANO_DATA: return "Valid name, no data record of requested type";
        case WSANO_RECOVERY: return "This is a non-recoverable error";
        case WSASYSNOTREADY: return "Network subsystem is unavailable";
        case WSATRY_AGAIN: return "Non-authoritative host not found";
        case WSAVERNOTSUPPORTED: return "WINSOCK.DLL version out of range";
        case WSAEDISCON: return "Graceful shutdown in progress";
        default: return "Unknown WSA error";
        };

/*
        static char err_buffer[16*1024];
        FormatMessage(
                FORMAT_MESSAGE_FROM_SYSTEM,
                NULL,
                GetLastError(),
                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                err_buffer,
                16*1024,
                NULL);

        return err_buffer;
*/
}
#endif

---