1

     2

#include <cassert>

     3

#include <cstring>

     4

     5

#include "Packet.hh"

     6

     7

// XXX: assumes that sizeof(float32) == sizeof(int32);

     8

     9

/*

    10

 * NetworkPacketInput

    11

 */

    12

template <typename T> T NetworkPacketInput::read_val (void) {

    13

    T val;

    14

    15

    // read

    16

    read(&val, sizeof(T));

    17

    18

    // return

    19

    return val;

    20

}

    21

    22

uint32_t NetworkPacketInput::read_uint32 (void) {

    23

    return ntohl(read_val<uint32_t>());

    24

}

    25

    26

uint16_t NetworkPacketInput::read_uint16 (void) {

    27

    return ntohs(read_val<uint16_t>());

    28

}

    29

    30

uint8_t NetworkPacketInput::read_uint8 (void) {

    31

    return read_val<uint8_t>();

    32

}

    33

    34

int32_t NetworkPacketInput::read_int32 (void) {

    35

    return ntohl(read_val<int32_t>());

    36

}

    37

    38

int16_t NetworkPacketInput::read_int16 (void) {

    39

    return ntohs(read_val<int16_t>());

    40

}

    41

    42

int8_t NetworkPacketInput::read_int8 (void) {

    43

    return read_val<int8_t>();

    44

}

    45

    46

float NetworkPacketInput::read_float32 (void) {

    47

    int32_t ival = read_int32();

    48

    float fval;

    49

    50

    assert(sizeof(ival) == sizeof(fval));

    51

    52

    memcpy(&fval, &ival, sizeof(float));

    53

    54

    return fval;

    55

}

    56

    57

Vector NetworkPacketInput::read_vector (void) {

    58

    float fx = read_float32();

    59

    float fy = read_float32();

    60

    61

    return Vector(fx, fy);

    62

}

    63

    64

/*

    65

 * NetworkPacketOutput

    66

 */

    67

template <typename T> void NetworkPacketOutput::write_val (const T &val) {

    68

    // write

    69

    write(&val, sizeof(T));

    70

}

    71

    72

    73

void NetworkPacketOutput::write_uint32 (uint32_t val) {

    74

    write_val<uint32_t>(htonl(val));

    75

}

    76

    77

void NetworkPacketOutput::write_uint16 (uint16_t val) {

    78

    write_val<uint16_t>(htons(val));

    79

}

    80

    81

void NetworkPacketOutput::write_uint8 (uint8_t val) {

    82

    write_val<uint8_t>(val);

    83

}

    84

    85

void NetworkPacketOutput::write_int32 (int32_t val) {

    86

    write_val<int32_t>(htonl(val));

    87

}

    88

    89

void NetworkPacketOutput::write_int16 (int16_t val) {

    90

    write_val<int16_t>(htons(val));

    91

}

    92

    93

void NetworkPacketOutput::write_int8 (int8_t val) {

    94

    write_val<int8_t>(val);

    95

}

    96

    97

void NetworkPacketOutput::write_float32 (float fval) {

    98

    int32_t ival;

    99

   100

    assert(sizeof(ival) == sizeof(fval));

   101

   102

    memcpy(&ival, &fval, sizeof(int32_t));

   103

   104

    write_int32(ival);

   105

}

   106

   107

void NetworkPacketOutput::write_vector (const Vector &vec) {

   108

    write_float32(vec.x);

   109

    write_float32(vec.y);

   110

}

   111

   112

void NetworkPacketOutput::write_packet (const NetworkPacketBuffer &pkt) {

   113

    // just write() it

   114

    write(pkt.get_buf(), pkt.get_data_size());

   115

}

   116

   117

/*

   118

 * NetworkPacketBuffer

   119

 */

   120

NetworkPacketBuffer::NetworkPacketBuffer (char *buf_ptr, size_t buf_size, size_t data_size) :

   121

    buf_ptr(buf_ptr), buf_size(buf_size), data_size(data_size), offset(0) {

   122

   123

    // nothing

   124

    if (buf_ptr == NULL)

   125

        throw NetworkPacketError("buf_ptr may not be NULL");

   126

}

   127

   128

void NetworkPacketBuffer::check_write_size (size_t item_size) {

   129

     if (offset + item_size > buf_size)

   130

        throw NetworkPacketError("not enough space to write");

   131

   132

}

   133

   134

void NetworkPacketBuffer::check_read_size (size_t item_size) {

   135

    if (offset + item_size > data_size)

   136

        throw NetworkPacketError("not enough data to read");

   137

}

   140

    // check buffer overflow

   141

    check_write_size(len);

   142

   159

   160

    // update offset and size

   161

    offset += len;

   162

    data_size += len;

   166

}

   167

   168

void NetworkPacketBuffer::read (void *ptr, size_t len) {

   171

   179

   187

}

   188

   189

/*

   190

 * NetworkPacket

   191

 */

   192

NetworkPacket::NetworkPacket (void) : 

   193

    NetworkPacketBuffer(_buf, NETWORK_PACKET_SIZE, 0) 

   194

{ 

   195

   196

}

   197

   198

/*

   199

 * BigNetworkPacket

   200

 */

   201

BigNetworkPacket::BigNetworkPacket (size_t size) :

   202

    NetworkPacketBuffer((char *) malloc(size), size, 0)

   203

{

   204

   205

}

   206

   207

BigNetworkPacket::~BigNetworkPacket (void) {

   208

    free(buf_ptr);

   209

}

   210