net.c

Go to the documentation of this file.

#include "iothread.h"
#include "random.h"
#include "message.h"
#include "timesync.h"
#include "net.h"
#include <string.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <SDL.h>
#ifndef WIN32
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#include <fcntl.h>
#endif

const rtsa_char *GetNetErrorString(int err) {
    int errInd;
    switch (err) {
        case 0:
            errInd = STRING_ERR_NONE;
            break;
        case EWOULDBLOCK:
            errInd = STRING_ERR_WOULDBLOCK;
            break;
        case EBADF:
            errInd = STRING_ERR_BADF;
            break;          
        case EFAULT:
            errInd = STRING_ERR_FAULT;
            break;
        case EINTR:
            errInd = STRING_ERR_INTR;
            break;
        case EINVAL:
            errInd = STRING_ERR_INVAL;
            break;
        case ENOTSOCK:
            errInd = STRING_ERR_NOTSOCK;
            break;
        case EADDRINUSE:
            errInd = STRING_ERR_ADDRINUSE;
            break;
        case ENETDOWN:
            errInd = STRING_ERR_NETDOWN;
            break;
        case ENETUNREACH:
            errInd = STRING_ERR_NETUNREACH;
            break;
        case ECONNRESET:
            errInd = STRING_ERR_CONNRESET;
            break;
        case ECONNREFUSED:
            errInd = STRING_ERR_CONNREFUSED;
            break;
        case EHOSTUNREACH:
            errInd = STRING_ERR_HOSTUNREACH;
            break;
        default:
            errInd = STRING_ERR_DEFAULT;
    }
    assert(strings[errInd] != NULL);
    return strings[errInd];
}

int netError = 0;

ClientData *clients = NULL;

unsigned int networkState = NETSTATE_SEARCHING;

Uint32 clientRandId;

int sock = -1;

SocketAddr outgoingAddr;

extern Uint32 localPlayer;

static Bool ConfigNonBlocking(int sock) {
    #ifdef WIN32
    u_long val = 1;
    // make the change
    return ioctlsocket(sock, FIONBIO, &val) == 0;
    #else
    // get file options
    int options = fcntl(sock, F_GETFL);
    // check for success
    if (options >= 0) {
        // non-blocking
        options |= O_NONBLOCK;
        // set the new options
        return fcntl(sock, F_SETFL, options) >= 0;
    }
    return FALSE;
    #endif
}

static Bool ConfigIPv4Broadcast(Bool isServer) {
    int bcast = 1;
    assert(sock == -1);
    // open the socket
    if ((sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
        // failed
        #ifdef USE_GETTEXT
        printf("Could not open an IPv4 UDP socket: %ls\n",
        GetNetErrorString(GetNetErrorVal()));
        #else
        printf("Could not open an IPv4 UDP socket: %s\n",
        GetNetErrorString(GetNetErrorVal()));
        #endif
        return FALSE;
    }
    // make it a broadcasting socket
    setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (const char*)&bcast,
    sizeof(int));
    // setup the socket address for reception
    outgoingAddr.ipv4.sin_family = AF_INET;
    outgoingAddr.ipv4.sin_port = isServer ? htons(PORT_SRV) : htons(PORT_CLI);
    outgoingAddr.ipv4.sin_addr.s_addr = htonl(INADDR_ANY);
    // bind to the port that will receive data
    if (bind(sock, &(outgoingAddr.addr),
    outgoingAddr.length = sizeof(struct sockaddr_in))) {
        // failed to bind
        #ifdef USE_GETTEXT
        printf("Could not bind to UDP port %u: %ls\n",
        ntohs(outgoingAddr.ipv4.sin_port), GetNetErrorString(GetNetErrorVal()));
        #else
        printf("Could not bind to UDP port %u: %s\n",
        ntohs(outgoingAddr.ipv4.sin_port), GetNetErrorString(GetNetErrorVal()));
        #endif
        return FALSE;
    }
    // setup the outgoing socket address
    outgoingAddr.ipv4.sin_port = isServer ? htons(PORT_CLI) : htons(PORT_SRV);
    outgoingAddr.ipv4.sin_addr.s_addr = htonl(INADDR_BROADCAST);
    // success
    return ConfigNonBlocking(sock);
}

int UnicastSocket(void *addr, Bool block) {
    int sock;
    assert(addr != NULL);
    // setup socket to contact the indicated system
    if ((sock = socket(((SocketAddr*)addr)->addr.sa_family,
    SOCK_DGRAM, IPPROTO_UDP)) == -1) {
        // failure
        return -1;
    }
    // bind the socket
    if (bind(sock, &(((SocketAddr*)addr)->addr),
    (((SocketAddr*)addr)->addr.sa_family == AF_INET) ?
    sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6))) {
        // failure
        CloseSocket(sock);
        return -1;
    }
    // use non-blocking sockets?
    if (!block && !ConfigNonBlocking(sock)) {
        // failure
        CloseSocket(sock);
        return -1;
    }
    // success
    return sock;
}

static Bool SendConnectMsg(Bool bcast) {
    char buff[6];
    // Build the message
    // message type
    buff[0] = MSG_TYPE_CONN_REQ;
    // broadcast flag
    buff[1] = bcast;
    // random value
    MSG_WRITE_32C(buff, 2, clientRandId);
    // send the data
    return sendto(sock, buff, 6, 0, (struct sockaddr*)&outgoingAddr,
    outgoingAddr.length) == 6;
}

extern char statHost[MAX_HOST_LEN];

static void DiscoverConnectServer(void *srvstr) {
    int loop, delay = 32;
    // clear the string with the server's name
    memset(statHost, 0, MAX_HOST_LEN);
    // check for an input hostname
    if (srvstr) {
        // setup the socket address for the client to bind to
        outgoingAddr.ipv4.sin_family = AF_INET;
        outgoingAddr.ipv4.sin_port = htons(PORT_CLI);
        outgoingAddr.ipv4.sin_addr.s_addr = htonl(INADDR_ANY);
        // set the length of the outgoing socket address
        outgoingAddr.length = sizeof(struct sockaddr_in);
        // attempt to open the socket
        if ((sock = UnicastSocket(&outgoingAddr, FALSE)) == -1) {
            // failed
            networkState = NETSTATE_CONERR;
            netError = GetNetErrorVal();
            return;
        }
        // try to get the address and check for validity
        if (inet_pton(AF_INET, srvstr, &(outgoingAddr.ipv4.sin_addr)) <= 0) {
            // failed; discover a server instead
            srvstr = NULL;
        }
        else {
            // set the server port for outgoing messages
            outgoingAddr.ipv4.sin_port = htons(PORT_SRV);
        }
    }
    // if discovering a server on the LAN and the socket cannot be configured
    if (!srvstr && !ConfigIPv4Broadcast(FALSE)) {
        // failed -- no way to send server discovery messages
        networkState = NETSTATE_SEARCHERR;
        netError = GetNetErrorVal();
        return;
    }
    // set the operating state of the networking module
    networkState = srvstr ? NETSTATE_CONNECTING : NETSTATE_SEARCHING;
    // get a random number for the client's ID
    clientRandId = RandNum();
    // make 6 attempts
    for (loop = 0; (loop < 24) && !IsCancelationRequested(); loop++) {
        // send out a connect message every fourth time through the loop
        if (((loop & 3) == 0) && (delay += 32,
        !SendConnectMsg(srvstr ? FALSE : TRUE))) {
            // failure
            networkState = srvstr ? NETSTATE_CONERR : NETSTATE_SEARCHERR;
            netError = GetNetErrorVal();
            return;
        }
        // wait for a response for at least 32ms, up to 192ms
        SDL_Delay(delay);
        //FindServer_tryAgain:
        if (!ReceiveMessages()) {
            // network trouble
            networkState = srvstr ? NETSTATE_CONERR : NETSTATE_SEARCHERR;
            netError = GetNetErrorVal();
            return;
        }
        // check the new network state
        if ((networkState == NETSTATE_RCVCFG) ||
        (networkState == NETSTATE_CLIENT) || (networkState == NETSTATE_SRVDENY)) {
            // queue up getting the hostname of the server
            StartNameLookup(&outgoingAddr, statHost);
            if (networkState == NETSTATE_RCVCFG) {
                // queue up time synchronization
                StartClientTimeSync();
            }
            // done -- in communication with the server
            return;
        }
    }
    // connecting to specific server?
    if (srvstr) {
        printf("Could not connect to %s; falling back on server discovery\n",
        (char*)srvstr);
        // close the socket
        CloseSocket(sock);
        // try discovery
        DiscoverConnectServer(NULL);
    }
    // discovery?
    else {
        // no server found, so start the process of becomming the server
        NetCliToSrv();
    }
}

Bool NetInit(char *srv) {
    // set the inital state
    networkState = NETSTATE_INIT;
    // queue up the operation to find own host information
    QueueOperation(DoHostnameLookup, NULL);
    // queue up the connection operation
    QueueOperation(DiscoverConnectServer, srv);
    // initalize the messaging system
    return MessageInit();
}

Bool NetInitSrv() {
    // set the inital state
    networkState = NETSTATE_INIT;
    // queue up the operation to find own host information
    QueueOperation(DoHostnameLookup, NULL);
    // try to be the server
    NetCliToSrv();
    // initalize the messaging system
    return MessageInit();
}

static void Disconnect(void *ignore) {
    int loop;
    // allow about 4 seconds for the operation
    for (loop = 255; loop > 0; loop--) {
        // don't use too much CPU time
        SDL_Delay(16);
        // attempt to process incomming messages
        if (!ReceiveMessages()) {
            // failure -- no way to continue with a reliable disconnect
            #ifndef NDEBUG
            printf("Disconnect receive error\n");
            #endif
            break;
        }
        // handle any re-transmissions
        ServiceMessages();
        // see if there are no messages left
        if (GetNumOutgoingMessages() == 0) {
            // must have received acknowledgements, so time to end
            break;
        }
        // see if MsgFailDropConnection() has already completed the disconnect
        if (networkState == NETSTATE_INIT) {
            return;
        }
    }
    // transition to the inital state
    if (networkState == NETSTATE_SRVDISCONN) {
        NetSrvToCli();
    }
    else {
        CloseSocket(sock);
        networkState = NETSTATE_INIT;
        timeSyncState = TIMESYNC_IDLE;
    }
    #ifndef NDEBUG
    printf("Disconnect complete\n");
    #endif
}

void NetUninit() {
    // assure that the time sync operation is no longer running
    StopServerTimeSync();
    // if the process has not yet started to disconnect . . .
    if ((networkState == NETSTATE_RCVCFG) ||
    (networkState == NETSTATE_CLIENT) || (networkState == NETSTATE_SERVER)) {
        // remove all existing messages from the system
        CancelAllMessages();
        // inform remote host(s) of disconnection
        SendDisconnectMessage(localPlayer);
        // change the network state to reflect this
        networkState++;
        // disconnect from remote host(s)
        Disconnect(NULL);
    }
    // if the process is working on the disconnect . . .
    else if ((networkState == NETSTATE_CLIDISCONN) ||
    (networkState == NETSTATE_SRVDISCONN)) {
        // wait for the operation to complete
        /*
        do {
            SDL_Delay(25);
        } while (networkState != NETSTATE_INIT);
        */
        Disconnect(NULL);
    }
    // uninitialize the messaging system
    MessageUninit();
    // close the socket
    CloseSocket(sock);
    // if server-side client data was stored . . .
    if (clients) {
        // . . . get rid of it
        free(clients);
        clients = NULL;
    }
}

void NetDisconnect() {
    // assure that the time sync operation is no longer running
    StopServerTimeSync();
    // assure a disconnect occurs only when connected
    if ((networkState == NETSTATE_RCVCFG)
    || (networkState == NETSTATE_CLIENT) || (networkState == NETSTATE_SERVER)) {
        // try to clear the I/O thread
        CancelOperations();
        // remove all existing messages from the system
        CancelAllMessages();
        // inform remote host(s) of disconnection
        SendDisconnectMessage(localPlayer);
        // change the network state to reflect this
        networkState++;
        // handle the disconnect in the I/O thread
        QueueOperation(Disconnect, NULL);
    }
}

// Prototypes for externally defined functions that aren't called anywhere else
Bool MessageCliToSrv();
Bool MessageSrvToCli();

Bool NetCliToSrv() {
    // allocate memory for server specific data on each client
    if ((clients = calloc(MAX_PLAYERS, sizeof(ClientData))) == NULL) {
        // allocation failed!
        networkState = NETSTATE_SRVERR;
        netError = 0;
        return FALSE;
    }
    // close the socket
    CloseSocket(sock);
    // open the socket bound to a different port
    if (!ConfigIPv4Broadcast(TRUE) || !StartServerTimeSync()) {
        // no socket, no server
        free(clients);
        clients = NULL;
        networkState = NETSTATE_SRVERR;
        netError = GetNetErrorVal();
        return FALSE;
    }
    // setup the local client
    localPlayer = 0;
    clients->contact = clients->active = TRUE;
    // change the message system state
    if (MessageCliToSrv()) {
        // set the server state
        networkState = NETSTATE_SERVER;
        // sucess
        return TRUE;
    }
    StopServerTimeSync();
    // failure
    return FALSE;
}

Bool NetSrvToCli() {
    Bool result;
    assert(networkState == NETSTATE_SRVDISCONN);
    // server specific data on clients is not needed by a client, so
    // deallocate it
    free(clients);
    clients = NULL;
    // close the socket
    CloseSocket(sock);
    // the socket will need to be reopened
    // change the message system state
    result = MessageSrvToCli();
    // kill the time sync thread
    StopServerTimeSync();
    // set the new state
    networkState = NETSTATE_INIT;
    return result;
}

---