1

#ifndef NETWORK_SESSION_HH

     2

#define NETWORK_SESSION_HH

     3

    10

#include <map>

    11

#include <stdint.h>

    12

    13

// forward-declare

    14

class NetworkSession;

    15

    16

/**

    17

 * A NetworkSession puts each packet onto a specific channel, which can the be used to run multiple different modules

    18

 * on top of a single session.

    19

 *

    20

 * NetworkChannelID zero is reserved for internal NetworkSession use

    21

 */

    22

typedef uint16_t NetworkChannelID;

    23

    24

/**

    25

 * Size of a NetworkSession's packet header:

    26

 *  uint16      channel_id

    27

 */

    28

const size_t NETWORK_SESSION_HEADER_SIZE = sizeof(uint16_t);

    29

    30

#include "TCP.hh"

    31

#include "UDP.hh"

    32

#include "Node.hh"

    33

    34

/**

    35

 * A NetworkSession provides TCP/UDP Server and Client functionality, representing remote NetworkSessions with

    36

 * NetworkNodes. A NetworkSession can then communicate with its NetworkNodes using TCP or UDP NetworkPackets.

    37

 */

    38

class NetworkSession {

    39

    friend class NetworkNode;

    40

    41

    private:

    42

        /**

    43

         * The application's magic ID

    44

         */

    45

        uint64_t magic;

    46

    47

        /**

    48

         * Our TCP server, if we're in listen() mode

    49

         */

    50

        NetworkTCPServer *tcp_srv;

    51

    52

        /**

    53

         * Our UDP server, if we're in listen() mode

    54

         */

    55

        NetworkUDP *udp_srv;

    56

    57

        /**

    58

         * Our UDP client, if we're in connect() mode

    59

         */

    60

        NetworkUDP *udp_client;

    61

    62

        CL_SlotContainer slots;

    63

    64

        /**

    65

         * A map of NetworkAddress -> NetworkNode, manipulated when TCP connections are established/broken down,

    66

         * and used to map UDP packets to their NetworkNode

    67

         */

    68

        std::map<NetworkAddress, NetworkNode*> nodes;

    69

    70

        /**

    71

         * A map of NetworkChannelID -> signal, used to signal our users when we receieve packets

    72

         */

    73

        std::map<NetworkChannelID, CL_Signal_v2<NetworkPacketInput&, NetworkNode *> > _map_sig_chan_message;

    74

    75

    public:

    76

        /**

    77

         * Construct an idle NetworkSession using the given application magic, which should be unique to tell different

    78

         * applications apart from each other.

    79

         *

    80

         * @param magic unique application magic

    81

         */

    82

        NetworkSession (uint64_t magic);

    83

    84

        /**

    85

         * Have the NetworkSession enter server mode, listening on the given address using both TCP and UDP

    86

         *

    87

         * @param addr local address to listen on

    88

         */

    89

        void listen (const NetworkEndpoint &addr);

    90

    91

        /**

    92

         * Have the NetworkSession enter client mode, establishing a TCP connection to the server, and then allocating

    93

         * an UDP socket on the same local address as the TCP connection.

    94

         *

    95

         * @param addr remote address to connect to

    96

         */

    97

        NetworkNode* connect (const NetworkEndpoint &addr);

    98

    99

    protected:

   100

        /**

   101

         * Used to build a new NetworkNode by connect/on_tcp_client. Can be used to override what kind of NetworkNodes

   102

         * get created. Type tells what kind of node this is.

   103

         *

   104

         * @param tcp the TCP transport for this node

   105

         * @param udp the UDP socket to use for this node

   106

         * @param addr the remote address

   107

         * @param type the type of node

   108

         * @see NetworkNodeType

   109

         */

   110

        virtual NetworkNode *build_node (NetworkTCPTransport *tcp, NetworkUDP *udp, const NetworkAddress &addr, enum NetworkNodeType type);

   111

   112

        /**

   113

         * A NetworkNode's TCP connection has failed. Removes the node from our nodes-map (using node->getRemoteAddress)

   114

         *

   115

         * @param node the node that has disconnected

   116

         */

   117

        void handle_disconnect (NetworkNode *node);

   118

   119

        /**

   120

         * We have received a NetworkPacket from the given node (either TCP or UDP, we don't know)

   121

         *

   122

         * @param pkt the NetworkPacket that we received

   123

         * @param node the node that sent it

   124

         */

   125

        void handle_message (NetworkPacketInput &pkt, NetworkNode *node);

   126

   127

    private:

   128

        /**

   129

         * Our tcp_srv has accept()'d a new client.

   130

         *

   131

         * Create a NetworkNode using build_node and udp_srv, add it to our node-map, and trigger sig_node_connected

   132

         */

   133

        void on_tcp_client (NetworkTCPTransport *client);

   134

   135

        /**

   136

         * Our udp_srv has recv()'d a NetworkPacket.

   137

         *

   138

         * Map it to a NetworkNode using our node-map and call handle_message

   139

         */

   140

        void on_udp_packet (NetworkPacketInput &pkt, const NetworkAddress &addr);

   141

   142

        /**

   143

         * New-client signal

   144

         */

   145

        CL_Signal_v1<NetworkNode*> _sig_node_connected;

   146

   147

    public:

   148

        /**

   149

         * Send the given NetworkPacket to all our nodes using the given NetworkChannelID, using TCP if reliable, UDP otherwise.

   150

         *

   151

         * @param channel_id the NetworkChannelID to use

   152

         * @param pkt the NetworkPacket to send

   153

         * @param reliable Whether to use TCP or UDP

   154

         */

   155

        void send_all (NetworkChannelID channel_id, const NetworkPacketBuffer &pkt, bool reliable = true);

   156

   157

        /**

   158

         * Like send_all, but do not send the packet to the specified node. If node is NULL, this behaves like

   159

         * send_all.

   160

         *

   161

         * @see send_all

   162

         */

   163

        void send_all_except (NetworkChannelID channel_id, const NetworkPacketBuffer &pkt, const NetworkNode *node, bool reliable = true);

   164

   165

        /**

   166

         * A new node has connected to us

   167

         */

   168

        CL_Signal_v1<NetworkNode*>& sig_node_connected (void) { return _sig_node_connected; }

   169

   170

        /**

   171

         * We have received a NetworkPacket from a NetworkNode on the given NetworkChannelID

   172

         */

   173

        CL_Signal_v2<NetworkPacketInput&, NetworkNode *>& sig_chan_message (NetworkChannelID cid) { return _map_sig_chan_message[cid]; }

   174

};

   175

   176

#endif /* NETWORK_SESSION_HH */