1

     2

#include "TCP.hh"

     3

#include "../Engine.hh"

     4

     5

/*

     6

 * NetworkTCPTransport

     7

 */

     8

NetworkTCPTransport::NetworkTCPTransport (NetworkSocket *socket) :

     9

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

    10

    11

    // connect signals

    12

    slots.connect(socket->sig_read(), this, &NetworkTCPTransport::on_read);

    13

    slots.connect(socket->sig_write(), this, &NetworkTCPTransport::on_write);

    14

    15

    // activate read polling, but leave write polling for later

    16

    socket->set_poll_read(true);

    17

}

    18

    19

NetworkTCPTransport::~NetworkTCPTransport (void) {

    20

    // release socket

    21

    delete socket;

    22

}

    23

    24

void NetworkTCPTransport::on_read (void) {

    25

    uint32_t length;

    26

    char *buf_ptr;

    27

    28

    try { 

    29

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

    30

        do {

    31

            // not enough data -> return and wait 

    32

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

    33

                break;

    34

    35

            // allocate the NetworkPacketBuffer with the given buf_ptr/length

    36

            NetworkPacketBuffer packet(buf_ptr, length, length);

    37

    38

            // pass the packet on

    39

            _sig_packet(packet);

    40

    41

            // flush it

    42

            in.flush_data<uint32_t>();

    43

        } while (true);

    44

    45

    } catch (NetworkSocketError &e) {

    46

        // log and disconnect

    47

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

    48

    49

        handle_disconnect();

    50

    }

    51

}

    52

    53

void NetworkTCPTransport::on_write (void) {

    54

    try {

    55

        // just flush the output buffer, and deactivate output polling if done

    56

        if (!out.flush_write())

    57

            socket->set_poll_write(false);

    58

    59

    } catch (NetworkSocketError &e) {

    60

        // log and disconnect

    61

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

    62

    63

        handle_disconnect();

    64

    }

    65

}

    66

    67

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

    68

    uint32_t prefix = packet.get_data_size();

    69

    70

    if (prefix != packet.get_data_size())

    71

        throw CL_Error("send prefix overflow");

    72

    73

    try {

    74

        // just write to the output buffer, but activate output polling if needed

    75

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

    76

            socket->set_poll_write(true);

    77

    78

    } catch (NetworkSocketError &e) {

    79

        const char *err = e.what();

    80

    81

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

    82

    83

        // XXX: these are not handled anywhere :(

    84

        throw;    

    85

    }

    86

}

    87

    88

void NetworkTCPTransport::handle_disconnect (void) {

    89

    // disable events on our socket

    90

    socket->set_poll_read(false);

    91

    socket->set_poll_write(false);

    92

    93

    // signal

    94

    _sig_disconnect();

    95

}

    96

    97

/*

    98

 * NetworkTCPServer

    99

 */

   101

    socket(AF_UNSPEC, SOCK_STREAM) {

   102

   103

    // bind

   104

    socket.bind(listen_addr);

   105

   106

    // assign slots

   107

    slots.connect(socket.sig_read(), this, &NetworkTCPServer::on_accept);

   108

   109

    // listen

   110

    socket.listen(NETWORK_LISTEN_BACKLOG);

   111

   112

    // use nonblocking sockets

   113

    socket.set_nonblocking(true);

   114

   115

    // activate polling

   116

    socket.set_poll_read(true);

   117

}

   118

   119

void NetworkTCPServer::on_accept (void) {

   120

    // accept a new socket

   121

    NetworkSocket *client_sock = socket.accept(NULL);

   122

   123

    // create a new NetworkTCPTransport

   124

    NetworkTCPTransport *client = buildTransport(client_sock);

   125

   126

    // let our user handle it

   127

    _sig_client(client);

   128

}

   129

   130

NetworkTCPTransport* NetworkTCPServer::buildTransport (NetworkSocket *socket) {

   131

    return new NetworkTCPTransport(socket);

   132

}

   133

   134

/*

   135

 * NetworkTCPClient

   136

 */

   138

    NetworkTCPTransport(new NetworkSocket(AF_UNSPEC, SOCK_STREAM)) {

   139

   140

    // connect

   141

    socket->connect(connect_addr);

   142

   143

    // use nonblocking sockets

   144

    socket->set_nonblocking(true);

   145

}