1

     2

#include "TCP.hh"

     3

#include "../Engine.hh"

     4

     5

/*

     6

 * NetworkTCPTransport

     7

 */

     9

    socket(socket), in(socket, NETWORK_TCP_INITIAL_IN_BUF), out(socket, NETWORK_TCP_INITIAL_OUT_BUF) {

    10

    11

    // connect signals

    14

}

    20

    21

void NetworkTCPTransport::on_read (void) {

    22

    uint32_t length;

    23

    char *buf_ptr;

    24

    25

    try { 

    26

        // let the in stream read length-prefixed packets and pass them on to handle_packet

    27

        do {

    28

            // not enough data -> return and wait 

    29

            if (in.peek_data<uint32_t>(length, buf_ptr) == false)

    30

                break;

    31

    32

            // allocate the NetworkPacketBuffer with the given buf_ptr/length

    33

            NetworkPacketBuffer packet(buf_ptr, length, length);

    34

    35

            // pass the packet on

    36

            _sig_packet(packet);

    37

    38

            // flush it

    39

            in.flush_data<uint32_t>();

    40

        } while (true);

    41

    42

    } catch (NetworkSocketError &e) {

    43

        // log and disconnect

    44

        Engine::log(ERROR, "tcp.on_read") << "socket error: " << e.what();

    45

    46

        _sig_disconnect();

    47

    }

    48

}

    49

    50

void NetworkTCPTransport::on_write (void) {

    51

    try {

    52

        // just flush the output buffer

    53

        out.flush_write();

    54

    55

    } catch (NetworkSocketError &e) {

    56

        // log and disconnect

    57

        Engine::log(ERROR, "tcp.on_write") << "socket error: " << e.what();

    58

    59

        _sig_disconnect();

    60

    }

    61

}

    62

    63

void NetworkTCPTransport::write_packet (const NetworkPacketBuffer &packet) {

    64

    uint32_t prefix = packet.get_data_size();

    65

    66

    if (prefix != packet.get_data_size())

    67

        throw CL_Error("send prefix overflow");

    68

    69

    try {

    70

        // just write to the output buffer

    71

        out.write_prefix((char *) packet.get_buf(), prefix);

    72

    73

    } catch (NetworkSocketError &e) {

    74

        const char *err = e.what();

    75

    76

        Engine::log(ERROR, "tcp.write_packet") << err;

    77

    78

        // XXX: these are not handled anywhere :(

    79

        throw;    

    80

    }

    81

}

    82

    86

NetworkTCPServer::NetworkTCPServer (const NetworkAddress &listen_addr) :

    88

    89

    // bind

    90

    socket.bind(listen_addr);

    91

    92

    // assign slots

    94

    95

    // listen

    96

    socket.listen(NETWORK_LISTEN_BACKLOG);

    97

    98

    // use nonblocking sockets

    99

    socket.set_nonblocking(true);

   100

}

   101

   102

   103

void NetworkTCPServer::on_accept (void) {

   104

    // accept a new socket

   106

   107

    // create a new NetworkTCPTransport

   108

    NetworkTCPTransport *client = buildTransport(client_sock);

   109

   110

    // let our user handle it

   111

    _sig_client(client);

   112

}

   113

   115

    return new NetworkTCPTransport(socket);

   116

}

   117

   121

NetworkTCPClient::NetworkTCPClient (const NetworkAddress &connect_addr) :

   123

   124

    // connect

   126

   127

    // use nonblocking sockets

   129

}