1 |
1 |
2 #include "NetworkPacket.hh" |
2 #include "NetworkPacket.hh" |
3 |
3 |
4 |
4 |
5 NetworkPacket::NetworkPacket (void) : |
5 NetworkPacket::NetworkPacket (void) : |
6 size(NETWORK_PACKET_SIZE), offset(0) { |
6 buf_size(NETWORK_PACKET_SIZE), data_size(0), offset(0) { |
7 |
7 |
8 // nothing |
8 // nothing |
|
9 } |
|
10 |
|
11 void NetworkPacket::check_write_size (size_t item_size) { |
|
12 if (offset + item_size > buf_size) |
|
13 throw CL_Error("not enough space to write"); |
|
14 |
|
15 } |
|
16 |
|
17 void NetworkPacket::check_read_size (size_t item_size) { |
|
18 if (offset + item_size > data_size) |
|
19 throw CL_Error("not enough data to read"); |
9 } |
20 } |
10 |
21 |
11 template <typename T> T NetworkPacket::read_val (void) { |
22 template <typename T> T NetworkPacket::read_val (void) { |
12 T val; |
23 T val; |
13 |
24 |
14 // check size |
25 // check size |
15 if (offset + sizeof(T) > size) |
26 check_read_size(sizeof(T)); |
16 throw CL_Error("not enough data to read"); |
|
17 |
27 |
18 // set value |
28 // set value |
19 val = *((T*) (buf + offset)); |
29 val = *((T*) (buf + offset)); |
20 |
30 |
21 // update offset |
31 // update offset |
25 return val; |
35 return val; |
26 } |
36 } |
27 |
37 |
28 template <typename T> void NetworkPacket::write_val (const T &val) { |
38 template <typename T> void NetworkPacket::write_val (const T &val) { |
29 // check max size |
39 // check max size |
30 if (offset + sizeof(T) > NETWORK_PACKET_SIZE) |
40 check_write_size(sizeof(T)); |
31 throw CL_Error("not enough space to write"); |
|
32 |
41 |
33 // set value |
42 // set value |
34 *((T*) (buf + offset)) = val; |
43 *((T*) (buf + offset)) = val; |
35 |
44 |
36 // update offset and size |
45 // update offset and size |
37 offset += sizeof(T); |
46 offset += sizeof(T); |
38 size += sizeof(T); |
47 data_size += sizeof(T); |
39 } |
48 } |
40 |
49 |
41 uint32_t NetworkPacket::read_uint32 (void) { |
50 uint32_t NetworkPacket::read_uint32 (void) const { |
42 return ntohl(read_val<uint32_t>()); |
51 return ntohl(read_val<uint32_t>()); |
43 } |
52 } |
44 |
53 |
45 uint16_t NetworkPacket::read_uint16 (void) { |
54 uint16_t NetworkPacket::read_uint16 (void) const { |
46 return ntohs(read_val<uint16_t>()); |
55 return ntohs(read_val<uint16_t>()); |
47 } |
56 } |
48 |
57 |
49 uint8_t NetworkPacket::read_uint8 (void) { |
58 uint8_t NetworkPacket::read_uint8 (void) const { |
50 return read_val<uint8_t>(); |
59 return read_val<uint8_t>(); |
51 } |
60 } |
52 |
61 |
53 int32_t NetworkPacket::read_int32 (void) { |
62 int32_t NetworkPacket::read_int32 (void) const { |
54 return ntohl(read_val<int32_t>()); |
63 return ntohl(read_val<int32_t>()); |
55 } |
64 } |
56 |
65 |
57 int16_t NetworkPacket::read_int16 (void) { |
66 int16_t NetworkPacket::read_int16 (void) const { |
58 return ntohs(read_val<int16_t>()); |
67 return ntohs(read_val<int16_t>()); |
59 } |
68 } |
60 |
69 |
61 int8_t NetworkPacket::read_int8 (void) { |
70 int8_t NetworkPacket::read_int8 (void) const { |
62 return read_val<int8_t>(); |
71 return read_val<int8_t>(); |
63 } |
72 } |
64 |
73 |
65 void NetworkPacket::write_uint32 (uint32_t val) { |
74 void NetworkPacket::write_uint32 (uint32_t val) { |
66 write_val<uint32_t>(htonl(val)); |
75 write_val<uint32_t>(htonl(val)); |
84 |
93 |
85 void NetworkPacket::write_int8 (int8_t val) { |
94 void NetworkPacket::write_int8 (int8_t val) { |
86 write_val<int8_t>(val); |
95 write_val<int8_t>(val); |
87 } |
96 } |
88 |
97 |
|
98 void write_packet (const NetworkPacket &pkt) { |
|
99 // check buffer size |
|
100 check_write_size(pkt.get_data_size()); |
|
101 |
|
102 // copy |
|
103 memcpy(buf + offset, pkt.get_buf(), pkt.get_data_size()); |
|
104 |
|
105 // update offset/data_size |
|
106 offset += pkt.get_data_size(); |
|
107 data_size += pkt.get_data_size(); |
|
108 } |