1

     2

#include <cassert>

     3

#include <cstring>

     4

     5

#include "Packet.hh"

     7

     8

#include <zlib.h>

     9

    10

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

    11

    12

/*

    13

 * NetworkPacketInput

    14

 */

    15

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

    16

    T val;

    17

    18

    // read

    19

    read(&val, sizeof(T));

    20

    21

    // return

    22

    return val;

    23

}

    24

    25

uint32_t NetworkPacketInput::read_uint32 (void) {

    26

    return ntohl(read_val<uint32_t>());

    27

}

    28

    29

uint16_t NetworkPacketInput::read_uint16 (void) {

    30

    return ntohs(read_val<uint16_t>());

    31

}

    32

    33

uint8_t NetworkPacketInput::read_uint8 (void) {

    34

    return read_val<uint8_t>();

    35

}

    36

    37

int32_t NetworkPacketInput::read_int32 (void) {

    38

    return ntohl(read_val<int32_t>());

    39

}

    40

    41

int16_t NetworkPacketInput::read_int16 (void) {

    42

    return ntohs(read_val<int16_t>());

    43

}

    44

    45

int8_t NetworkPacketInput::read_int8 (void) {

    46

    return read_val<int8_t>();

    47

}

    48

    49

float NetworkPacketInput::read_float32 (void) {

    50

    int32_t ival = read_int32();

    51

    float fval;

    52

    53

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

    54

    55

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

    56

    57

    return fval;

    58

}

    59

    60

Vector NetworkPacketInput::read_vector (void) {

    61

    float fx = read_float32();

    62

    float fy = read_float32();

    63

    64

    return Vector(fx, fy);

    65

}

    66

    67

size_t NetworkPacketInput::read_uncompressed (void *buf, size_t len) {

    68

    // given len

    69

    unsigned long inflate_size = len;

    70

    71

    // read deflate size

    72

    unsigned long deflate_size = read_uint32();

    73

    74

    // pointer to packet data

    75

    const void *deflate_ptr = read_ptr(deflate_size);

    76

    77

    // uncompress the rest of the packet data

    78

    if (uncompress((uint8_t *) buf, &inflate_size, (const uint8_t *) deflate_ptr, deflate_size) != Z_OK)

    79

        throw Error("uncompress");

    80

    81

    // return inflated size

    82

    return inflate_size;

    83

}

    84

    85

/*

    86

 * NetworkPacketOutput

    87

 */

    88

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

    89

    // write

    90

    write(&val, sizeof(T));

    91

}

    92

    93

    94

void NetworkPacketOutput::write_uint32 (uint32_t val) {

    95

    write_val<uint32_t>(htonl(val));

    96

}

    97

    98

void NetworkPacketOutput::write_uint16 (uint16_t val) {

    99

    write_val<uint16_t>(htons(val));

   100

}

   101

   102

void NetworkPacketOutput::write_uint8 (uint8_t val) {

   103

    write_val<uint8_t>(val);

   104

}

   105

   106

void NetworkPacketOutput::write_int32 (int32_t val) {

   107

    write_val<int32_t>(htonl(val));

   108

}

   109

   110

void NetworkPacketOutput::write_int16 (int16_t val) {

   111

    write_val<int16_t>(htons(val));

   112

}

   113

   114

void NetworkPacketOutput::write_int8 (int8_t val) {

   115

    write_val<int8_t>(val);

   116

}

   117

   118

void NetworkPacketOutput::write_float32 (float fval) {

   119

    int32_t ival;

   120

   121

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

   122

   123

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

   124

   125

    write_int32(ival);

   126

}

   127

   128

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

   129

    write_float32(vec.x);

   130

    write_float32(vec.y);

   131

}

   132

   133

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

   134

    // just write() it

   135

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

   136

}

   137

   138

void NetworkPacketOutput::write_compressed (const void *ptr, uint32_t len) {

   139

    // full compression buffer size, including header

   140

    unsigned long deflate_buf_size = write_compressed_size(len);

   141

   142

    // size of compressed data area after header

   143

    unsigned long deflate_size = deflate_buf_size - sizeof(uint32_t);

   144

   145

    // packet buffer

   146

    void *deflate_buf = write_ptr(deflate_buf_size);

   147

   148

    // compress

   149

    if (compress((uint8_t *) deflate_buf + sizeof(uint32_t), &deflate_size, (const uint8_t *) ptr, len) != Z_OK)

   150

       throw Error("compress failed"); 

   151

   152

    // write data size

   153

    *((uint32_t *) deflate_buf) = htonl(deflate_size);

   154

   155

    // adjust final area

   156

    write_ptr_adjust(deflate_buf_size, sizeof(uint32_t) + deflate_size);

   157

}

   158

   159

size_t NetworkPacketOutput::write_compressed_size (uint32_t len) {

   160

    return sizeof(uint32_t) + compressBound(len);

   161

}

   162

   163

/*

   164

 * NetworkPacketBuffer

   165

 */

   166

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

   167

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

   168

   169

    // nothing

   170

    if (buf_ptr == NULL)

   171

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

   172

}

   173

   174

void NetworkPacketBuffer::check_write_size (size_t item_size) {

   175

     if (offset + item_size > buf_size)

   176

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

   177

   178

}

   179

   180

void NetworkPacketBuffer::check_read_size (size_t item_size) {

   181

    if (offset + item_size > data_size)

   182

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

   183

}

   184

   185

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

   186

    // check buffer overflow

   187

    check_read_size(len);

   188

   189

    // pointer value...

   190

    const void *ptr = buf_ptr + offset;

   191

   192

    // update offset

   193

    offset += len;

   194

   195

    // return pointer

   196

    return ptr;

   197

}

   198

   199

void* NetworkPacketBuffer::write_ptr (size_t len) {

   200

    // check buffer overflow

   201

    check_write_size(len);

   202

   203

    // pointer value...

   204

    void *ptr = buf_ptr + offset;

   205

   206

    // update offset and size

   207

    offset += len;

   208

    data_size += len;

   209

   210

    // return pointer

   211

    return ptr;

   212

}

   213

   214

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

   215

    // get input pointer...

   216

    const void *input_ptr = read_ptr(len);

   217

   218

    // copy value out

   219

    memcpy(ptr, input_ptr, len);

   220

}

   221

   222

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

   223

    // get output pointer...

   224

    void *output_ptr = write_ptr(len);

   225

   226

    // copy value in

   227

    memcpy(output_ptr, ptr, len);

   228

}

   229

   230

void NetworkPacketBuffer::write_ptr_adjust (size_t buf_len, size_t data_len) {

   231

    assert(data_len <= buf_len);

   232

   233

    // adjust offset backwards

   234

    offset -= (buf_len - data_len);

   235

    data_size -= (buf_len - data_len);

   236

}

   237

   238

size_t NetworkPacketBuffer::tell_remaining (void) {

   239

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

   240

    return data_size - offset;

   241

}

   242

   243

/*

   244

 * NetworkPacket

   245

 */

   246

NetworkPacket::NetworkPacket (void) : 

   247

    NetworkPacketBuffer(_buf, NETWORK_PACKET_SIZE, 0) 

   248

{ 

   249

   250

}

   251

   252

/*

   253

 * BigNetworkPacket

   254

 */

   255

BigNetworkPacket::BigNetworkPacket (size_t size) :

   256

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

   257

{

   258

   259

}

   260

   261

BigNetworkPacket::~BigNetworkPacket (void) {

   262

    free(buf_ptr);

   263

}

   264