1 

     2 #include "NetworkSession.hh"

     3 #include "Engine.hh"

     4 

     5 #include <cassert>

     6 

     7 NetworkSession::NetworkSession (uint64_t magic) :

     8     magic(magic), tcp_srv(NULL), udp_srv(NULL), udp_client(NULL) {

     9    

    10     // nothing

    11 }

    12         

    13 void NetworkSession::listen (const NetworkAddress &addr) {

    14     assert(tcp_srv == NULL && udp_srv == NULL);

    15     

    16     // create TCP/UDP servers

    17     tcp_srv = new NetworkTCPServer(addr);

    18     udp_srv = new NetworkUDP(addr);

    19     

    20     // connect signals

    21     slots.connect(tcp_srv->sig_client(), this, &NetworkSession::on_tcp_client);

    22     slots.connect(udp_srv->sig_packet(), this, &NetworkSession::on_udp_packet);

    23 }

    24         

    25 NetworkNode *NetworkSession::build_node (NetworkTCPTransport *tcp, NetworkUDP *udp, const NetworkAddress &addr, enum NetworkNodeType type) {

    26     // XXX: unused

    27     (void) type;

    28 

    29     // create node

    30     return new NetworkNode(*this, tcp, udp, addr);

    31 }

    32 

    33 NetworkNode* NetworkSession::connect (const NetworkAddress &addr) {

    34     // XXX: only one connect

    35     assert(!udp_client);

    36 

    37     // connect TCP

    38     NetworkTCPClient *tcp_client = new NetworkTCPClient(addr);

    39         

    40     // create UDP socket on same address

    41     udp_client = new NetworkUDP(tcp_client->getLocalAddress());

    42     

    43     // build client

    44     NetworkNode *client_node = build_node(tcp_client, udp_client, addr, NETWORK_NODE_CLIENT_SERVER);

    45 

    46     // add to nodes

    47     nodes[addr] = client_node;

    48 

    49     // connect signals

    50     slots.connect(udp_client->sig_packet(), this, &NetworkSession::on_udp_packet);

    51         

    52     // return the "server" node

    53     return client_node;

    54 }

    55                 

    56 void NetworkSession::handle_disconnect (NetworkNode *node) {

    57     // remove from nodes

    58     nodes.erase(node->getRemoteAddress());

    59 }

    60         

    61 void NetworkSession::handle_message (NetworkPacket &pkt, NetworkNode *node) {

    62     // read the channel id

    63     NetworkChannelID channel_id = pkt.read_uint16();

    64 

    65     // fire signal

    66     _map_sig_chan_message[channel_id](pkt, node);

    67 }

    68  

    69 void NetworkSession::on_tcp_client (NetworkTCPTransport *tcp_client) {

    70     // get remote address manually, because NetworkTCPServer doesn't pass it in to us

    71     NetworkAddress addr = tcp_client->getRemoteAddress();

    72 

    73     // build client

    74     NetworkNode *client_node = build_node(tcp_client, udp_srv, addr, NETWORK_NODE_SERVER_CLIENT);

    75 

    76     // add to nodes

    77     nodes[addr] = client_node;

    78     

    79     // fire signals

    80     _sig_node_connected(client_node);

    81 }

    82         

    83 void NetworkSession::on_udp_packet (NetworkPacket &pkt, const NetworkAddress &addr) {

    84     NetworkNode *node = nodes[addr];

    85     

    86     // drop from unknown sources

    87     if (!node) {

    88         Engine::log(WARN, "net_session.on_udp_packet") << "dropping unsolicted UDP packet from " << addr;

    89         return;

    90     }

    91 

    92     // handle

    93     handle_message(pkt, node);

    94 }

    95        

    96 void NetworkSession::send_all (NetworkChannelID channel_id, const NetworkPacket &pkt, bool reliable) {

    97     send_all_except(channel_id, pkt, NULL, reliable);

    98 }

    99         

   100 void NetworkSession::send_all_except (NetworkChannelID channel_id, const NetworkPacket &pkt, const NetworkNode *node, bool reliable) {

   101     for (std::map<NetworkAddress, NetworkNode*>::iterator it = nodes.begin(); it != nodes.end(); it++) {

   102         if (it->second == node)

   103             continue;

   104 

   105         it->second->send(channel_id, pkt, reliable);

   106     }

   107 }