1

     2

#include <cassert>

     3

#include <cstring>

     4

     5

#include "Packet.hh"

     6

     7

/*

     8

 * NetworkPacketInput

     9

 */

    10

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

    11

    T val;

    12

    13

    // read

    14

    read(&val, sizeof(T));

    15

    16

    // return

    17

    return val;

    18

}

    19

    20

uint32_t NetworkPacketInput::read_uint32 (void) {

    21

    return ntohl(read_val<uint32_t>());

    22

}

    23

    24

uint16_t NetworkPacketInput::read_uint16 (void) {

    25

    return ntohs(read_val<uint16_t>());

    26

}

    27

    28

uint8_t NetworkPacketInput::read_uint8 (void) {

    29

    return read_val<uint8_t>();

    30

}

    31

    32

int32_t NetworkPacketInput::read_int32 (void) {

    33

    return ntohl(read_val<int32_t>());

    34

}

    35

    36

int16_t NetworkPacketInput::read_int16 (void) {

    37

    return ntohs(read_val<int16_t>());

    38

}

    39

    40

int8_t NetworkPacketInput::read_int8 (void) {

    41

    return read_val<int8_t>();

    42

}

    43

    44

float NetworkPacketInput::read_float32 (void) {

    45

    int32_t ival = read_int32();

    46

    47

    return *((float *) &ival);

    48

}

    49

    50

Vector NetworkPacketInput::read_vector (void) {

    51

    float fx = read_float32();

    52

    float fy = read_float32();

    53

    54

    return Vector(fx, fy);

    55

}

    56

    57

/*

    58

 * NetworkPacketOutput

    59

 */

    60

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

    61

    // write

    62

    write(&val, sizeof(T));

    63

}

    64

    65

    66

void NetworkPacketOutput::write_uint32 (uint32_t val) {

    67

    write_val<uint32_t>(htonl(val));

    68

}

    69

    70

void NetworkPacketOutput::write_uint16 (uint16_t val) {

    71

    write_val<uint16_t>(htons(val));

    72

}

    73

    74

void NetworkPacketOutput::write_uint8 (uint8_t val) {

    75

    write_val<uint8_t>(val);

    76

}

    77

    78

void NetworkPacketOutput::write_int32 (int32_t val) {

    79

    write_val<int32_t>(htonl(val));

    80

}

    81

    82

void NetworkPacketOutput::write_int16 (int16_t val) {

    83

    write_val<int16_t>(htons(val));

    84

}

    85

    86

void NetworkPacketOutput::write_int8 (int8_t val) {

    87

    write_val<int8_t>(val);

    88

}

    89

    90

void NetworkPacketOutput::write_float32 (float val) {

    91

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

    92

}

    93

    94

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

    95

    write_float32(vec.x);

    96

    write_float32(vec.y);

    97

}

    98

    99

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

   100

    // just write() it

   101

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

   102

}

   103

   104

/*

   105

 * NetworkPacketBuffer

   106

 */

   107

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

   108

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

   109

   110

    // nothing

   111

    if (buf_ptr == NULL)

   112

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

   113

}

   114

   115

void NetworkPacketBuffer::check_write_size (size_t item_size) {

   116

     if (offset + item_size > buf_size)

   117

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

   118

   119

}

   120

   121

void NetworkPacketBuffer::check_read_size (size_t item_size) {

   122

    if (offset + item_size > data_size)

   123

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

   124

}

   125

   126

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

   127

    // check buffer overflow

   128

    check_write_size(len);

   129

   130

    // set value

   131

    memcpy(buf_ptr + offset, ptr, len);

   132

   133

    // update offset and size

   134

    offset += len;

   135

    data_size += len;

   136

}

   137

   138

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

   139

    // check buffer underflow

   140

    check_read_size(len);

   141

   142

    // set value

   143

    memcpy(ptr, buf_ptr + offset, len);

   144

   145

    // update offset

   146

    offset += len;

   147

}

   148

   149

/*

   150

 * NetworkPacket

   151

 */

   152

NetworkPacket::NetworkPacket (void) : 

   153

    NetworkPacketBuffer(_buf, NETWORK_PACKET_SIZE, 0) 

   154

{ 

   155

   156

}

   157

   158

/*

   159

 * BigNetworkPacket

   160

 */

   161

BigNetworkPacket::BigNetworkPacket (size_t size) :

   162

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

   163

{

   164

   165

}

   166

   167

BigNetworkPacket::~BigNetworkPacket (void) {

   168

    free(buf_ptr);

   169

}

   170