1

     2

#include <cassert>

     3

#include <cstring>

     4

     5

#include "Packet.hh"

     6

     9

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

    10

    11

/*

    12

 * NetworkPacketInput

    13

 */

    14

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

    15

    T val;

    16

    17

    // read

    18

    read(&val, sizeof(T));

    19

    20

    // return

    21

    return val;

    22

}

    23

    24

uint32_t NetworkPacketInput::read_uint32 (void) {

    25

    return ntohl(read_val<uint32_t>());

    26

}

    27

    28

uint16_t NetworkPacketInput::read_uint16 (void) {

    29

    return ntohs(read_val<uint16_t>());

    30

}

    31

    32

uint8_t NetworkPacketInput::read_uint8 (void) {

    33

    return read_val<uint8_t>();

    34

}

    35

    36

int32_t NetworkPacketInput::read_int32 (void) {

    37

    return ntohl(read_val<int32_t>());

    38

}

    39

    40

int16_t NetworkPacketInput::read_int16 (void) {

    41

    return ntohs(read_val<int16_t>());

    42

}

    43

    44

int8_t NetworkPacketInput::read_int8 (void) {

    45

    return read_val<int8_t>();

    46

}

    47

    48

float NetworkPacketInput::read_float32 (void) {

    49

    int32_t ival = read_int32();

    50

    float fval;

    51

    52

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

    53

    54

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

    55

    56

    return fval;

    57

}

    58

    59

Vector NetworkPacketInput::read_vector (void) {

    60

    float fx = read_float32();

    61

    float fy = read_float32();

    62

    63

    return Vector(fx, fy);

    64

}

    83

    84

/*

    85

 * NetworkPacketOutput

    86

 */

    87

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

    88

    // write

    89

    write(&val, sizeof(T));

    90

}

    91

    92

    93

void NetworkPacketOutput::write_uint32 (uint32_t val) {

    94

    write_val<uint32_t>(htonl(val));

    95

}

    96

    97

void NetworkPacketOutput::write_uint16 (uint16_t val) {

    98

    write_val<uint16_t>(htons(val));

    99

}

   100

   101

void NetworkPacketOutput::write_uint8 (uint8_t val) {

   102

    write_val<uint8_t>(val);

   103

}

   104

   105

void NetworkPacketOutput::write_int32 (int32_t val) {

   106

    write_val<int32_t>(htonl(val));

   107

}

   108

   109

void NetworkPacketOutput::write_int16 (int16_t val) {

   110

    write_val<int16_t>(htons(val));

   111

}

   112

   113

void NetworkPacketOutput::write_int8 (int8_t val) {

   114

    write_val<int8_t>(val);

   115

}

   116

   117

void NetworkPacketOutput::write_float32 (float fval) {

   118

    int32_t ival;

   119

   120

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

   121

   122

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

   123

   124

    write_int32(ival);

   125

}

   126

   127

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

   128

    write_float32(vec.x);

   129

    write_float32(vec.y);

   130

}

   131

   132

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

   133

    // just write() it

   134

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

   135

}

   161

   162

/*

   163

 * NetworkPacketBuffer

   164

 */

   165

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

   166

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

   167

   168

    // nothing

   169

    if (buf_ptr == NULL)

   170

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

   171

}

   172

   173

void NetworkPacketBuffer::check_write_size (size_t item_size) {

   174

     if (offset + item_size > buf_size)

   175

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

   176

   177

}

   178

   179

void NetworkPacketBuffer::check_read_size (size_t item_size) {

   180

    if (offset + item_size > data_size)

   181

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

   182

}

   183

   184

const void* NetworkPacketBuffer::read_ptr (size_t len) {

   185

    // check buffer overflow

   187

   188

    // pointer value...

   189

    const void *ptr = buf_ptr + offset;

   190

   191

    // update offset

   192

    offset += len;

   193

   194

    // return pointer

   195

    return ptr;

   196

}

   197

   198

void* NetworkPacketBuffer::write_ptr (size_t len) {

   199

    // check buffer overflow

   200

    check_write_size(len);

   201

   202

    // pointer value...

   203

    void *ptr = buf_ptr + offset;

   204

   205

    // update offset and size

   206

    offset += len;

   207

    data_size += len;

   208

   209

    // return pointer

   210

    return ptr;

   211

}

   212

   213

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

   214

    // get input pointer...

   215

    const void *input_ptr = read_ptr(len);

   216

   217

    // copy value out

   218

    memcpy(ptr, input_ptr, len);

   219

}

   220

   221

void NetworkPacketBuffer::write (const void *ptr, size_t len) {

   222

    // get output pointer...

   223

    void *output_ptr = write_ptr(len);

   224

   225

    // copy value in

   226

    memcpy(output_ptr, ptr, len);

   227

}

   228

   237

size_t NetworkPacketBuffer::tell_remaining (void) {

   238

    // number of bytes in total - number of bytes read

   239

    return data_size - offset;

   240

}

   241

   242

/*

   243

 * NetworkPacket

   244

 */

   245

NetworkPacket::NetworkPacket (void) : 

   246

    NetworkPacketBuffer(_buf, NETWORK_PACKET_SIZE, 0) 

   247

{ 

   248

   249

}

   250

   251

/*

   252

 * BigNetworkPacket

   253

 */

   254

BigNetworkPacket::BigNetworkPacket (size_t size) :

   255

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

   256

{

   257

   258

}

   259

   260

BigNetworkPacket::~BigNetworkPacket (void) {

   261

    free(buf_ptr);

   262

}

   263