netbase.h

Go to the documentation of this file.

/*
 * netbase.h by Matze Braun <[email protected]>
 *
 * Copyright (C) 2001 Atomic Blue ([email protected], http://www.atomicblue.org)
 *
 *
 * 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 (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.
 *
 * This file defines some inline functions which are used in client and server
 * network functions, the client/server interface classes should be derived from
 * this base class
 */
#ifndef __NETBASE_H__
#define __NETBASE_H__

#include "net/pstypes.h"
#include "net/netinfos.h"
#include "net/netpacket.h"
#include "util/genrefqueue.h"
#include <csutil/ref.h>
#include <csutil/weakref.h>
#include <csutil/weakreferenced.h>
#include <csutil/refcount.h>
#include <csutil/strset.h>
#include <csutil/array.h>
#include "netprofile.h"

#define NUM_BROADCAST        0xffffffff
#define MAXQUEUESIZE        20000
#define MAXCLIENTQUEUESIZE  5000
#define MAXPACKETHISTORY    1009 // Should be a prime to improve performance of hash
                                 // This must be set carefully and ideally should be at least the size
                                 // of the input queue
#define NETAVGCOUNT 400
#define RESENDAVGCOUNT 200

const unsigned int WINDOW_MAX_SIZE = 65536; // The size of the maximum reliable window in bytes.

// The number of times the SendTo function will retry on a EAGAIN or EWOULDBLOCK
#define SENDTO_MAX_RETRIES   200
// The whole seconds that the SendTo function will block each cycle waiting for the write state to change on the socket
#define SENDTO_SELECT_TIMEOUT_SEC 0
// The microseconds (1/10^6 s) that the SendTo function will block each cycle waiting for the write state to change on the socket
#define SENDTO_SELECT_TIMEOUT_USEC 10000

/* Include platform specific socket settings */
#ifdef USE_WINSOCK
#   include "net/sockwin.h"
#endif
#ifdef USE_UNISOCK
#   include "net/sockuni.h"
#endif

// Jorrit: hack for mingw.
#ifdef SendMessage
#undef SendMessage
#endif
#ifdef SetJob
#undef SetJob
#endif
#ifdef GetJob
#undef GetJob
#endif

class MsgEntry;
class NetPacketQueueRefCount;
class csRandomGen;
class csStringHashReversible;
struct iEngine;
typedef GenericRefQueue <MsgEntry> MsgQueue;
typedef GenericRefQueue <psNetPacketEntry> NetPacketQueue;

/*
 * Microsoft sockets do not use Berkeley error codes or functions in all cases.
 * This is the workaround.
 * http://msdn.microsoft.com/en-us/library/ms737828(VS.85).aspx
 *      Ravna 19/3/2016: This breaks msvc2015, since various internal libraries like String use errno, and can't assign to it if it is not a value, 
 *      so I changed the 3 values the macro originally replaced. Left this for reference.
 */

#ifndef CS_PLATFORM_WIN32
#define WSAEWOULDBLOCK EAGAIN
#endif


struct PublishDestination
{
    uint32_t client;
    void*    object;
    float    dist;
    float    min_dist;

    PublishDestination(int client, void* object, float dist, float min_dist) : client(client), object(object), dist(dist), min_dist(min_dist) {}
};

//-----------------------------------------------------------------------------

class NetBase
{
public:

    struct AccessPointers
    {
        // msgstrings are loaded by CacheManager and mantained in CacheManager.msg_strings
        // then sent from server to client at login with psMsgStringsMessage
        // and stored in <appdata>/cache/commonstrings client side
        csStringSet* msgstrings;
        csStringHashReversible* msgstringshash;
        iEngine *engine;

        const char* Request(csStringID id) const;

        csStringID Request(const char* string) const;
    };

    
    NetBase(int outqueuelen=100);
    virtual ~NetBase();

    bool AddMsgQueue (MsgQueue *,objID minID=0,objID maxID=0xffffffff);

    void RemoveMsgQueue(MsgQueue *);

    virtual bool SendMessage (MsgEntry* me);
    virtual bool SendMessage (MsgEntry* me,NetPacketQueueRefCount *queue);

    virtual void Broadcast (MsgEntry* me, int scope, int guildID) = 0;

    virtual void Multicast (MsgEntry* me, const csArray<PublishDestination>& multi, uint32_t except, float range) = 0;

    bool IsReady()  { return ready; }

    bool QueueMessage(MsgEntry *me);

    void ProcessNetwork (csTicks timeout);

    bool SendOut(void);

    bool CheckIn(void);

    bool Flush(MsgQueue * queue);

    bool Bind(const char* addr, int port);
    bool Bind(const IN_ADDR &addr, int port);

    class Connection;

    enum broadcasttype
    {
    BC_EVERYONEBUTSELF = 1,
    BC_GROUP = 2,
    BC_GUILD = 3,
    BC_SECTOR = 4,
    BC_EVERYONE = 5,
    BC_FINALPACKET = 6
    };

    csTicks GetPing(void) { return netInfos.GetAveragePingTicks();}

    psNetMsgProfiles * GetProfs() { return profs; }

    struct timeval timeout;

    void SetMsgStrings(csStringSet* msgstrings, csStringHashReversible* msgstringshash)
    {
        accessPointers.msgstrings = msgstrings;
        accessPointers.msgstringshash = msgstringshash;
    }

    void SetEngine(iEngine* engine) { accessPointers.engine = engine; }

    iEngine* GetEngine() { return accessPointers.engine; }

    static AccessPointers* GetAccessPointers() { return &accessPointers; }
    
    void LogMessages(char dir, MsgEntry* me);

    csString LogMessageFilter(const char *arg);

    void AddFilterLogMessage(int type);

    void RemoveFilterLogMessage(int type);

    void LogMessageFilterClear();

    void InvertLogMessageFilter() { logmsgfiltersetting.invert = !logmsgfiltersetting.invert; }

    void ToggleReceiveMessageFilter() { logmsgfiltersetting.receive = !logmsgfiltersetting.receive; }

    void ToggleSendMessageFilter() { logmsgfiltersetting.send = !logmsgfiltersetting.send; }

    void SetLogMessageFilterHex(bool filterhex) { logmsgfiltersetting.filterhex = filterhex; }

    void LogMessageFilterDump();

    uint32_t GetRandomID();

protected:
    bool FilterLogMessage(int type,char dir);

    /* the following protected stuff is thought of being used in the inherited
     * network classes
     */

    int SendTo (LPSOCKADDR_IN addr, const void *data, unsigned int size)
    {
        struct timeval timeout;
        int sentbytes;
        int retries=0;
        fd_set wfds;

        #ifdef DEBUG
            if (!addr || !data)
            Error1("wrong args");
        #endif

        // #define ENDIAN_DEBUG

        #ifdef ENDIAN_DEBUG
            FILE *f = fopen("hexdump.txt","a");
            int i;
            int len;
            char c;
            const char *ptr;
            ptr = (const char *)data;
            len = ((40<size) ? 40 : size);
            fprintf(f,"\n------------\nSending %d bytes:\n",len);
            for ( i = 0 ; i < len ; i++ ) /* Print the hex dump for len chars. */
                fprintf(f,"%02x " ,(*(ptr+i)&0xff));
            for ( i = len ; i < 16 ; i++ ) /* Pad out the dump field to the ASCII */
                fprintf(f, "   " ); /* field. */
            fprintf(f, " " );
            for ( i = 0 ; i < len ; i++ ) /* Now print the ASCII field. */
            {
                 c=0x7f&(*(ptr+i)); /* mask out bit 7 */
                 if (!(isprint(c))) /* If not printable */
                     fprintf(f, "." ); /* print a dot */
                 else {
                     fprintf(f, "%c" ,c);
                 } /* else display it */
            }
            fprintf(f,"\n-----------------\n");
            fclose(f);
        #endif

        // Try and send the data, if we fail we wait for the status to change
        sentbytes=SOCK_SENDTO(mysocket, data, size, 0, (LPSOCKADDR) addr, sizeof (SOCKADDR_IN) );


        /* Call select() to wait until precisely the time of the change, but have a timeout.
         *  It's possible that the buffer will free between the sendto call and the select
         *  leaving the select hanging forever if not for the timeout value.
         */
#ifdef CS_PLATFORM_WIN32 
        while (retries++ < SENDTO_MAX_RETRIES && sentbytes == -1 && (WSAGetLastError() == EAGAIN || WSAGetLastError() == WSAEWOULDBLOCK))
#else
                while (retries++ < SENDTO_MAX_RETRIES && sentbytes == -1 && (errno == EAGAIN || errno == WSAEWOULDBLOCK))
#endif
        {
            printf("In while loop on EAGAIN... retry #%d.\n", retries);

            // Clear the file descriptor set
            FD_ZERO(&wfds);
            // Set the socket's FD in this set
            FD_SET(mysocket,&wfds);

            // Zero out the timeout value to start
            memset(&timeout,0,sizeof(struct timeval));
            timeout.tv_sec=SENDTO_SELECT_TIMEOUT_SEC;
            timeout.tv_usec=SENDTO_SELECT_TIMEOUT_USEC;

            /* Wait for the descriptor to change.  Note that it's possible that the status
             * has already cleared, so we'll try to send again after this anyway.
             */
            SOCK_SELECT(mysocket+1,NULL,&wfds,NULL,&timeout);

            // Try and send again.
            sentbytes=SOCK_SENDTO(mysocket, data, size, 0, (LPSOCKADDR) addr, sizeof (SOCKADDR_IN) );
        }

        if (sentbytes>0)
        {
            totaltransferout += size;
            totalcountout++;
        }
        else
        {
#ifdef CS_PLATFORM_WIN32
            Error2("NetBase::SendTo() gave up trying to send a packet with errno=%d.", WSAGetLastError());
#else
                        Error2("NetBase::SendTo() gave up trying to send a packet with errno=%d.", errno);
#endif
        }

        return sentbytes;
    }

    int RecvFrom (LPSOCKADDR_IN addr, socklen_t *socklen, void *buf,
        unsigned int maxsize)
    {
        #ifdef DEBUG
        if (!addr || !buf)
            Error1("wrong args");
        #endif
        fd_set set;

        /* Initialize the file descriptor set. */
        FD_ZERO (&set);
        FD_SET (mysocket, &set);
#ifndef CS_PLATFORM_WIN32
        if(pipe_fd[0] > 0)
            FD_SET (pipe_fd[0], &set);
#endif

        // Backup the timeval struct in case select changes it as on Linux
        struct timeval prevTimeout = timeout;

        /* select returns 0 if timeout, 1 if input available, -1 if error. */
        if (SOCK_SELECT(csMax(mysocket, pipe_fd[0]) + 1, &set, NULL, NULL, &timeout) < 1)
        {
            timeout = prevTimeout;
            return 0;
        }

#ifndef CS_PLATFORM_WIN32
        if(FD_ISSET(pipe_fd[0], &set))
        {
            char throwaway[32];
            if(read(pipe_fd[0], throwaway, 32) == -1)
            {
               Error1("Read failed!");
            }
        }
#endif

        timeout = prevTimeout;

        if(!FD_ISSET(mysocket, &set))
            return 0;

        int err = SOCK_RECVFROM (mysocket, buf, maxsize, 0,
            (LPSOCKADDR) addr, socklen);
        if (err>=0)
        {
            totaltransferin += err;
            totalcountin++;
        }
        return err;
    }


    int GetIPByName (LPSOCKADDR_IN addr, const char *name);

    virtual Connection *GetConnByIP (LPSOCKADDR_IN addr) = 0;

    virtual Connection *GetConnByNum (uint32_t clientnum) = 0;

    virtual bool HandleUnknownClient (LPSOCKADDR_IN addr, MsgEntry *data) = 0;

    bool Init(bool autobind = true);

    void Close(bool force = true);

    bool HandleAck(psNetPacketEntry* pkt, Connection* connection, LPSOCKADDR_IN addr);

    void CheckResendPkts(void);

    bool BuildMessage(psNetPacketEntry* pkt,Connection* &connection,LPSOCKADDR_IN addr);

    void CheckFragmentTimeouts(void);

    csPtr<MsgEntry> CheckCompleteMessage(uint32_t client,uint32_t id);

    void HandleCompletedMessage(MsgEntry *me,
                Connection* &connection,
                LPSOCKADDR_IN addr,
                psNetPacketEntry* pkt);

    bool CheckDoublePackets (Connection* connection, psNetPacketEntry* pkt);


    bool SendMergedPackets(NetPacketQueue *q);

    bool SendSinglePacket(psNetPacketEntry* pkt);

    bool SendFinalPacket(psNetPacketEntry* pkt);

    bool SendFinalPacket(psNetPacketEntry* pkt, LPSOCKADDR_IN addr);

    csRef<NetPacketQueueRefCount> NetworkQueue;

    GenericRefQueue<NetPacketQueueRefCount, csWeakRef > senders;

    csArray<MsgQueue*> inqueues;

    csHash<csRef<psNetPacketEntry>, PacketKey> awaitingack;

    static int socklibrefcount;

    bool ready;

    long totaltransferin, totaltransferout;
    long totalcountin, totalcountout;

    typedef struct {
        unsigned int senders;
        unsigned int messages;
        csTicks time;
    } SendQueueStats_t;

    SendQueueStats_t sendStats[NETAVGCOUNT];
    csTicks lastSendReport;
    unsigned int avgIndex;

    size_t resends[RESENDAVGCOUNT];
    unsigned int resendIndex;

    psNetMsgProfiles * profs;

private:
    SOCKET mysocket;

    SOCKET pipe_fd[2];

    csHash<csRef<psNetPacketEntry> , PacketKey> packets;

    csRandomGen* randomgen;

    CS::Threading::Mutex mutex;

    psNetInfos netInfos;

    static AccessPointers accessPointers;

    csArray<int> logmessagefilter;

    typedef struct {
        bool invert;
        bool filterhex;
        bool receive;
        bool send;
    } LogMsgFilterSetting_t;

    LogMsgFilterSetting_t logmsgfiltersetting;

    char* input_buffer;
};


//-----------------------------------------------------------------------------


class NetBase::Connection
{
    uint32_t sequence;
public:
    csHash<uint32_t> packethistoryhash;
    void *buf;
    SOCKADDR_IN addr;
    csString nameAddr;
    int pcknumin;
    int pcknumout;
    bool valid;
    uint32_t clientnum;
    csTicks lastRecvPacketTime;
    int heartbeat;
    float estRTT;
    float devRTT;
    csTicks RTO;
    uint32_t sends;
    uint32_t resends;
    
    // Reliable transmission window size
    uint32_t window;

    uint32_t packethistoryid[MAXPACKETHISTORY];
    uint32_t packethistoryoffset[MAXPACKETHISTORY];
    int historypos;

    Connection(uint32_t num=0);
    ~Connection();
    bool isValid() const
    { return valid; }

    uint32_t GetNextPacketID() {return sequence++;}
    
    bool IsWindowFull() {return window > WINDOW_MAX_SIZE; }
    void AddToWindow(uint32_t bytes) {window += bytes; }
    void RemoveFromWindow(uint32_t bytes) { if(bytes > window) abort(); window -= bytes;}
};


//-----------------------------------------------------------------------------


class NetPacketQueueRefCount : public NetPacketQueue, public csSyncRefCount, public CS::Utility::WeakReferenced
{
private:
    bool pending;

public:
    NetPacketQueueRefCount(int qlen)
    : NetPacketQueue(qlen)
    { pending=false; }
    virtual ~NetPacketQueueRefCount()
    {}

    void SetPending(bool flag)
    {
        pending = flag;
    }
    bool GetPending()
    {
        return pending;
    }
};

#endif