1

#ifndef NETWORK_NODE_HH

     2

#define NETWORK_NODE_HH

     3

    10

// forward-declare

    11

class NetworkNode;

    12

    13

/**

    14

 * Used to differentiate between different kinds of nodes in NetworkSession::build_node

    15

 *

    16

 * @see NetworkSession::build_node

    17

 */

    18

enum NetworkNodeType {

    19

    NETWORK_NODE_SERVER_CLIENT,     //<<< A server's client

    20

    NETWORK_NODE_CLIENT_SERVER      //<<< A client's server

    21

};

    22

    23

#include "TCP.hh"

    24

#include "UDP.hh"

    25

#include "Session.hh"

    26

    27

/**

    28

 * A NetworkNode represents a remote NetworkSession connected to our NetworkSession.

    29

 *

    30

 * A NetworkNode has a tcp connection, plus an udp socket to us (either NetworkSession's udp_srv or udp_client)

    31

 */

    32

class NetworkNode {

    33

    private:

    34

        /**

    35

         * Our local NetworkSession

    36

         */

    37

        NetworkSession &session;

    38

    39

        /**

    40

         * The TCP connection

    41

         */

    42

        NetworkTCPTransport *tcp;

    43

    44

        /**

    45

         * Our NetworkSession's UDP socket that we should use to send UDP packets to this node

    46

         */

    47

        NetworkUDP *udp;

    48

    49

        /**

    50

         * This address that the node connected from using TCP, used to associate received UDP packets with this node

    51

         */

    52

        const NetworkAddress address;

    53

    54

        CL_SlotContainer slots;

    55

    56

    public:

    57

        /**

    58

         * Construct a new NetworkNode from the given tcp/udp sockets and address

    59

         *

    60

         * @param session our NetworkSession

    61

         * @param tcp this node's TCP socket

    62

         * @param udp the UDP socket to use for outgoing packets

    63

         * @param address the remote address

    64

         */

    65

        NetworkNode (NetworkSession &session, NetworkTCPTransport *tcp, NetworkUDP *udp, const NetworkAddress &address);

    66

    67

    private:

    68

        /**

    69

         * Node should not be copied

    70

         */

    71

        NetworkNode (const NetworkNode &copy);

    72

        ~NetworkNode (void);

    73

        NetworkNode& operator= (const NetworkNode &copy);

    74

    75

        /**

    76

         * Our TCP socket indicates disconnect, tell NetworkSession and trigger sig_disconnect

    77

         */

    78

        void on_disconnect (void);

    79

    80

        /**

    81

         * Our disconnect signal

    82

         */

    83

        CL_Signal_v0 _sig_disconnected;

    84

    85

    public:

    86

        /**

    87

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

    88

         * send_raw. The size of the header is equal to NETWORK_SESSION_HEADER_SIZE

    89

         *

    90

         * @param pkt the packet to write the header to

    91

         * @param channel_id the NetworkChannelID to use

    92

         *

    93

         * @see send_raw

    94

         * @see NETWORK_SESSION_HEADER_SIZE

    95

         */

    96

        void write_packet_header (NetworkPacketOutput &pkt, NetworkChannelID channel_id);

    97

    98

        /**

    99

         * Send a raw packet prepared using write_packet_header. This does not need to copy the packet data around.

   100

         *

   101

         * @param pkt the NetworkPacket prepared using write_packet_header

   102

         * @param reliable Whether to use TCP or UDP

   103

         *

   104

         * @see write_packet_header

   105

         */

   106

        void send_raw (const NetworkPacketBuffer &pkt, bool reliable = true);

   107

   108

        /**

   109

         * Send the given packet to this node on the given channel.

   110

         *

   111

         * Note that this constructs a new *NetworkPacket* containing our header and the given packet, so there

   112

         * given packet must be small enough to fit.

   113

         *

   114

         * @param channel_id the NetworkChannelID to use

   115

         * @param pkt the NetworkPacket to send on the given channel

   116

         * @param reliable Whether to use TCP or UDP

   117

         */

   118

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

   119

   120

        /**

   121

         * Get this node's remote address (both TCP and UDP).

   122

         *

   123

         * @return NetworkAddress the remote address

   124

         */

   125

        const NetworkAddress& getRemoteAddress (void);

   126

   127

        /**

   128

         * This node's TCP connection was lost, and the node has been removed from the NetworkSession's nodes list.

   129

         *

   130

         * Once this completes, the node will be destructed

   131

         */

   132

        CL_Signal_v0& sig_disconnected (void) { return _sig_disconnected; }

   133

};

   134

   135

#endif /* NETWORK_NODE_HH */