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_triggered(), this, &NetworkTCPTransport::on_read);

    13

    slots.connect(socket.sig_write_triggered(), this, &NetworkTCPTransport::on_write);

    14

    slots.connect(socket.sig_disconnected(), this, &NetworkTCPTransport::on_disconnected);

    15

}

    16

    17

    18

void NetworkTCPTransport::on_read (void) {

    19

    uint32_t length;

    20

    char *buf_ptr;

    21

    22

    try { 

    23

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

    24

        do {

    25

            // not enough data -> return and wait 

    26

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

    27

                break;

    28

    29

            // allocate the NetworkPacketBuffer with the given buf_ptr/length

    30

            NetworkPacketBuffer packet(buf_ptr, length, length);

    31

    32

            // pass the packet on

    33

            _sig_packet(packet);

    34

    35

            // flush it

    36

            in.flush_data<uint32_t>();

    37

        } while (true);

    38

    39

    } catch (NetworkSocketError &e) {

    40

        // log and disconnect

    41

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

    42

    43

        _sig_disconnect();

    44

    }

    45

}

    46

    47

void NetworkTCPTransport::on_write (void) {

    48

    try {

    49

        // just flush the output buffer

    50

        out.flush_write();

    51

    52

    } catch (NetworkSocketError &e) {

    53

        // log and disconnect

    54

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

    55

    56

        _sig_disconnect();

    57

    }

    58

}

    59

    60

void NetworkTCPTransport::on_disconnected (void) {

    61

    // pass right through

    62

    _sig_disconnect();

    63

}

    64

    65

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

    66

    uint32_t prefix = packet.get_data_size();

    67

    68

    if (prefix != packet.get_data_size())

    69

        throw CL_Error("send prefix overflow");

    70

    71

    try {

    72

        // just write to the output buffer

    73

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

    74

    75

    } catch (NetworkSocketError &e) {

    76

        const char *err = e.what();

    77

    78

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

    79

    80

        // XXX: these are not handled anywhere :(

    81

        throw;    

    82

    }

    83

}

    84

    85

NetworkTCPServer::NetworkTCPServer (const NetworkAddress &listen_addr) :

    86

    socket(CL_Socket::tcp, CL_Socket::ipv4) {

    87

    88

    // wow... I didn't know ClanLib was *this* crap

    89

    socket.proto = CL_Socket::tcp;

    90

    91

    // bind

    92

    socket.bind(listen_addr);

    93

    94

    // assign slots

    95

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

    96

    97

    // listen

    98

    socket.listen(NETWORK_LISTEN_BACKLOG);

    99

   100

    // use nonblocking sockets

   101

    socket.set_nonblocking(true);

   102

}

   103

   104

   105

void NetworkTCPServer::on_accept (void) {

   106

    // accept a new socket

   107

    NetworkSocket client_sock = socket.accept();

   108

   109

    // create a new NetworkTCPTransport

   110

    NetworkTCPTransport *client = buildTransport(client_sock);

   111

   112

    // let our user handle it

   113

    _sig_client(client);

   114

}

   115

   116

NetworkTCPTransport* NetworkTCPServer::buildTransport (CL_Socket &socket) {

   117

    return new NetworkTCPTransport(socket);

   118

}

   119

   120

NetworkTCPClient::NetworkTCPClient (const NetworkAddress &connect_addr) :

   121

    NetworkTCPTransport(NetworkSocket(CL_Socket::tcp, CL_Socket::ipv4)) {

   122

   123

    // wow... I didn't know ClanLib was *this* crap

   124

    socket.proto = CL_Socket::tcp;

   125

   126

    // connect

   127

    socket.connect(connect_addr);

   128

   129

    // use nonblocking sockets

   130

    socket.set_nonblocking(true);

   131

}