1 files changed, 68 insertions, 35 deletions

diff --git a/src/ByteBuffer.cpp b/src/ByteBuffer.cpp
index e06f63a0e..1893d89a8 100644
--- a/src/ByteBuffer.cpp
+++ b/src/ByteBuffer.cpp
@@ -44,16 +44,17 @@
 
 
 
-#if 0
+#ifdef SELF_TEST
 
 /// Self-test of the VarInt-reading and writing code
-class cByteBufferSelfTest
+static class cByteBufferSelfTest
 {
 public:
 	cByteBufferSelfTest(void)
 	{
 		TestRead();
 		TestWrite();
+		TestWrap();
 	}
 	
 	void TestRead(void)
@@ -61,11 +62,11 @@ public:
 		cByteBuffer buf(50);
 		buf.Write("\x05\xac\x02\x00", 4);
 		UInt32 v1;
-		ASSERT(buf.ReadVarInt(v1) && (v1 == 5));
+		assert_test(buf.ReadVarInt(v1) && (v1 == 5));
 		UInt32 v2;
-		ASSERT(buf.ReadVarInt(v2) && (v2 == 300));
+		assert_test(buf.ReadVarInt(v2) && (v2 == 300));
 		UInt32 v3;
-		ASSERT(buf.ReadVarInt(v3) && (v3 == 0));
+		assert_test(buf.ReadVarInt(v3) && (v3 == 0));
 	}
 	
 	void TestWrite(void)
@@ -76,9 +77,30 @@ public:
 		buf.WriteVarInt(0);
 		AString All;
 		buf.ReadAll(All);
-		ASSERT(All.size() == 4);
-		ASSERT(memcmp(All.data(), "\x05\xac\x02\x00", All.size()) == 0);
+		assert_test(All.size() == 4);
+		assert_test(memcmp(All.data(), "\x05\xac\x02\x00", All.size()) == 0);
 	}
+	
+	void TestWrap(void)
+	{
+		cByteBuffer buf(3);
+		for (int i = 0; i < 1000; i++)
+		{
+			size_t FreeSpace = buf.GetFreeSpace();
+			assert_test(buf.GetReadableSpace() == 0);
+			assert_test(FreeSpace > 0);
+			assert_test(buf.Write("a", 1));
+			assert_test(buf.CanReadBytes(1));
+			assert_test(buf.GetReadableSpace() == 1);
+			unsigned char v = 0;
+			assert_test(buf.ReadByte(v));
+			assert_test(v == 'a');
+			assert_test(buf.GetReadableSpace() == 0);
+			buf.CommitRead();
+			assert_test(buf.GetFreeSpace() == FreeSpace);  // We're back to normal
+		}
+	}
+	
 } g_ByteBufferTest;
 
 #endif
@@ -149,21 +171,22 @@ cByteBuffer::~cByteBuffer()
 
 
 
-bool cByteBuffer::Write(const char * a_Bytes, int a_Count)
+bool cByteBuffer::Write(const char * a_Bytes, size_t a_Count)
 {
 	CHECK_THREAD;
 	CheckValid();
 
 	// Store the current free space for a check after writing:
-	int CurFreeSpace = GetFreeSpace();
-	int CurReadableSpace = GetReadableSpace();
-	int WrittenBytes = 0;
+	size_t CurFreeSpace = GetFreeSpace();
+	size_t CurReadableSpace = GetReadableSpace();
+	size_t WrittenBytes = 0;
 	
-	if (GetFreeSpace() < a_Count)
+	if (CurFreeSpace < a_Count)
 	{
 		return false;
 	}
-	int TillEnd = m_BufferSize - m_WritePos;
+	ASSERT(m_BufferSize >= m_WritePos);
+	size_t TillEnd = m_BufferSize - m_WritePos;
 	if (TillEnd <= a_Count)
 	{
 		// Need to wrap around the ringbuffer end
@@ -194,16 +217,20 @@ bool cByteBuffer::Write(const char * a_Bytes, int a_Count)
 
 
 
-int cByteBuffer::GetFreeSpace(void) const
+size_t cByteBuffer::GetFreeSpace(void) const
 {
 	CHECK_THREAD;
 	CheckValid();
 	if (m_WritePos >= m_DataStart)
 	{
 		// Wrap around the buffer end:
+		ASSERT(m_BufferSize >= m_WritePos);
+		ASSERT((m_BufferSize - m_WritePos + m_DataStart) >= 1);
 		return m_BufferSize - m_WritePos + m_DataStart - 1;
 	}
 	// Single free space partition:
+	ASSERT(m_BufferSize >= m_WritePos);
+	ASSERT(m_BufferSize - m_WritePos >= 1);
 	return m_DataStart - m_WritePos - 1;
 }
 
@@ -212,10 +239,12 @@ int cByteBuffer::GetFreeSpace(void) const
 
 
 /// Returns the number of bytes that are currently in the ringbuffer. Note GetReadableBytes()
-int cByteBuffer::GetUsedSpace(void) const
+size_t cByteBuffer::GetUsedSpace(void) const
 {
 	CHECK_THREAD;
 	CheckValid();
+	ASSERT(m_BufferSize >= GetFreeSpace());
+	ASSERT((m_BufferSize - GetFreeSpace()) >= 1);
 	return m_BufferSize - GetFreeSpace() - 1;
 }
 
@@ -224,16 +253,18 @@ int cByteBuffer::GetUsedSpace(void) const
 
 
 /// Returns the number of bytes that are currently available for reading (may be less than UsedSpace due to some data having been read already)
-int cByteBuffer::GetReadableSpace(void) const
+size_t cByteBuffer::GetReadableSpace(void) const
 {
 	CHECK_THREAD;
 	CheckValid();
 	if (m_ReadPos > m_WritePos)
 	{
 		// Wrap around the buffer end:
+		ASSERT(m_BufferSize >= m_ReadPos);
 		return m_BufferSize - m_ReadPos + m_WritePos;
 	}
 	// Single readable space partition:
+	ASSERT(m_WritePos >= m_ReadPos);
 	return m_WritePos - m_ReadPos ;
 }
 
@@ -241,7 +272,7 @@ int cByteBuffer::GetReadableSpace(void) const
 
 
 
-bool cByteBuffer::CanReadBytes(int a_Count) const
+bool cByteBuffer::CanReadBytes(size_t a_Count) const
 {
 	CHECK_THREAD;
 	CheckValid();
@@ -252,7 +283,7 @@ bool cByteBuffer::CanReadBytes(int a_Count) const
 
 
 
-bool cByteBuffer::CanWriteBytes(int a_Count) const
+bool cByteBuffer::CanWriteBytes(size_t a_Count) const
 {
 	CHECK_THREAD;
 	CheckValid();
@@ -428,7 +459,7 @@ bool cByteBuffer::ReadVarUTF8String(AString & a_Value)
 	}
 	if (Size > MAX_STRING_SIZE)
 	{
-		LOGWARNING("%s: String too large: %llu (%llu KiB)", __FUNCTION__, Size, Size / 1024);
+		LOGWARNING("%s: String too large: %u (%u KiB)", __FUNCTION__, Size, Size / 1024);
 	}
 	return ReadString(a_Value, (int)Size);
 }
@@ -628,15 +659,14 @@ bool cByteBuffer::WriteLEInt(int a_Value)
 
 
 
-bool cByteBuffer::ReadBuf(void * a_Buffer, int a_Count)
+bool cByteBuffer::ReadBuf(void * a_Buffer, size_t a_Count)
 {
 	CHECK_THREAD;
 	CheckValid();
-	ASSERT(a_Count >= 0);
 	NEEDBYTES(a_Count);
 	char * Dst = (char *)a_Buffer;  // So that we can do byte math
-	int BytesToEndOfBuffer = m_BufferSize - m_ReadPos;
-	ASSERT(BytesToEndOfBuffer >= 0);  // Sanity check
+	ASSERT(m_BufferSize >= m_ReadPos);
+	size_t BytesToEndOfBuffer = m_BufferSize - m_ReadPos;
 	if (BytesToEndOfBuffer <= a_Count)
 	{
 		// Reading across the ringbuffer end, read the first part and adjust parameters:
@@ -662,14 +692,14 @@ bool cByteBuffer::ReadBuf(void * a_Buffer, int a_Count)
 
 
 
-bool cByteBuffer::WriteBuf(const void * a_Buffer, int a_Count)
+bool cByteBuffer::WriteBuf(const void * a_Buffer, size_t a_Count)
 {
 	CHECK_THREAD;
 	CheckValid();
-	ASSERT(a_Count >= 0);
 	PUTBYTES(a_Count);
 	char * Src = (char *)a_Buffer;  // So that we can do byte math
-	int BytesToEndOfBuffer = m_BufferSize - m_WritePos;
+	ASSERT(m_BufferSize >= m_ReadPos);
+	size_t BytesToEndOfBuffer = m_BufferSize - m_WritePos;
 	if (BytesToEndOfBuffer <= a_Count)
 	{
 		// Reading across the ringbuffer end, read the first part and adjust parameters:
@@ -692,22 +722,22 @@ bool cByteBuffer::WriteBuf(const void * a_Buffer, int a_Count)
 
 
 
-bool cByteBuffer::ReadString(AString & a_String, int a_Count)
+bool cByteBuffer::ReadString(AString & a_String, size_t a_Count)
 {
 	CHECK_THREAD;
 	CheckValid();
-	ASSERT(a_Count >= 0);
 	NEEDBYTES(a_Count);
 	a_String.clear();
 	a_String.reserve(a_Count);
-	int BytesToEndOfBuffer = m_BufferSize - m_ReadPos;
-	ASSERT(BytesToEndOfBuffer >= 0);  // Sanity check
+	ASSERT(m_BufferSize >= m_ReadPos);
+	size_t BytesToEndOfBuffer = m_BufferSize - m_ReadPos;
 	if (BytesToEndOfBuffer <= a_Count)
 	{
 		// Reading across the ringbuffer end, read the first part and adjust parameters:
 		if (BytesToEndOfBuffer > 0)
 		{
 			a_String.assign(m_Buffer + m_ReadPos, BytesToEndOfBuffer);
+			ASSERT(a_Count >= BytesToEndOfBuffer);
 			a_Count -= BytesToEndOfBuffer;
 		}
 		m_ReadPos = 0;
@@ -737,7 +767,7 @@ bool cByteBuffer::ReadUTF16String(AString & a_String, int a_NumChars)
 	{
 		return false;
 	}
-	RawBEToUTF8((short *)(RawData.data()), a_NumChars, a_String);
+	RawBEToUTF8(RawData.data(), a_NumChars, a_String);
 	return true;
 }
 
@@ -745,11 +775,10 @@ bool cByteBuffer::ReadUTF16String(AString & a_String, int a_NumChars)
 
 
 
-bool cByteBuffer::SkipRead(int a_Count)
+bool cByteBuffer::SkipRead(size_t a_Count)
 {
 	CHECK_THREAD;
 	CheckValid();
-	ASSERT(a_Count >= 0);
 	if (!CanReadBytes(a_Count))
 	{
 		return false;
@@ -787,6 +816,7 @@ bool cByteBuffer::ReadToByteBuffer(cByteBuffer & a_Dst, size_t a_NumBytes)
 		size_t num = (a_NumBytes > sizeof(buf)) ? sizeof(buf) : a_NumBytes;
 		VERIFY(ReadBuf(buf, num));
 		VERIFY(a_Dst.Write(buf, num));
+		ASSERT(a_NumBytes >= num);
 		a_NumBytes -= num;
 	}
 	return true;
@@ -824,13 +854,15 @@ void cByteBuffer::ReadAgain(AString & a_Out)
 	// Used by ProtoProxy to repeat communication twice, once for parsing and the other time for the remote party
 	CHECK_THREAD;
 	CheckValid();
-	int DataStart = m_DataStart;
+	size_t DataStart = m_DataStart;
 	if (m_ReadPos < m_DataStart)
 	{
 		// Across the ringbuffer end, read the first part and adjust next part's start:
+		ASSERT(m_BufferSize >= m_DataStart);
 		a_Out.append(m_Buffer + m_DataStart, m_BufferSize - m_DataStart);
 		DataStart = 0;
 	}
+	ASSERT(m_ReadPos >= DataStart);
 	a_Out.append(m_Buffer + DataStart, m_ReadPos - DataStart);
 }
 
@@ -838,7 +870,7 @@ void cByteBuffer::ReadAgain(AString & a_Out)
 
 
 
-void cByteBuffer::AdvanceReadPos(int a_Count)
+void cByteBuffer::AdvanceReadPos(size_t a_Count)
 {
 	CHECK_THREAD;
 	CheckValid();
@@ -864,3 +896,4 @@ void cByteBuffer::CheckValid(void) const
 
 
 
+