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>

    12

    13

// forward-declare

    14

class NetworkSession;

    15

    16

/**

    17

 * Size of a NetworkSession's packet header:

    18

 *  uint16      channel_id

    19

 */

    20

const size_t NETWORK_SESSION_HEADER_SIZE = sizeof(uint16_t);

    21

    22

#include "TCP.hh"

    23

#include "UDP.hh"

    24

#include "Node.hh"

    25

#include "Group.hh"

    26

#include "Packet.hh"

    27

#include "Channel.hh"

    28

    29

/**

    30

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

    31

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

    32

 */

    33

class NetworkSession {

    34

    friend class NetworkNode;

    35

    36

    private:

    37

        /**

    38

         * The application's magic ID

    39

         */

    40

        uint64_t magic;

    41

    42

        /**

    43

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

    44

         */

    45

        NetworkTCPServer *tcp_srv;

    46

    47

        /**

    48

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

    49

         */

    50

        NetworkUDP *udp_srv;

    51

    52

        /**

    53

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

    54

         */

    55

        NetworkUDP *udp_client;

    56

    57

        CL_SlotContainer slots;

    58

    59

        /**

    60

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

    61

         * and used to map UDP packets to their NetworkNode

    62

         */

    63

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

    64

    65

        /**

    66

         * A plain list of connected NetworkNode's

    67

         */

    68

        std::list<NetworkNode*> node_list;

    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

         * Get a NetworkGroup containing all connected nodes

   150

         */

   151

        NetworkGroup all_nodes (void) {

   152

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

   153

        }

   154

   155

        /**

   156

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

   157

         */

   158

        NetworkGroup all_nodes_except (NetworkNode &node) {

   159

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

   160

        }

   161

   162

        /**

   163

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

   164

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

   165

         *

   166

         * XXX: this interface needs fixing to be less procedural

   167

         *

   168

         * @param pkt the packet to write the header to

   169

         * @param channel_id the NetworkChannelID to use

   170

         *

   171

         * @see NetworkTarget::send_raw()

   172

         * @see NETWORK_SESSION_HEADER_SIZE

   173

         */

   174

        void write_packet_header (NetworkPacketOutput &pkt, NetworkChannelID channel_id);

   175

   176

        /**

   177

         * A new node has connected to us

   178

         */

   179

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

   180

   181

        /**

   182

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

   183

         */

   184

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

   185

};

   186

   187

#endif /* NETWORK_SESSION_HH */