]>
Dogcows Code - chaz/yoink/blob - src/Moof/old/Packet.cc
2 /*] Copyright (c) 2009-2010, Charles McGarvey [**************************
3 **] All rights reserved.
7 * Distributable under the terms and conditions of the 2-clause BSD license;
8 * see the file COPYING for a complete text of the license.
10 **************************************************************************/
12 #include "../config.h"
21 #include <arpa/inet.h>
30 #define bswap_16(x) ((((x) >> 8) & 0xff) | (((x) & 0xff) << 8))
34 #define bswap_32(x) ((((x) & 0xff000000) >> 24) | \
35 (((x) & 0x00ff0000) >> 8) | \
36 (((x) & 0x0000ff00) << 8) | \
37 (((x) & 0x000000ff) << 24))
41 #define bswap_64(x) (((x) << 56) | \
42 (((x) << 40) & 0xff000000000000ULL) | \
43 (((x) << 24) & 0xff0000000000ULL) | \
44 (((x) << 8) & 0xff00000000ULL) | \
45 (((x) >> 8) & 0xff000000ULL) | \
46 (((x) >> 24) & 0xff0000ULL) | \
47 (((x) >> 40) & 0xff00ULL) | \
53 static uint16_t htons(uint16_t x
)
55 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
61 static uint16_t ntohs(uint16_t x
)
66 static uint32_t htonl(uint32_t x
)
68 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
74 static uint32_t ntohl(uint32_t x
)
81 static uint64_t htonll(uint64_t x
)
83 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
89 static uint64_t ntohll(uint64_t x
)
98 Packet::Packet(size_t capacity
) :
99 mBuffer((char*)malloc(capacity
)),
109 Packet::Packet(const char* data
, size_t size
) :
110 mBuffer((char*)malloc(size
)),
120 if (mBuffer
) memcpy(mBuffer
, data
, size
);
124 Packet::Packet(const Packet
& copy
) :
125 mBuffer((char*)malloc(copy
.mSize
)),
129 mOriginalW(copy
.mOriginalW
),
132 mBoolNumR(copy
.mBoolNumR
),
133 mBoolNumW(copy
.mBoolNumW
)
135 if (mBuffer
) memcpy(mBuffer
, copy
.mBuffer
, mSize
);
138 Packet
& Packet::operator=(const Packet
& copy
)
142 mBuffer
= (char*)malloc(copy
.mSize
);
146 mOriginalW
= copy
.mOriginalW
;
147 mBoolR
= copy
.mBoolR
;
148 mBoolW
= copy
.mBoolW
;
149 mBoolNumR
= copy
.mBoolNumR
;
150 mBoolNumW
= copy
.mBoolNumW
;
151 if (mBuffer
) memcpy(mBuffer
, copy
.mBuffer
, mSize
);
162 bool Packet::put(bool value
)
164 int bit
= mBoolNumW
% 8;
169 unsigned char byte
= 0;
170 if (write(&byte
, 1) == 0) return false;
173 if (value
) mBuffer
[mBoolW
] |= (1 << bit
);
179 bool Packet::put(int8_t value
)
181 return put(uint8_t(value
));
184 bool Packet::put(int16_t value
)
186 return put(uint16_t(value
));
189 bool Packet::put(int32_t value
)
191 return put(uint32_t(value
));
194 bool Packet::put(int64_t value
)
196 return put(uint64_t(value
));
200 bool Packet::put(uint8_t value
)
202 return write(&value
, sizeof(value
)) == sizeof(value
);
205 bool Packet::put(uint16_t value
)
207 value
= htons(value
);
208 return write(&value
, sizeof(value
)) == sizeof(value
);
211 bool Packet::put(uint32_t value
)
213 value
= htonl(value
);
214 return write(&value
, sizeof(value
)) == sizeof(value
);
217 bool Packet::put(uint64_t value
)
219 value
= htonll(value
);
220 return write(&value
, sizeof(value
)) == sizeof(value
);
223 bool Packet::put(float value
)
225 // XXX: assumes the ieee-754
226 uint32_t* integer
= reinterpret_cast<uint32_t*>(&value
);
227 *integer
= htonl(*integer
);
228 return write(integer
, sizeof(value
)) == sizeof(value
);
231 bool Packet::put(double value
)
233 // XXX: assumes the ieee-754
234 uint64_t* integer
= reinterpret_cast<uint64_t*>(&value
);
235 *integer
= htonll(*integer
);
236 return write(integer
, sizeof(value
)) == sizeof(value
);
240 size_t Packet::write(const void* bytes
, size_t size
)
242 size_t nBytes
= std::min(size
, mSize
- mW
);
243 if (!mBuffer
|| nBytes
< size
)
245 int nPages
= 1 + size
/ PAGE_SIZE
;
246 int newSize
= mSize
+ nPages
* PAGE_SIZE
;
247 char* newBuffer
= (char*)realloc(mBuffer
, newSize
);
254 if (!mBuffer
) return 0;
256 memcpy(mBuffer
+ mW
, bytes
, nBytes
);
262 bool Packet::get(bool& value
, int flags
)
264 int bit
= mBoolNumR
% 8;
269 unsigned char byte
= 0;
270 if (read(&byte
, 1, flags
) == 0) return false;
273 value
= 1 & (mBuffer
[mBoolR
] >> bit
);
274 if (!(flags
& PEEK
)) ++mBoolNumR
;
278 bool Packet::get(int8_t& value
, int flags
)
280 return get((uint8_t&)value
, flags
);
283 bool Packet::get(int16_t& value
, int flags
)
285 return get((uint16_t&)value
, flags
);
288 bool Packet::get(int32_t& value
, int flags
)
290 return get((uint32_t&)value
, flags
);
293 bool Packet::get(int64_t& value
, int flags
)
295 return get((uint64_t&)value
, flags
);
298 bool Packet::get(uint8_t& value
, int flags
)
300 size_t numBytes
= read(&value
, sizeof(value
), flags
);
301 return numBytes
== sizeof(value
);
304 bool Packet::get(uint16_t& value
, int flags
)
306 size_t numBytes
= read(&value
, sizeof(value
), flags
);
307 value
= ntohs(value
);
308 return numBytes
== sizeof(value
);
311 bool Packet::get(uint32_t& value
, int flags
)
313 size_t numBytes
= read(&value
, sizeof(value
), flags
);
314 value
= ntohl(value
);
315 return numBytes
== sizeof(value
);
318 bool Packet::get(uint64_t& value
, int flags
)
320 size_t numBytes
= read(&value
, sizeof(value
), flags
);
321 value
= ntohll(value
);
322 return numBytes
== sizeof(value
);
325 bool Packet::get(float& value
, int flags
)
327 // XXX: assumes the ieee-754
328 uint32_t* integer
= reinterpret_cast<uint32_t*>(&value
);
329 size_t numBytes
= read(integer
, sizeof(value
));
330 *integer
= htonl(*integer
);
331 return numBytes
== sizeof(value
);
334 bool Packet::get(double& value
, int flags
)
336 // XXX: assumes the ieee-754
337 uint64_t* integer
= reinterpret_cast<uint64_t*>(&value
);
338 size_t numBytes
= read(integer
, sizeof(value
));
339 *integer
= htonll(*integer
);
340 return numBytes
== sizeof(value
);
344 size_t Packet::read(void* bytes
, size_t size
, int flags
)
346 size_t nBytes
= std::min(size
, mW
- mR
);
347 memcpy(bytes
, mBuffer
+ mR
, nBytes
);
348 if (!(flags
& PEEK
)) mR
+= nBytes
;
This page took 0.049135 seconds and 4 git commands to generate.