1

#ifndef NETWORK_SESSION_HH

     2

#define NETWORK_SESSION_HH

     3

     4

/**

     5

 * @file

     6

 *

     7

 * Support for a groups of clients/servers with associated TCP/UDP sockets

     8

 */

     9

    10

#include <map>

    11

#include <stdint.h>

    13

    14

// forward-declare

    15

class NetworkSession;

    16

    17

/**

    18

 * Size of a NetworkSession's packet header:

    19

 *  uint16      channel_id

    20

 */

    21

const size_t NETWORK_SESSION_HEADER_SIZE = sizeof(uint16_t);

    22

    23

#include "TCP.hh"

    24

#include "UDP.hh"

    25

#include "Node.hh"

    26

#include "Group.hh"

    27

#include "Packet.hh"

    28

#include "Channel.hh"

    29

    30

/**

    31

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

    32

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

    33

 */

    34

class NetworkSession {

    35

    friend class NetworkNode;

    36

    37

    private:

    38

        /**

    39

         * The application's magic ID

    40

         */

    41

        uint64_t magic;

    42

    43

        /**

    44

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

    45

         */

    46

        NetworkTCPServer *tcp_srv;

    47

    48

        /**

    49

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

    50

         */

    51

        NetworkUDP *udp_srv;

    52

    53

        /**

    54

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

    55

         */

    56

        NetworkUDP *udp_client;

    57

    58

        CL_SlotContainer slots;

    59

    60

        /**

    61

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

    62

         * and used to map UDP packets to their NetworkNode

    63

         */

    64

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

    65

    66

        /**

    67

         * A plain list of connected NetworkNode's

    68

         */

    69

        std::list<NetworkNode*> node_list;

    70

    71

        /**

    72

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

    73

         */

    74

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

    75

    76

    public:

    77

        /**

    78

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

    79

         * applications apart from each other.

    80

         *

    81

         * @param magic unique application magic

    82

         */

    83

        NetworkSession (uint64_t magic);

    84

    85

        /**

    86

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

    87

         *

    88

         * @param addr local address to listen on

    89

         */

    90

        void listen (const NetworkEndpoint &addr);

    91

    92

        /**

    93

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

    94

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

    95

         *

    96

         * @param addr remote address to connect to

    97

         */

    98

        NetworkNode* connect (const NetworkEndpoint &addr);

    99

   100

    protected:

   101

        /**

   102

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

   103

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

   104

         *

   105

         * @param tcp the TCP transport for this node

   106

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

   107

         * @param addr the remote address

   108

         * @param type the type of node

   109

         * @see NetworkNodeType

   110

         */

   111

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

   112

   113

        /**

   114

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

   115

         *

   116

         * @param node the node that has disconnected

   117

         */

   118

        void handle_disconnect (NetworkNode *node);

   119

   120

        /**

   121

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

   122

         *

   123

         * @param pkt the NetworkPacket that we received

   124

         * @param node the node that sent it

   125

         */

   126

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

   127

   128

    private:

   129

        /**

   130

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

   131

         *

   132

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

   133

         */

   134

        void on_tcp_client (NetworkTCPTransport *client);

   135

   136

        /**

   137

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

   138

         *

   139

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

   140

         */

   141

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

   142

   143

        /**

   144

         * New-client signal

   145

         */

   146

        CL_Signal_v1<NetworkNode*> _sig_node_connected;

   147

   148

    public:

   149

        /**

   150

         * Get a NetworkGroup containing all connected nodes

   151

         */

   152

        NetworkGroup all_nodes (void) {

   153

            return NetworkGroup(node_list.begin(), node_list.end(), NULL);

   154

        }

   155

   156

        /**

   157

         * Get a NetworkGroup containing all connected nodes, but excluding the given one

   158

         */

   159

        NetworkGroup all_nodes_except (NetworkNode &node) {

   160

            return NetworkGroup(node_list.begin(), node_list.end(), &node);

   161

        }

   162

   163

        /**

   164

         * Write the appropriate NetworkSession header to the given packet. Can be used to prepare packets for use with

   165

         * NetworkTarget::send_raw(). The size of the header is equal to NETWORK_SESSION_HEADER_SIZE

   166

         *

   167

         * XXX: this interface needs fixing to be less procedural

   168

         *

   169

         * @param pkt the packet to write the header to

   170

         * @param channel_id the NetworkChannelID to use

   171

         *

   172

         * @see NetworkTarget::send_raw()

   173

         * @see NETWORK_SESSION_HEADER_SIZE

   174

         */

   175

        void write_packet_header (NetworkPacketOutput &pkt, NetworkChannelID channel_id);

   176

   177

        /**

   178

         * A new node has connected to us

   179

         */

   180

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

   181

   182

        /**

   183

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

   184

         */

   185

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

   186

};

   187

   188

#endif /* NETWORK_SESSION_HH */