1

     2

#include <cassert>

     3

#include <cstring>

     4

     5

#include "Packet.hh"

     6

     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();

    51

    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

   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

}

   138

   139

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

   140

    // check buffer overflow

   141

    check_write_size(len);

   142

   143

    // set value

   144

    memcpy(buf_ptr + offset, ptr, len);

   145

   146

    // update offset and size

   147

    offset += len;

   148

    data_size += len;

   149

}

   150

   151

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

   152

    // check buffer underflow

   153

    check_read_size(len);

   154

   155

    // set value

   156

    memcpy(ptr, buf_ptr + offset, len);

   157

   158

    // update offset

   159

    offset += len;

   160

}

   161

   162

/*

   163

 * NetworkPacket

   164

 */

   165

NetworkPacket::NetworkPacket (void) : 

   166

    NetworkPacketBuffer(_buf, NETWORK_PACKET_SIZE, 0) 

   167

{ 

   168

   169

}

   170

   171

/*

   172

 * BigNetworkPacket

   173

 */

   174

BigNetworkPacket::BigNetworkPacket (size_t size) :

   175

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

   176

{

   177

   178

}

   179

   180

BigNetworkPacket::~BigNetworkPacket (void) {

   181

    free(buf_ptr);

   182

}

   183