From 0943c006c7d900dfc0281639e992791d6c567438 Mon Sep 17 00:00:00 2001

From: Pierre Ossman <ossman@cendio.se>

Date: Mon, 23 Sep 2019 11:00:17 +0200

Subject: [PATCH] Use size_t for lengths in stream objects

Provides safety against them accidentally becoming negative because

of bugs in the calculations.

Also does the same to CharArray and friends as they were strongly

connection to the stream objects.

---

 common/rdr/FdInStream.cxx    | 20 ++++++++++----------

 common/rdr/FdInStream.h      | 17 +++++++++--------

 common/rdr/FdOutStream.cxx   | 20 ++++++++++----------

 common/rdr/FdOutStream.h     | 12 ++++++------

 common/rdr/FileInStream.cxx  |  8 ++++----

 common/rdr/FileInStream.h    |  4 ++--

 common/rdr/HexInStream.cxx   | 20 ++++++++++----------

 common/rdr/HexInStream.h     | 12 ++++++------

 common/rdr/HexOutStream.cxx  | 20 ++++++++++----------

 common/rdr/HexOutStream.h    | 12 ++++++------

 common/rdr/InStream.h        | 16 ++++++++--------

 common/rdr/MemInStream.h     |  8 ++++----

 common/rdr/MemOutStream.h    | 12 ++++++------

 common/rdr/OutStream.h       | 20 ++++++++++----------

 common/rdr/RandomStream.cxx  | 14 +++++++-------

 common/rdr/RandomStream.h    |  6 +++---

 common/rdr/TLSInStream.cxx   | 10 +++++-----

 common/rdr/TLSInStream.h     | 10 +++++-----

 common/rdr/TLSOutStream.cxx  | 10 +++++-----

 common/rdr/TLSOutStream.h    | 10 +++++-----

 common/rdr/ZlibInStream.cxx  | 16 ++++++++--------

 common/rdr/ZlibInStream.h    | 14 +++++++-------

 common/rdr/ZlibOutStream.cxx | 10 +++++-----

 common/rdr/ZlibOutStream.h   | 10 +++++-----

 common/rfb/Configuration.cxx |  6 +++---

 common/rfb/Configuration.h   | 13 +++++++------

 common/rfb/Password.cxx      |  6 +++---

 common/rfb/Password.h        |  6 +++---

 common/rfb/util.h            |  2 +-

 tests/perf/encperf.cxx       | 10 +++++-----

 win/rfb_win32/Registry.cxx   |  6 +++---

 win/rfb_win32/Registry.h     |  6 +++---

 32 files changed, 184 insertions(+), 182 deletions(-)

diff --git a/common/rdr/FdInStream.cxx b/common/rdr/FdInStream.cxx

index a8b3085..e99c108 100644

--- a/common/rdr/FdInStream.cxx

+++ b/common/rdr/FdInStream.cxx

@@ -56,7 +56,7 @@ using namespace rdr;

 enum { DEFAULT_BUF_SIZE = 8192,

        MIN_BULK_SIZE = 1024 };

-FdInStream::FdInStream(int fd_, int timeoutms_, int bufSize_,

+FdInStream::FdInStream(int fd_, int timeoutms_, size_t bufSize_,

                        bool closeWhenDone_)

   : fd(fd_), closeWhenDone(closeWhenDone_),

     timeoutms(timeoutms_), blockCallback(0),

@@ -67,7 +67,7 @@ FdInStream::FdInStream(int fd_, int timeoutms_, int bufSize_,

 }

 FdInStream::FdInStream(int fd_, FdInStreamBlockCallback* blockCallback_,

-                       int bufSize_)

+                       size_t bufSize_)

   : fd(fd_), timeoutms(0), blockCallback(blockCallback_),

     timing(false), timeWaitedIn100us(5), timedKbits(0),

     bufSize(bufSize_ ? bufSize_ : DEFAULT_BUF_SIZE), offset(0)

@@ -92,12 +92,12 @@ void FdInStream::setBlockCallback(FdInStreamBlockCallback* blockCallback_)

   timeoutms = 0;

 }

-int FdInStream::pos()

+size_t FdInStream::pos()

 {

   return offset + ptr - start;

 }

-void FdInStream::readBytes(void* data, int length)

+void FdInStream::readBytes(void* data, size_t length)

 {

   if (length < MIN_BULK_SIZE) {

     InStream::readBytes(data, length);

@@ -106,7 +106,7 @@ void FdInStream::readBytes(void* data, int length)

   U8* dataPtr = (U8*)data;

-  int n = end - ptr;

+  size_t n = end - ptr;

   if (n > length) n = length;

   memcpy(dataPtr, ptr, n);

@@ -123,7 +123,7 @@ void FdInStream::readBytes(void* data, int length)

 }

-int FdInStream::overrun(int itemSize, int nItems, bool wait)

+size_t FdInStream::overrun(size_t itemSize, size_t nItems, bool wait)

 {

   if (itemSize > bufSize)

     throw Exception("FdInStream overrun: max itemSize exceeded");

@@ -135,7 +135,7 @@ int FdInStream::overrun(int itemSize, int nItems, bool wait)

   end -= ptr - start;

   ptr = start;

-  int bytes_to_read;

+  size_t bytes_to_read;

   while (end < start + itemSize) {

     bytes_to_read = start + bufSize - end;

     if (!timing) {

@@ -147,12 +147,12 @@ int FdInStream::overrun(int itemSize, int nItems, bool wait)

       // bytes is ineffecient.

       bytes_to_read = vncmin(bytes_to_read, vncmax(itemSize*nItems, 8));

     }

-    int n = readWithTimeoutOrCallback((U8*)end, bytes_to_read, wait);

+    size_t n = readWithTimeoutOrCallback((U8*)end, bytes_to_read, wait);

     if (n == 0) return 0;

     end += n;

   }

-  if (itemSize * nItems > end - ptr)

+  if (itemSize * nItems > (size_t)(end - ptr))

     nItems = (end - ptr) / itemSize;

   return nItems;

@@ -171,7 +171,7 @@ int FdInStream::overrun(int itemSize, int nItems, bool wait)

 // returning EINTR.

 //

-int FdInStream::readWithTimeoutOrCallback(void* buf, int len, bool wait)

+size_t FdInStream::readWithTimeoutOrCallback(void* buf, size_t len, bool wait)

 {

   struct timeval before, after;

   if (timing)

diff --git a/common/rdr/FdInStream.h b/common/rdr/FdInStream.h

index 5d9598c..b93fd84 100644

--- a/common/rdr/FdInStream.h

+++ b/common/rdr/FdInStream.h

@@ -36,16 +36,17 @@ namespace rdr {

   public:

-    FdInStream(int fd, int timeoutms=-1, int bufSize=0,

+    FdInStream(int fd, int timeoutms=-1, size_t bufSize=0,

                bool closeWhenDone_=false);

-    FdInStream(int fd, FdInStreamBlockCallback* blockCallback, int bufSize=0);

+    FdInStream(int fd, FdInStreamBlockCallback* blockCallback,

+               size_t bufSize=0);

     virtual ~FdInStream();

     void setTimeout(int timeoutms);

     void setBlockCallback(FdInStreamBlockCallback* blockCallback);

     int getFd() { return fd; }

-    int pos();

-    void readBytes(void* data, int length);

+    size_t pos();

+    void readBytes(void* data, size_t length);

     void startTiming();

     void stopTiming();

@@ -53,10 +54,10 @@ namespace rdr {

     unsigned int timeWaited() { return timeWaitedIn100us; }

   protected:

-    int overrun(int itemSize, int nItems, bool wait);

+    size_t overrun(size_t itemSize, size_t nItems, bool wait);

   private:

-    int readWithTimeoutOrCallback(void* buf, int len, bool wait=true);

+    size_t readWithTimeoutOrCallback(void* buf, size_t len, bool wait=true);

     int fd;

     bool closeWhenDone;

@@ -67,8 +68,8 @@ namespace rdr {

     unsigned int timeWaitedIn100us;

     unsigned int timedKbits;

-    int bufSize;

-    int offset;

+    size_t bufSize;

+    size_t offset;

     U8* start;

   };

diff --git a/common/rdr/FdOutStream.cxx b/common/rdr/FdOutStream.cxx

index 29e864f..0900fd1 100644

--- a/common/rdr/FdOutStream.cxx

+++ b/common/rdr/FdOutStream.cxx

@@ -50,7 +50,7 @@ using namespace rdr;

 enum { DEFAULT_BUF_SIZE = 16384 };

-FdOutStream::FdOutStream(int fd_, bool blocking_, int timeoutms_, int bufSize_)

+FdOutStream::FdOutStream(int fd_, bool blocking_, int timeoutms_, size_t bufSize_)

   : fd(fd_), blocking(blocking_), timeoutms(timeoutms_),

     bufSize(bufSize_ ? bufSize_ : DEFAULT_BUF_SIZE), offset(0)

 {

@@ -78,7 +78,7 @@ void FdOutStream::setBlocking(bool blocking_) {

   blocking = blocking_;

 }

-int FdOutStream::length()

+size_t FdOutStream::length()

 {

   return offset + ptr - sentUpTo;

 }

@@ -96,9 +96,9 @@ unsigned FdOutStream::getIdleTime()

 void FdOutStream::flush()

 {

   while (sentUpTo < ptr) {

-    int n = writeWithTimeout((const void*) sentUpTo,

-                             ptr - sentUpTo,

-                             blocking? timeoutms : 0);

+    size_t n = writeWithTimeout((const void*) sentUpTo,

+                                ptr - sentUpTo,

+                                blocking? timeoutms : 0);

     // Timeout?

     if (n == 0) {

@@ -119,7 +119,7 @@ void FdOutStream::flush()

 }

-int FdOutStream::overrun(int itemSize, int nItems)

+size_t FdOutStream::overrun(size_t itemSize, size_t nItems)

 {

   if (itemSize > bufSize)

     throw Exception("FdOutStream overrun: max itemSize exceeded");

@@ -128,10 +128,10 @@ int FdOutStream::overrun(int itemSize, int nItems)

   flush();

   // Still not enough space?

-  if (itemSize > end - ptr) {

+  if (itemSize > (size_t)(end - ptr)) {

     // Can we shuffle things around?

     // (don't do this if it gains us less than 25%)

-    if ((sentUpTo - start > bufSize / 4) &&

+    if (((size_t)(sentUpTo - start) > bufSize / 4) &&

         (itemSize < bufSize - (ptr - sentUpTo))) {

       memmove(start, sentUpTo, ptr - sentUpTo);

       ptr = start + (ptr - sentUpTo);

@@ -149,7 +149,7 @@ int FdOutStream::overrun(int itemSize, int nItems)

   }

   // Can we fit all the items asked for?

-  if (itemSize * nItems > end - ptr)

+  if (itemSize * nItems > (size_t)(end - ptr))

     nItems = (end - ptr) / itemSize;

   return nItems;

@@ -165,7 +165,7 @@ int FdOutStream::overrun(int itemSize, int nItems)

 // select() and write() returning EINTR.

 //

-int FdOutStream::writeWithTimeout(const void* data, int length, int timeoutms)

+size_t FdOutStream::writeWithTimeout(const void* data, size_t length, int timeoutms)

 {

   int n;

diff --git a/common/rdr/FdOutStream.h b/common/rdr/FdOutStream.h

index b7f6cb0..ed84fdb 100644

--- a/common/rdr/FdOutStream.h

+++ b/common/rdr/FdOutStream.h

@@ -34,7 +34,7 @@ namespace rdr {

   public:

-    FdOutStream(int fd, bool blocking=true, int timeoutms=-1, int bufSize=0);

+    FdOutStream(int fd, bool blocking=true, int timeoutms=-1, size_t bufSize=0);

     virtual ~FdOutStream();

     void setTimeout(int timeoutms);

@@ -42,20 +42,20 @@ namespace rdr {

     int getFd() { return fd; }

     void flush();

-    int length();

+    size_t length();

     int bufferUsage();

     unsigned getIdleTime();

   private:

-    int overrun(int itemSize, int nItems);

-    int writeWithTimeout(const void* data, int length, int timeoutms);

+    size_t overrun(size_t itemSize, size_t nItems);

+    size_t writeWithTimeout(const void* data, size_t length, int timeoutms);

     int fd;

     bool blocking;

     int timeoutms;

-    int bufSize;

-    int offset;

+    size_t bufSize;

+    size_t offset;

     U8* start;

     U8* sentUpTo;

     struct timeval lastWrite;

diff --git a/common/rdr/FileInStream.cxx b/common/rdr/FileInStream.cxx

index 8d5c22e..56830a0 100644

--- a/common/rdr/FileInStream.cxx

+++ b/common/rdr/FileInStream.cxx

@@ -48,7 +48,7 @@ void FileInStream::reset(void) {

   ptr = end = b;

 }

-int FileInStream::pos()

+size_t FileInStream::pos()

 {

   if (!file)

     throw Exception("File is not open");

@@ -56,9 +56,9 @@ int FileInStream::pos()

   return ftell(file) + ptr - b;

 }

-int FileInStream::overrun(int itemSize, int nItems, bool wait)

+size_t FileInStream::overrun(size_t itemSize, size_t nItems, bool wait)

 {

-  if (itemSize > (int)sizeof(b))

+  if (itemSize > sizeof(b))

     throw Exception("FileInStream overrun: max itemSize exceeded");

   if (end - ptr != 0)

@@ -80,7 +80,7 @@ int FileInStream::overrun(int itemSize, int nItems, bool wait)

     end += b + sizeof(b) - end;

   }

-  if (itemSize * nItems > end - ptr)

+  if (itemSize * nItems > (size_t)(end - ptr))

     nItems = (end - ptr) / itemSize;

   return nItems;

diff --git a/common/rdr/FileInStream.h b/common/rdr/FileInStream.h

index ace04f3..a33c765 100644

--- a/common/rdr/FileInStream.h

+++ b/common/rdr/FileInStream.h

@@ -35,10 +35,10 @@ namespace rdr {

     void reset(void);

-    int pos();

+    size_t pos();

   protected:

-    int overrun(int itemSize, int nItems, bool wait = true);

+    size_t overrun(size_t itemSize, size_t nItems, bool wait = true);

   private:

     U8 b[131072];

diff --git a/common/rdr/HexInStream.cxx b/common/rdr/HexInStream.cxx

index 80f8a79..8f93988 100644

--- a/common/rdr/HexInStream.cxx

+++ b/common/rdr/HexInStream.cxx

@@ -28,7 +28,7 @@ const int DEFAULT_BUF_LEN = 16384;

 static inline int min(int a, int b) {return a

-HexInStream::HexInStream(InStream& is, int bufSize_)

+HexInStream::HexInStream(InStream& is, size_t bufSize_)

 : bufSize(bufSize_ ? bufSize_ : DEFAULT_BUF_LEN), offset(0), in_stream(is)

 {

   ptr = end = start = new U8[bufSize];

@@ -50,8 +50,8 @@ bool HexInStream::readHexAndShift(char c, int* v) {

   return true;

 }

-bool HexInStream::hexStrToBin(const char* s, char** data, int* length) {

-  int l=strlen(s);

+bool HexInStream::hexStrToBin(const char* s, char** data, size_t* length) {

+  size_t l=strlen(s);

   if ((l % 2) == 0) {

     delete [] *data;

     *data = 0; *length = 0;

@@ -59,7 +59,7 @@ bool HexInStream::hexStrToBin(const char* s, char** data, int* length) {

       return true;

     *data = new char[l/2];

     *length = l/2;

-    for(int i=0;i

+    for(size_t i=0;i

       int byte = 0;

       if (!readHexAndShift(s[i], &byte) ||

         !readHexAndShift(s[i+1], &byte))

@@ -76,11 +76,11 @@ decodeError:

 }

-int HexInStream::pos() {

+size_t HexInStream::pos() {

   return offset + ptr - start;

 }

-int HexInStream::overrun(int itemSize, int nItems, bool wait) {

+size_t HexInStream::overrun(size_t itemSize, size_t nItems, bool wait) {

   if (itemSize > bufSize)

     throw Exception("HexInStream overrun: max itemSize exceeded");

@@ -92,14 +92,14 @@ int HexInStream::overrun(int itemSize, int nItems, bool wait) {

   ptr = start;

   while (end < ptr + itemSize) {

-    int n = in_stream.check(2, 1, wait);

+    size_t n = in_stream.check(2, 1, wait);

     if (n == 0) return 0;

     const U8* iptr = in_stream.getptr();

     const U8* eptr = in_stream.getend();

-    int length = min((eptr - iptr)/2, start + bufSize - end);

+    size_t length = min((eptr - iptr)/2, start + bufSize - end);

     U8* optr = (U8*) end;

-    for (int i=0; i

+    for (size_t i=0; i

       int v = 0;

       readHexAndShift(iptr[i*2], &v);

       readHexAndShift(iptr[i*2+1], &v);

@@ -110,7 +110,7 @@ int HexInStream::overrun(int itemSize, int nItems, bool wait) {

     end += length;

   }

-  if (itemSize * nItems > end - ptr)

+  if (itemSize * nItems > (size_t)(end - ptr))

     nItems = (end - ptr) / itemSize;

   return nItems;

diff --git a/common/rdr/HexInStream.h b/common/rdr/HexInStream.h

index 6bfb843..8e495fb 100644

--- a/common/rdr/HexInStream.h

+++ b/common/rdr/HexInStream.h

@@ -26,21 +26,21 @@ namespace rdr {

   class HexInStream : public InStream {

   public:

-    HexInStream(InStream& is, int bufSize=0);

+    HexInStream(InStream& is, size_t bufSize=0);

     virtual ~HexInStream();

-    int pos();

+    size_t pos();

     static bool readHexAndShift(char c, int* v);

-    static bool hexStrToBin(const char* s, char** data, int* length);

+    static bool hexStrToBin(const char* s, char** data, size_t* length);

   protected:

-    int overrun(int itemSize, int nItems, bool wait);

+    size_t overrun(size_t itemSize, size_t nItems, bool wait);

   private:

-    int bufSize;

+    size_t bufSize;

     U8* start;

-    int offset;

+    size_t offset;

     InStream& in_stream;

   };

diff --git a/common/rdr/HexOutStream.cxx b/common/rdr/HexOutStream.cxx

index 9b0b6c4..7232514 100644

--- a/common/rdr/HexOutStream.cxx

+++ b/common/rdr/HexOutStream.cxx

@@ -23,9 +23,9 @@ using namespace rdr;

 const int DEFAULT_BUF_LEN = 16384;

-static inline int min(int a, int b) {return a

+static inline size_t min(size_t a, size_t b) {return a

-HexOutStream::HexOutStream(OutStream& os, int buflen)

+HexOutStream::HexOutStream(OutStream& os, size_t buflen)

 : out_stream(os), offset(0), bufSize(buflen ? buflen : DEFAULT_BUF_LEN)

 {

   if (bufSize % 2)

@@ -48,9 +48,9 @@ char HexOutStream::intToHex(int i) {

     throw rdr::Exception("intToHex failed");

 }

-char* HexOutStream::binToHexStr(const char* data, int length) {

+char* HexOutStream::binToHexStr(const char* data, size_t length) {

   char* buffer = new char[length*2+1];

-  for (int i=0; i

+  for (size_t i=0; i

     buffer[i*2] = intToHex((data[i] >> 4) & 15);

     buffer[i*2+1] = intToHex((data[i] & 15));

     if (!buffer[i*2] || !buffer[i*2+1]) {

@@ -70,9 +70,9 @@ HexOutStream::writeBuffer() {

     out_stream.check(2);

     U8* optr = out_stream.getptr();

     U8* oend = out_stream.getend();

-    int length = min(ptr-pos, (oend-optr)/2);

+    size_t length = min(ptr-pos, (oend-optr)/2);

-    for (int i=0; i

+    for (size_t i=0; i

       optr[i*2] = intToHex((pos[i] >> 4) & 0xf);

       optr[i*2+1] = intToHex(pos[i] & 0xf);

     }

@@ -84,7 +84,7 @@ HexOutStream::writeBuffer() {

   ptr = start;

 }

-int HexOutStream::length()

+size_t HexOutStream::length()

 {

   return offset + ptr - start;

 }

@@ -95,14 +95,14 @@ HexOutStream::flush() {

   out_stream.flush();

 }

-int

-HexOutStream::overrun(int itemSize, int nItems) {

+size_t

+HexOutStream::overrun(size_t itemSize, size_t nItems) {

   if (itemSize > bufSize)

     throw Exception("HexOutStream overrun: max itemSize exceeded");

   writeBuffer();

-  if (itemSize * nItems > end - ptr)

+  if (itemSize * nItems > (size_t)(end - ptr))

     nItems = (end - ptr) / itemSize;

   return nItems;

diff --git a/common/rdr/HexOutStream.h b/common/rdr/HexOutStream.h

index 10247e6..92442a7 100644

--- a/common/rdr/HexOutStream.h

+++ b/common/rdr/HexOutStream.h

@@ -26,24 +26,24 @@ namespace rdr {

   class HexOutStream : public OutStream {

   public:

-    HexOutStream(OutStream& os, int buflen=0);

+    HexOutStream(OutStream& os, size_t buflen=0);

     virtual ~HexOutStream();

     void flush();

-    int length();

+    size_t length();

     static char intToHex(int i);

-    static char* binToHexStr(const char* data, int length);

+    static char* binToHexStr(const char* data, size_t length);

   private:

     void writeBuffer();

-    int overrun(int itemSize, int nItems);

+    size_t overrun(size_t itemSize, size_t nItems);

     OutStream& out_stream;

     U8* start;

-    int offset;

-    int bufSize;

+    size_t offset;

+    size_t bufSize;

   };

 }

diff --git a/common/rdr/InStream.h b/common/rdr/InStream.h

index 212a2ec..14ecf09 100644

--- a/common/rdr/InStream.h

+++ b/common/rdr/InStream.h

@@ -41,7 +41,7 @@ namespace rdr {

     // for the bytes, zero is returned if the bytes are not immediately

     // available.

-    inline int check(int itemSize, int nItems=1, bool wait=true)

+    inline size_t check(size_t itemSize, size_t nItems=1, bool wait=true)

     {

       if (ptr + itemSize * nItems > end) {

         if (ptr + itemSize > end)

@@ -56,7 +56,7 @@ namespace rdr {

     // be read without blocking.  It returns true if this is the case, false

     // otherwise.  The length must be "small" (less than the buffer size).

-    inline bool checkNoWait(int length) { return check(length, 1, false)!=0; }

+    inline bool checkNoWait(size_t length) { return check(length, 1, false)!=0; }

     // readU/SN() methods read unsigned and signed N-bit integers.

@@ -82,9 +82,9 @@ namespace rdr {

     static U32 maxStringLength;

-    inline void skip(int bytes) {

+    inline void skip(size_t bytes) {

       while (bytes > 0) {

-        int n = check(1, bytes);

+        size_t n = check(1, bytes);

         ptr += n;

         bytes -= n;

       }

@@ -92,11 +92,11 @@ namespace rdr {

     // readBytes() reads an exact number of bytes.

-    void readBytes(void* data, int length) {

+    void readBytes(void* data, size_t length) {

       U8* dataPtr = (U8*)data;

       U8* dataEnd = dataPtr + length;

       while (dataPtr < dataEnd) {

-        int n = check(1, dataEnd - dataPtr);

+        size_t n = check(1, dataEnd - dataPtr);

         memcpy(dataPtr, ptr, n);

         ptr += n;

         dataPtr += n;

@@ -114,7 +114,7 @@ namespace rdr {

     // pos() returns the position in the stream.

-    virtual int pos() = 0;

+    virtual size_t pos() = 0;

     // getptr(), getend() and setptr() are "dirty" methods which allow you to

     // manipulate the buffer directly.  This is useful for a stream which is a

@@ -133,7 +133,7 @@ namespace rdr {

     // instead of blocking to wait for the bytes, zero is returned if the bytes

     // are not immediately available.

-    virtual int overrun(int itemSize, int nItems, bool wait=true) = 0;

+    virtual size_t overrun(size_t itemSize, size_t nItems, bool wait=true) = 0;

   protected:

diff --git a/common/rdr/MemInStream.h b/common/rdr/MemInStream.h

index 1a6a798..3e9e77b 100644

--- a/common/rdr/MemInStream.h

+++ b/common/rdr/MemInStream.h

@@ -36,7 +36,7 @@ namespace rdr {

   public:

-    MemInStream(const void* data, int len, bool deleteWhenDone_=false)

+    MemInStream(const void* data, size_t len, bool deleteWhenDone_=false)

       : start((const U8*)data), deleteWhenDone(deleteWhenDone_)

     {

       ptr = start;

@@ -48,12 +48,12 @@ namespace rdr {

         delete [] start;

     }

-    int pos() { return ptr - start; }

-    void reposition(int pos) { ptr = start + pos; }

+    size_t pos() { return ptr - start; }

+    void reposition(size_t pos) { ptr = start + pos; }

   private:

-    int overrun(int itemSize, int nItems, bool wait) { throw EndOfStream(); }

+    size_t overrun(size_t itemSize, size_t nItems, bool wait) { throw EndOfStream(); }

     const U8* start;

     bool deleteWhenDone;

   };

diff --git a/common/rdr/MemOutStream.h b/common/rdr/MemOutStream.h

index 3b17e55..4a815b3 100644

--- a/common/rdr/MemOutStream.h

+++ b/common/rdr/MemOutStream.h

@@ -40,16 +40,16 @@ namespace rdr {

       delete [] start;

     }

-    void writeBytes(const void* data, int length) {

+    void writeBytes(const void* data, size_t length) {

       check(length);

       memcpy(ptr, data, length);

       ptr += length;

     }

-    int length() { return ptr - start; }

+    size_t length() { return ptr - start; }

     void clear() { ptr = start; };

     void clearAndZero() { memset(start, 0, ptr-start); clear(); }

-    void reposition(int pos) { ptr = start + pos; }

+    void reposition(size_t pos) { ptr = start + pos; }

     // data() returns a pointer to the buffer.

@@ -60,9 +60,9 @@ namespace rdr {

     // overrun() either doubles the buffer or adds enough space for nItems of

     // size itemSize bytes.

-    int overrun(int itemSize, int nItems) {

-      int len = ptr - start + itemSize * nItems;

-      if (len < (end - start) * 2)

+    size_t overrun(size_t itemSize, size_t nItems) {

+      size_t len = ptr - start + itemSize * nItems;

+      if (len < (size_t)(end - start) * 2)

         len = (end - start) * 2;

       U8* newStart = new U8[len];

diff --git a/common/rdr/OutStream.h b/common/rdr/OutStream.h

index a749a20..11aafd2 100644

--- a/common/rdr/OutStream.h

+++ b/common/rdr/OutStream.h

@@ -44,7 +44,7 @@ namespace rdr {

     // itemSize bytes.  Returns the number of items which fit (up to a maximum

     // of nItems).

-    inline int check(int itemSize, int nItems=1)

+    inline size_t check(size_t itemSize, size_t nItems=1)

     {

       if (ptr + itemSize * nItems > end) {

         if (ptr + itemSize > end)

@@ -76,13 +76,13 @@ namespace rdr {

       writeBytes(str, len);

     }

-    inline void pad(int bytes) {

+    inline void pad(size_t bytes) {

       while (bytes-- > 0) writeU8(0);

     }

-    inline void skip(int bytes) {

+    inline void skip(size_t bytes) {

       while (bytes > 0) {

-        int n = check(1, bytes);

+        size_t n = check(1, bytes);

         ptr += n;

         bytes -= n;

       }

@@ -90,11 +90,11 @@ namespace rdr {