____                _       __
    / __ )____  _____   | |     / /___ ___________
   / __  / __ \/ ___/   | | /| / / __ `/ ___/ ___/
  / /_/ / /_/ (__  )    | |/ |/ / /_/ / /  (__  )
 /_____/\____/____/     |__/|__/\__,_/_/  /____/

       A futuristic real-time strategy game.
          This file is part of Bos Wars.

(C) Copyright 2001-2007 by the Bos Wars and Stratagus Project. Distributed under the "GNU General Public License"

---

lowlevel.cpp

Go to the documentation of this file.

//     ____                _       __               
//    / __ )____  _____   | |     / /___ ___________
//   / __  / __ \/ ___/   | | /| / / __ `/ ___/ ___/
//  / /_/ / /_/ (__  )    | |/ |/ / /_/ / /  (__  ) 
// /_____/\____/____/     |__/|__/\__,_/_/  /____/  
//                                              
//       A futuristic real-time strategy game.
//          This file is part of Bos Wars.
//
//
//      (c) Copyright 2000-2007 by Lutz Sammer and Jimmy Salmon
//
//      This program is free software; you can redistribute it and/or modify
//      it under the terms of the GNU General Public License as published by
//      the Free Software Foundation; only version 2 of the License.
//
//      This program is distributed in the hope that it will be useful,
//      but WITHOUT ANY WARRANTY; without even the implied warranty of
//      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//      GNU General Public License for more details.
//
//      You should have received a copy of the GNU General Public License
//      along with this program; if not, write to the Free Software
//      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
//      02111-1307, USA.
//


//----------------------------------------------------------------------------
//  Includes
//----------------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>

#ifndef _MSC_VER
#include <signal.h>
#endif

#include "stratagus.h"
#include "net_lowlevel.h"
#include "network.h"

//----------------------------------------------------------------------------
//  Declarations
//----------------------------------------------------------------------------

#define MAX_LOC_IP 10

#if defined(_MSC_VER) || defined(__MINGW32__)
typedef const char *setsockopttype;
typedef char *recvfrombuftype;
typedef char *recvbuftype;
typedef const char *sendtobuftype;
typedef const char *sendbuftype;
typedef int socklen_t;
#else
typedef const void *setsockopttype;
typedef void *recvfrombuftype;
typedef void *recvbuftype;
typedef const void *sendtobuftype;
typedef const void *sendbuftype;
#endif

//----------------------------------------------------------------------------
//  Variables
//----------------------------------------------------------------------------

int NetLastSocket;         
unsigned long NetLastHost; 
int NetLastPort;           

unsigned long NetLocalAddrs[MAX_LOC_IP]; 

//----------------------------------------------------------------------------
//  Low level functions
//----------------------------------------------------------------------------

#ifdef USE_WINSOCK // {

int NetInit(void)
{
    WSADATA wsaData;

    // Start up the windows networking
    if (WSAStartup(MAKEWORD(2, 2), &wsaData)) {
        fprintf(stderr, "Couldn't initialize Winsock 2\n");
        return -1;
    }
    return 0;
}

void NetExit(void)
{
    // Clean up windows networking
    if (WSACleanup() == SOCKET_ERROR) {
        if (WSAGetLastError() == WSAEINPROGRESS) {
            WSACancelBlockingCall();
            WSACleanup();
        }
    }
}

void NetCloseUDP(Socket sockfd)
{
    closesocket(sockfd);
}

void NetCloseTCP(Socket sockfd)
{
    closesocket(sockfd);
}

#endif // } !USE_WINSOCK

#if !defined(USE_WINSOCK) // {

int NetInit(void)
{
    return 0;
}

void NetExit(void)
{
}

void NetCloseUDP(Socket sockfd)
{
    close(sockfd);
}

void NetCloseTCP(Socket sockfd)
{
    close(sockfd);
}

#endif // } !USE_WINSOCK

#ifdef USE_WINSOCK
int NetSetNonBlocking(Socket sockfd)
{
    unsigned long opt = 1;
    return ioctlsocket(sockfd, FIONBIO, &opt);
}
#else
int NetSetNonBlocking(Socket sockfd)
{
    int flags = fcntl(sockfd, F_GETFL, 0);
    return fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
}
#endif

unsigned long NetResolveHost(const std::string &host)
{
    unsigned long addr;

    if (!host.empty()) {
        addr = inet_addr(host.c_str()); // try dot notation
        if (addr == INADDR_NONE) {
            struct hostent *he;

            he = 0;
            he = gethostbyname(host.c_str());
            if (he) {
                addr = 0;
                Assert(he->h_length == 4);
                memcpy(&addr, he->h_addr, he->h_length);
            }
        }
        return addr;
    }
    return INADDR_NONE;
}

#ifdef USE_WINSOCK // {
// ARI: MS documented this for winsock2, so I finally found it..
// I also found a way for winsock1.1 (= win95), but
// that one was too complex to start with.. -> trouble
// Lookout for INTRFC.EXE on the MS web site...
int NetSocketAddr(const Socket sock)
{
    INTERFACE_INFO localAddr[MAX_LOC_IP];  // Assume there will be no more than MAX_LOC_IP interfaces
    DWORD bytesReturned;
    SOCKADDR_IN *pAddrInet;
    u_long SetFlags;
    int i;
    int nif;
    int wsError;
    int numLocalAddr;

    nif = 0;
    if (sock != (Socket)-1) {
        wsError = WSAIoctl(sock, SIO_GET_INTERFACE_LIST, NULL, 0, &localAddr,
            sizeof(localAddr), &bytesReturned, NULL, NULL);
        if (wsError == SOCKET_ERROR) {
            DebugPrint("SIOCGIFCONF:WSAIoctl(SIO_GET_INTERFACE_LIST) - errno %d\n" _C_
                WSAGetLastError());
        }

        // parse interface information
        numLocalAddr = (bytesReturned / sizeof(INTERFACE_INFO));
        for (i = 0; i < numLocalAddr; ++i) {
            SetFlags = localAddr[i].iiFlags;
            if ((SetFlags & IFF_UP) == 0) {
                continue;
            }
            if ((SetFlags & IFF_LOOPBACK)) {
                continue;
            }
            pAddrInet = (SOCKADDR_IN *)&localAddr[i].iiAddress;
            NetLocalAddrs[nif] = pAddrInet->sin_addr.s_addr;
            ++nif;
            if (nif == MAX_LOC_IP) {
                break;
            }
        }
    }
    return nif;
}
#else // } { !USE_WINSOCK
#ifdef unix // {
// ARI: I knew how to write this for a unix environment,
// but am quite certain that porting this can cause you
// trouble..
int NetSocketAddr(const Socket sock)
{
    char buf[4096];
    char *cp;
    char *cplim;
    struct ifconf ifc;
    struct ifreq ifreq;
    struct ifreq *ifr;
    struct sockaddr_in *sap;
    struct sockaddr_in sa;
    int i;
    int nif;

    nif = 0;
    if (sock != (Socket)-1) {
        ifc.ifc_len = sizeof(buf);
        ifc.ifc_buf = buf;
        if (ioctl(sock, SIOCGIFCONF, (char *)&ifc) < 0) {
            DebugPrint("SIOCGIFCONF - errno %d\n" _C_ errno);
            return 0;
        }
        // with some inspiration from routed..
        ifr = ifc.ifc_req;
        cplim = buf + ifc.ifc_len; // skip over if's with big ifr_addr's
        for (cp = buf; cp < cplim;
                cp += sizeof(ifr->ifr_name) + sizeof(ifr->ifr_ifru)) {
            ifr = (struct ifreq *)cp;
            ifreq = *ifr;
            if (ioctl(sock, SIOCGIFFLAGS, (char *)&ifreq) < 0) {
                DebugPrint("%s: SIOCGIFFLAGS - errno %d\n" _C_
                    ifr->ifr_name _C_ errno);
                continue;
            }
            if ((ifreq.ifr_flags & IFF_UP) == 0 ||
                    ifr->ifr_addr.sa_family == AF_UNSPEC) {
                continue;
            }
            // argh, this'll have to change sometime
            if (ifr->ifr_addr.sa_family != AF_INET) {
                continue;
            }
            if (ifreq.ifr_flags & IFF_LOOPBACK) {
                continue;
            }
            sap = (struct sockaddr_in *)&ifr->ifr_addr;
            sa = *sap;
            NetLocalAddrs[nif] = sap->sin_addr.s_addr;
            if (ifreq.ifr_flags & IFF_POINTOPOINT) {
                if (ioctl(sock, SIOCGIFDSTADDR, (char *)&ifreq) < 0) {
                    DebugPrint("%s: SIOCGIFDSTADDR - errno %d\n" _C_
                        ifr->ifr_name _C_ errno);
                    // failed to obtain dst addr - ignore
                    continue;
                }
                if (ifr->ifr_addr.sa_family == AF_UNSPEC) {
                    continue;
                }
            }
            // avoid p-t-p links with common src
            if (nif) {
                for (i = 0; i < nif; ++i) {
                    if (sa.sin_addr.s_addr == NetLocalAddrs[i]) {
                        i = -1;
                        break;
                    }
                }
                if (i == -1) {
                    continue;
                }
            }
            ++nif;
            if (nif == MAX_LOC_IP) {
                break;
            }
        }
    }
    return nif;
}
#else // } !unix
// Beos?? Mac??
int NetSocketAddr(const Socket sock)
{
    NetLocalAddrs[0] = htonl(0x7f000001);
    return 1;
}
#endif
#endif // } !USE_WINSOCK

Socket NetOpenUDP(int port)
{
    Socket sockfd;

    // open the socket
    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == INVALID_SOCKET) {
        return (Socket)-1;
    }
    // bind local port
    if (port) {
        struct sockaddr_in sock_addr;

        memset(&sock_addr, 0, sizeof(sock_addr));
        sock_addr.sin_family = AF_INET;
        sock_addr.sin_addr.s_addr = INADDR_ANY;
        sock_addr.sin_port = htons(port);
        // Bind the socket for listening
        if (bind(sockfd, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) < 0) {
            fprintf(stderr, "Couldn't bind to local port\n");
            NetCloseUDP(sockfd);
            return (Socket)-1;
        }
        NetLastHost = sock_addr.sin_addr.s_addr;
        NetLastPort = sock_addr.sin_port;
    }
    return sockfd;
}

Socket NetOpenTCP(int port)
{
    Socket sockfd;

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == INVALID_SOCKET) {
        return (Socket)-1;
    }
    // bind local port
    if (port) {
        struct sockaddr_in sock_addr;
        int opt;

        memset(&sock_addr, 0, sizeof(sock_addr));
        sock_addr.sin_family = AF_INET;
        sock_addr.sin_addr.s_addr = INADDR_ANY;
        sock_addr.sin_port = htons(port);

        opt = 1;
        setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (setsockopttype)&opt, sizeof(opt));

        if (bind(sockfd,(struct sockaddr *)&sock_addr, sizeof(sock_addr)) < 0) {
            fprintf(stderr, "Couldn't bind to local port\n");
            NetCloseTCP(sockfd);
            return (Socket)-1;
        }
        NetLastHost = sock_addr.sin_addr.s_addr;
        NetLastPort = sock_addr.sin_port;
    }
    NetLastSocket = sockfd;
    return sockfd;
}

int NetConnectTCP(Socket sockfd, unsigned long addr, int port)
{
    struct sockaddr_in sa;
#ifndef __BEOS__
    int opt;

    opt = 1;
    setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (setsockopttype)&opt, sizeof(opt));
    opt = 0;
    setsockopt(sockfd, SOL_SOCKET, SO_LINGER, (setsockopttype)&opt, sizeof(opt));
#endif

    if (addr == INADDR_NONE) {
        return -1;
    }

    memset(&sa, 0, sizeof(sa));
    memcpy(&sa.sin_addr, &addr, sizeof(addr));
    sa.sin_family = AF_INET;
    sa.sin_port = htons(port);

    if (connect(sockfd, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
        fprintf(stderr, "connect to %d.%d.%d.%d:%d failed\n",
            NIPQUAD(ntohl(addr)), port);
        return -1;
    }

    return sockfd;
}

int NetSocketReady(Socket sockfd, int timeout)
{
    int retval;
    struct timeval tv;
    fd_set mask;

    // Check the file descriptors for available data
    do {
        // Set up the mask of file descriptors
        FD_ZERO(&mask);
        FD_SET(sockfd, &mask);

        // Set up the timeout
        tv.tv_sec = timeout / 1000;
        tv.tv_usec = (timeout % 1000) * 1000;

        // Data available?
        retval = select(sockfd + 1, &mask, NULL, NULL, &tv);
#ifdef USE_WINSOCK
    } while (retval == SOCKET_ERROR && WSAGetLastError() == WSAEINTR);
#else
    } while (retval == -1 && errno == EINTR);
#endif

    return retval;
}

int NetSocketSetReady(SocketSet *set, int timeout)
{
    int retval;
    struct timeval tv;
    fd_set mask;

    // Check the file descriptors for available data
    do {
        // Set up the mask of file descriptors
        FD_ZERO(&mask);
        for (size_t i = 0; i < set->Sockets.size(); ++i) {
            FD_SET(set->Sockets[i], &mask);
        }

        // Set up the timeout
        tv.tv_sec = timeout / 1000;
        tv.tv_usec = (timeout % 1000) * 1000;

        // Data available?
        retval = select(set->MaxSockFD + 1, &mask, NULL, NULL, &tv);
#ifdef USE_WINSOCK
    } while (retval == SOCKET_ERROR && WSAGetLastError() == WSAEINTR);
#else
    } while (retval == -1 && errno == EINTR);
#endif

    for (size_t i = 0; i < set->Sockets.size(); ++i) {
        set->SocketReady[i] = FD_ISSET(set->Sockets[i], &mask);
    }

    return retval;
}

int NetSocketSetSocketReady(SocketSet *set, Socket socket)
{
    for (size_t i = 0; i < set->Sockets.size(); ++i) {
        if (set->Sockets[i] == socket) {
            return set->SocketReady[i];
        }
    }
    DebugPrint("Socket not found in socket set\n");
    return 0;
}

int NetRecvUDP(Socket sockfd, void *buf, int len)
{
    socklen_t n;
    int l;
    struct sockaddr_in sock_addr;

    n = sizeof(struct sockaddr_in);
    if ((l = recvfrom(sockfd, (recvfrombuftype)buf, len, 0, (struct sockaddr *)&sock_addr, &n)) < 0) {
        PrintFunction();
        fprintf(stdout, "Could not read from UDP socket\n");
        return -1;
    }

    // Packet check for validness is done higher up, we don't know who should be
    // sending us packets at this level

    NetLastHost = sock_addr.sin_addr.s_addr;
    NetLastPort = sock_addr.sin_port;

    return l;
}

int NetRecvTCP(Socket sockfd, void *buf, int len)
{
    int ret;

    NetLastSocket = sockfd;
    ret = recv(sockfd, (recvbuftype)buf, len, 0);
    if (ret > 0) {
        return ret;
    }
    if (ret == 0) {
        return -1;
    }
#ifdef USE_WINSOCK
    if (WSAGetLastError() == WSAEWOULDBLOCK) {
#else
    if (errno == EWOULDBLOCK || errno == EAGAIN) {
#endif
        return 0;
    }
    return ret;
}

int NetSendUDP(Socket sockfd, unsigned long host, int port,
    const void *buf, int len)
{
    int n;
    struct sockaddr_in sock_addr;

    n = sizeof(struct sockaddr_in);
    sock_addr.sin_addr.s_addr = host;
    sock_addr.sin_port = port;
    sock_addr.sin_family = AF_INET;

    // if (MyRand() % 7) { return 0; }

    return sendto(sockfd, (sendtobuftype)buf, len, 0, (struct sockaddr *)&sock_addr, n);
}

int NetSendTCP(Socket sockfd, const void *buf, int len)
{
    return send(sockfd, (sendbuftype)buf, len, 0);
}

int NetListenTCP(Socket sockfd)
{
    return listen(sockfd, PlayerMax);
}

Socket NetAcceptTCP(Socket sockfd)
{
    struct sockaddr_in sa;
    socklen_t len;

    len = sizeof(struct sockaddr_in);
    NetLastSocket = accept(sockfd, (struct sockaddr *)&sa, &len);
    NetLastHost = sa.sin_addr.s_addr;
    NetLastPort = sa.sin_port;
    return NetLastSocket;
}

void SocketSet::AddSocket(Socket socket)
{
    Sockets.push_back(socket);
    SocketReady.push_back(0);
    if (socket > MaxSockFD) {
        MaxSockFD = socket;
    }
}

void SocketSet::DelSocket(Socket socket)
{
    std::vector<Socket>::iterator i;
    std::vector<int>::iterator j;

    for (i = Sockets.begin(), j = SocketReady.begin(); i != Sockets.end(); ++i, ++j) {
        if (*i == socket) {
            Sockets.erase(i);
            SocketReady.erase(j);
            break;
        }
    }
    if (socket == MaxSockFD) {
        MaxSockFD = 0;
        for (i = Sockets.begin(); i != Sockets.end(); ++i) {
            if (*i > MaxSockFD) {
                MaxSockFD = *i;
            }
        }
    }
}

---