1

     2

#include <cassert>

     3

#include <cstring>

     4

     5

#include "NetworkPacket.hh"

     6

     7

     8

NetworkPacket::NetworkPacket (void) :

     9

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

    10

    11

    // nothing

    12

}

    13

    14

void NetworkPacket::check_write_size (size_t item_size) {

    15

     if (offset + item_size > buf_size)

    16

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

    17

    18

}

    19

    20

void NetworkPacket::check_read_size (size_t item_size) {

    21

    if (offset + item_size > data_size)

    22

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

    23

}

    24

    25

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

    26

    // check buffer overflow

    27

    check_write_size(len);

    28

    29

    // set value

    30

    memcpy(buf + offset, ptr, len);

    31

    32

    // update offset and size

    33

    offset += len;

    34

    data_size += len;

    35

}

    36

    37

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

    38

    // check buffer underflow

    39

    check_read_size(len);

    40

    41

    // set value

    42

    memcpy(ptr, buf + offset, len);

    43

    44

    // update offset

    45

    offset += len;

    46

}

    47

    48

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

    49

    T val;

    50

    51

    // read

    52

    read(&val, sizeof(T));

    53

    54

    // return

    55

    return val;

    56

}

    57

    58

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

    59

    // write

    60

    write(&val, sizeof(T));

    61

}

    62

    63

uint32_t NetworkPacket::read_uint32 (void) {

    64

    return ntohl(read_val<uint32_t>());

    65

}

    66

    67

uint16_t NetworkPacket::read_uint16 (void) {

    68

    return ntohs(read_val<uint16_t>());

    69

}

    70

    71

uint8_t NetworkPacket::read_uint8 (void) {

    72

    return read_val<uint8_t>();

    73

}

    74

    75

int32_t NetworkPacket::read_int32 (void) {

    76

    return ntohl(read_val<int32_t>());

    77

}

    78

    79

int16_t NetworkPacket::read_int16 (void) {

    80

    return ntohs(read_val<int16_t>());

    81

}

    82

    83

int8_t NetworkPacket::read_int8 (void) {

    84

    return read_val<int8_t>();

    85

}

    86

    87

float NetworkPacket::read_float32 (void) {

    88

    int32_t ival = read_int32();

    89

    90

    return *((float *) &ival);

    91

}

    92

    93

Vector NetworkPacket::read_vector (void) {

    94

    float fx = read_float32();

    95

    float fy = read_float32();

    96

    97

    return Vector(fx, fy);

    98

}

    99

   100

void NetworkPacket::write_uint32 (uint32_t val) {

   101

    write_val<uint32_t>(htonl(val));

   102

}

   103

   104

void NetworkPacket::write_uint16 (uint16_t val) {

   105

    write_val<uint16_t>(htons(val));

   106

}

   107

   108

void NetworkPacket::write_uint8 (uint8_t val) {

   109

    write_val<uint8_t>(val);

   110

}

   111

   112

void NetworkPacket::write_int32 (int32_t val) {

   113

    write_val<int32_t>(htonl(val));

   114

}

   115

   116

void NetworkPacket::write_int16 (int16_t val) {

   117

    write_val<int16_t>(htons(val));

   118

}

   119

   120

void NetworkPacket::write_int8 (int8_t val) {

   121

    write_val<int8_t>(val);

   122

}

   123

   124

void NetworkPacket::write_float32 (float val) {

   125

    write_int32(*((int32_t *) &val));

   126

}

   127

   128

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

   129

    write_float32(vec.x);

   130

    write_float32(vec.y);

   131

}

   132

   133

void NetworkPacket::write_packet (const NetworkPacket &pkt) {

   134

    // check buffer size

   135

    check_write_size(pkt.get_data_size());

   136

   137

    // copy

   138

    memcpy(buf + offset, pkt.get_buf(), pkt.get_data_size());

   139

   140

    // update offset/data_size

   141

    offset += pkt.get_data_size();

   142

    data_size += pkt.get_data_size();

   143

}

   144