X-Git-Url: https://git.dogcows.com/gitweb?p=chaz%2Fyoink;a=blobdiff_plain;f=src%2FMoof%2FPacket.cc;h=437438effd73803b814123f3bfbea4ab32c45be4;hp=62da00b17f98141d307573232c2d23ca07444fa8;hb=c85b710e7ead9bc417805bb893571a7139f1081c;hpb=1a9061caa8fe73b4b34a37fe467e145bba7bd2f5

diff --git a/src/Moof/Packet.cc b/src/Moof/Packet.cc
index 62da00b..437438e 100644
--- a/src/Moof/Packet.cc
+++ b/src/Moof/Packet.cc
@@ -15,6 +15,7 @@
 #if HAVE_BYTESWAP_H
 #include <byteswap.h>
 #endif
+#include <cstdlib>
 
 #if HAVE_ARPA_INET_H
 #include <arpa/inet.h>
@@ -95,28 +96,69 @@ namespace Mf {
 	
 
 Packet::Packet(size_t size) :
+	mBuffer((char*)malloc(size)),
+	mSize(size),
 	mR(0),
 	mW(0),
+	mOriginalW(0),
 	mBoolR(0),
 	mBoolW(0),
 	mBoolNumR(0),
-	mBoolNumW(0)
-{
-	mBuffer = boost::shared_array<char>(new char[size]);
-	mSize = size;
-}
+	mBoolNumW(0) {}
 
 Packet::Packet(const char* data, size_t size) :
+	mBuffer((char*)malloc(size)),
+	mSize(size),
 	mR(0),
+	mW(size),
+	mOriginalW(size),
 	mBoolR(0),
 	mBoolW(0),
 	mBoolNumR(0),
 	mBoolNumW(0)
 {
-	mBuffer = boost::shared_array<char>(new char[size]);
-	mSize = size;
-	mW = size;
-	memcpy(mBuffer.get(), data, mSize);
+	if (mBuffer) memcpy(mBuffer, data, size);
+	else throw std::length_error("out of memory");
+}
+
+
+Packet::Packet(const Packet& copy) :
+	mBuffer((char*)malloc(copy.mSize)),
+	mSize(copy.mSize),
+	mR(copy.mR),
+	mW(copy.mW),
+	mOriginalW(copy.mOriginalW),
+	mBoolR(copy.mBoolR),
+	mBoolW(copy.mBoolW),
+	mBoolNumR(copy.mBoolNumR),
+	mBoolNumW(copy.mBoolNumW)
+{
+	if (mBuffer) memcpy(mBuffer, copy.mBuffer, mSize);
+	else throw std::length_error("out of memory");
+}
+
+Packet& Packet::operator=(const Packet& copy)
+{
+	free(mBuffer);
+
+	mBuffer = (char*)malloc(copy.mSize);
+	mSize = copy.mSize;
+	mR = copy.mR;
+	mW = copy.mW;
+	mOriginalW = copy.mOriginalW;
+	mBoolR = copy.mBoolR;
+	mBoolW = copy.mBoolW;
+	mBoolNumR = copy.mBoolNumR;
+	mBoolNumW = copy.mBoolNumW;
+	if (mBuffer) memcpy(mBuffer, copy.mBuffer, mSize);
+	else throw std::length_error("out of memory");
+	return *this;
+}
+
+
+Packet::~Packet()
+{
+	free(mBuffer);
 }
 
 
@@ -128,7 +170,7 @@ Packet& Packet::operator<<(bool value)
 		mBoolW = mW;
 
 		unsigned char byte = 0;
-		if (write(&byte, 1) == 0) return *this;
+		if (write(&byte, 1) == 0) throw std::length_error("out of memory");
 	}
 
 	if (value) mBuffer[mBoolW] |= (1 << bit);
@@ -140,49 +182,61 @@ Packet& Packet::operator<<(bool value)
 
 Packet& Packet::operator<<(int8_t value)
 {
-	return *this << (uint8_t)value;
+	return *this << reinterpret_cast<uint8_t&>(value);
 }
 
 Packet& Packet::operator<<(int16_t value)
 {
-	return *this << (uint16_t)value;
+	return *this << reinterpret_cast<uint16_t&>(value);
 }
 
 Packet& Packet::operator<<(int32_t value)
 {
-	return *this << (uint32_t)value;
+	return *this << reinterpret_cast<uint32_t&>(value);
 }
 
 Packet& Packet::operator<<(int64_t value)
 {
-	return *this << (uint64_t)value;
+	return *this << reinterpret_cast<uint64_t&>(value);
 }
 
 
 Packet& Packet::operator<<(uint8_t value)
 {
-	write(&value, sizeof(value));
+	if (write(&value, sizeof(value)) != sizeof(value))
+	{
+		throw std::length_error("out of memory");
+	}
 	return *this;
 }
 
 Packet& Packet::operator<<(uint16_t value)
 {
 	value = htons(value);
-	write(&value, sizeof(value));
+	if (write(&value, sizeof(value)) != sizeof(value))
+	{
+		throw std::length_error("out of memory");
+	}
 	return *this;
 }
 
 Packet& Packet::operator<<(uint32_t value)
 {
 	value = htonl(value);
-	write(&value, sizeof(value));
+	if (write(&value, sizeof(value)) != sizeof(value))
+	{
+		throw std::length_error("out of memory");
+	}
 	return *this;
 }
 
 Packet& Packet::operator<<(uint64_t value)
 {
 	value = htonll(value);
-	write(&value, sizeof(value));
+	if (write(&value, sizeof(value)) != sizeof(value))
+	{
+		throw std::length_error("out of memory");
+	}
 	return *this;
 }
 
@@ -191,7 +245,10 @@ Packet& Packet::operator<<(float value)
 	// XXX: assumes the ieee-754
 	uint32_t* integer = reinterpret_cast<uint32_t*>(&value);
 	*integer = htonl(*integer);
-	write(integer, sizeof(value));
+	if (write(integer, sizeof(value)) != sizeof(value))
+	{
+		throw std::length_error("out of memory");
+	}
 	return *this;
 }
 
@@ -200,14 +257,30 @@ Packet& Packet::operator<<(double value)
 	// XXX: assumes the ieee-754
 	uint64_t* integer = reinterpret_cast<uint64_t*>(&value);
 	*integer = htonll(*integer);
-	write(integer, sizeof(value));
+	if (write(integer, sizeof(value)) != sizeof(value))
+	{
+		throw std::length_error("out of memory");
+	}
 	return *this;
 }
 
 size_t Packet::write(const void* bytes, size_t size)
 {
 	size_t nBytes = std::min(size, mSize - mW);
-	memcpy(&mBuffer[mW], bytes, nBytes);
+	if (!mBuffer || nBytes < size)
+	{
+		int nPages = 1 + size / PAGE_SIZE;
+		int newSize = mSize + nPages * PAGE_SIZE;
+		char* newBuffer = (char*)realloc(mBuffer, newSize);
+		if (newBuffer)
+		{
+			mBuffer = newBuffer;
+			mSize = newSize;
+			nBytes = size;
+		}
+		if (!mBuffer) return 0;
+	}
+	memcpy(mBuffer + mW, bytes, nBytes);
 	mW += nBytes;
 	return nBytes;
 }
@@ -221,7 +294,7 @@ Packet& Packet::operator>>(bool& value)
 		mBoolR = mR;
 
 		unsigned char byte = 0;
-		if (read(&byte, 1) == 0) return *this;
+		if (read(&byte, 1) == 0) throw std::out_of_range("end of packet");
 	}
 
 	value = 1 & (mBuffer[mBoolR] >> bit);
@@ -232,47 +305,59 @@ Packet& Packet::operator>>(bool& value)
 
 Packet& Packet::operator>>(int8_t& value)
 {
-	return *this >> (uint8_t&)value;
+	return *this >> reinterpret_cast<uint8_t&>(value);
 }
 
 Packet& Packet::operator>>(int16_t& value)
 {
-	return *this >> (uint16_t&)value;
+	return *this >> reinterpret_cast<uint16_t&>(value);
 }
 
 Packet& Packet::operator>>(int32_t& value)
 {
-	return *this >> (uint32_t&)value;
+	return *this >> reinterpret_cast<uint32_t&>(value);
 }
 
 Packet& Packet::operator>>(int64_t& value)
 {
-	return *this >> (uint64_t&)value;
+	return *this >> reinterpret_cast<uint64_t&>(value);
 }
 
 Packet& Packet::operator>>(uint8_t& value)
 {
-	read(&value, sizeof(value));
+	if (read(&value, sizeof(value)) != sizeof(value))
+	{
+		throw std::out_of_range("end of packet");
+	}
 	return *this;
 }
 
 Packet& Packet::operator>>(uint16_t& value)
 {
-	read(&value, sizeof(value));
+	if (read(&value, sizeof(value)) != sizeof(value))
+	{
+		throw std::out_of_range("end of packet");
+	}
 	value = ntohs(value);
 	return *this;
 }
 
 Packet& Packet::operator>>(uint32_t& value)
 {
-	read(&value, sizeof(value));
+	if (read(&value, sizeof(value)) != sizeof(value))
+	{
+		throw std::out_of_range("end of packet");
+	}
 	value = ntohl(value);
 	return *this;
 }
 
 Packet& Packet::operator>>(uint64_t& value)
 {
-	read(&value, sizeof(value));
+	if (read(&value, sizeof(value)) != sizeof(value))
+	{
+		throw std::out_of_range("end of packet");
+	}
 	value = ntohll(value);
 	return *this;
 }
@@ -281,7 +366,10 @@ Packet& Packet::operator>>(float& value)
 {
 	// XXX: assumes the ieee-754
 	uint32_t* integer = reinterpret_cast<uint32_t*>(&value);
-	read(integer, sizeof(value));
+	if (read(integer, sizeof(value)) != sizeof(value))
+	{
+		throw std::out_of_range("end of packet");
+	}
 	*integer = htonl(*integer);
 	return *this;
 }
@@ -290,7 +378,10 @@ Packet& Packet::operator>>(double& value)
 {
 	// XXX: assumes the ieee-754
 	uint64_t* integer = reinterpret_cast<uint64_t*>(&value);
-	read(integer, sizeof(value));
+	if (read(integer, sizeof(value)) != sizeof(value))
+	{
+		throw std::out_of_range("end of packet");
+	}
 	*integer = htonll(*integer);
 	return *this;
 }
@@ -298,11 +389,33 @@ Packet& Packet::operator>>(double& value)
 size_t Packet::read(void* bytes, size_t size)
 {
 	size_t nBytes = std::min(size, mW - mR);
-	memcpy(bytes, &mBuffer[mR], nBytes);
+	memcpy(bytes, mBuffer + mR, nBytes);
 	mR += nBytes;
 	return nBytes;
 }
 
 
+void Packet::clear()
+{
+	mR = 0;
+	mW = 0;
+	mBoolR = 0;
+	mBoolW = 0;
+	mBoolNumR = 0;
+	mBoolNumW = 0;
+}
+
+
+void Packet::reset()
+{
+	mR = 0;
+	mW = mOriginalW;
+	mBoolR = 0;
+	mBoolW = 0;
+	mBoolNumR = 0;
+	mBoolNumW = 0;
+}
+
+
 } // namespace Mf