summaryrefslogtreecommitdiffhomepage
path: root/NetEx/NetPeer.h
blob: 3610f1b14a261eb5a8702ac0c0c779b73e7251c7 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
/*  Starshatter: The Open Source Project
    Copyright (c) 2021-2022, Starshatter: The Open Source Project Contributors
    Copyright (c) 2011-2012, Starshatter OpenSource Distribution Contributors
    Copyright (c) 1997-2006, Destroyer Studios LLC.

     AUTHOR:       John DiCamillo


     OVERVIEW
     ========
     One side of a UDP net link connection
*/


#ifndef NetPeer_h
#define NetPeer_h

#include <mutex>

#include <windows.h>
#include "NetAddr.h"
#include "List.h"

// +-------------------------------------------------------------------+

class NetGram;
class NetMsg;

// +-------------------------------------------------------------------+

class NetPeer
{
public:
    static const char* TYPENAME() { return "NetPeer"; }

    enum STATUS { OK, SEND_OVERFLOW, RECV_OVERFLOW };

    NetPeer(const NetAddr& addr, DWORD id);
    ~NetPeer();

    int operator == (const NetPeer& p)  const { return netid == p.netid; }

    bool              SendMessage(NetMsg* msg);
    NetMsg*           GetMessage();

    NetGram*          ComposeGram();
    bool              ReceiveGram(NetGram* g, List<NetMsg>* q=0);

    const NetAddr&    Address()         const { return addr;       }
    DWORD             NetID()           const { return netid;      }
    DWORD             Sequence()        const { return sequence;   }

    int               GetMaxPPS()       const { return pps;        }
    void              SetMaxPPS(int p)        { pps = p;           }
    int               GetMaxBPS()       const { return bps;        }
    void              SetMaxBPS(int b)        { bps = b;           }
    int               GetMaxQSize()     const { return max_qsize;  }
    void              SetMaxQSize(int q)      { max_qsize = q;     }

    DWORD             GetChunkSize()    const { return chunk_size; }
    void              SetChunkSize(DWORD s)   { chunk_size = s;    }

    DWORD             LastReceiveTime() const { return last_recv_time; }
    void              SetLastReceiveTime(DWORD t) { last_recv_time = t; }

private:
    bool              OKtoSend()        const;
    void              CheckMultiRecv(List<NetMsg>* q);

    NetAddr           addr;          // remote network address
    DWORD             sequence;      // highest packet id received
    DWORD             netid;         // unique id for this peer
    int               pps;           // max packets per second
    int               bps;           // max bits per second
    int               max_qsize;     // max bytes in either queue
    int               status;        // ok or error code
    DWORD             chunk_size;    // size of multipart message chunk

    enum HIST { HIST_SIZE=8 };

    DWORD             last_recv_time;         // time of last received packet
    DWORD             hist_time[HIST_SIZE];   // history for pps check
    DWORD             hist_size[HIST_SIZE];   // history for bps check
    int               hist_indx;              // index into history

    int               send_size;     // total bytes in send list
    int               recv_size;     // total bytes in recv list
    List<NetMsg>      send_list;     // queue of messages waiting to be sent
    List<NetMsg>      recv_list;     // queue of messages waiting to be read

    List<NetMsg>      multi_send_list;
    List<NetMsg>      multi_recv_list;

    std::mutex        sync;
};


#endif  // NetPeer_h