Make BufferedInStream allocation more available

Allow subclasses to call it, instead of it being strictly internal. This
is useful when a subclass can only provide data in minimum sized chunks.

common/rdr/BufferedInStream.cxx

 #include <config.h>
 #endif
 
+#include <assert.h>
+
 #include <rdr/BufferedInStream.h>
 #include <rdr/Exception.h>
 
   return offset + ptr - start;
 }
 
-bool BufferedInStream::overrun(size_t needed)
+void BufferedInStream::ensureSpace(size_t needed)
 {
   struct timeval now;
 
+  // Given argument is how much free space is needed, but for allocation
+  // purposes we need to now how much space everything needs, including
+  // any existing data already in the buffer
+  needed += avail();
+
   if (needed > bufSize) {
     size_t newSize;
     U8* newBuffer;
     end -= ptr - start;
     ptr = start;
   }
+}
+
+bool BufferedInStream::overrun(size_t needed)
+{
+  // Make sure fillBuffer() has room for all the requested data
+  assert(needed > avail());
+  ensureSpace(needed - avail());
 
   while (avail() < needed) {
-    if (!fillBuffer(start + bufSize - end))
+    if (!fillBuffer())
       return false;
   }
 

common/rdr/BufferedInStream.h

 
     virtual size_t pos();
 
+  protected:
+    size_t availSpace() { return start + bufSize - end; }
+
+    void ensureSpace(size_t needed);
+
   private:
-    virtual bool fillBuffer(size_t maxSize) = 0;
+    virtual bool fillBuffer() = 0;
 
     virtual bool overrun(size_t needed);
 

common/rdr/FdInStream.cxx

 }
 
 
-bool FdInStream::fillBuffer(size_t maxSize)
+bool FdInStream::fillBuffer()
 {
-  size_t n = readFd((U8*)end, maxSize);
+  size_t n = readFd((U8*)end, availSpace());
   if (n == 0)
     return false;
   end += n;

common/rdr/FdInStream.h

     int getFd() { return fd; }
 
   private:
-    virtual bool fillBuffer(size_t maxSize);
+    virtual bool fillBuffer();
 
     size_t readFd(void* buf, size_t len);
 

common/rdr/FileInStream.cxx

   }
 }
 
-bool FileInStream::fillBuffer(size_t maxSize)
+bool FileInStream::fillBuffer()
 {
-  size_t n = fread((U8 *)end, 1, maxSize, file);
+  size_t n = fread((U8 *)end, 1, availSpace(), file);
   if (n == 0) {
     if (ferror(file))
       throw SystemException("fread", errno);

common/rdr/FileInStream.h

     ~FileInStream(void);
 
   private:
-    virtual bool fillBuffer(size_t maxSize);
+    virtual bool fillBuffer();
 
   private:
     FILE *file;

common/rdr/HexInStream.cxx

 }
 
 
-bool HexInStream::fillBuffer(size_t maxSize) {
+bool HexInStream::fillBuffer() {
   if (!in_stream.hasData(2))
     return false;
 
-  size_t length = min(in_stream.avail()/2, maxSize);
+  size_t length = min(in_stream.avail()/2, availSpace());
   const U8* iptr = in_stream.getptr(length*2);
 
   U8* optr = (U8*) end;

common/rdr/HexInStream.h

     static bool hexStrToBin(const char* s, char** data, size_t* length);
 
   private:
-    virtual bool fillBuffer(size_t maxSize);
+    virtual bool fillBuffer();
 
   private:
     InStream& in_stream;

common/rdr/RandomStream.cxx

 #endif
 }
 
-bool RandomStream::fillBuffer(size_t maxSize) {
+bool RandomStream::fillBuffer() {
 #ifdef RFB_HAVE_WINCRYPT
   if (provider) {
-    if (!CryptGenRandom(provider, maxSize, (U8*)end))
+    if (!CryptGenRandom(provider, availSpace(), (U8*)end))
       throw rdr::SystemException("unable to CryptGenRandom", GetLastError());
-    end += maxSize;
+    end += availSpace();
   } else {
 #else
 #ifndef WIN32
   if (fp) {
-    size_t n = fread((U8*)end, 1, maxSize, fp);
+    size_t n = fread((U8*)end, 1, availSpace(), fp);
     if (n <= 0)
       throw rdr::SystemException("reading /dev/urandom or /dev/random failed",
                                  errno);
   {
 #endif
 #endif
-    for (size_t i=0; i<maxSize; i++)
+    for (size_t i=availSpace(); i>0; i--)
       *(U8*)end++ = (int) (256.0*rand()/(RAND_MAX+1.0));
   }
 

common/rdr/RandomStream.h

     virtual ~RandomStream();
 
   private:
-    virtual bool fillBuffer(size_t maxSize);
+    virtual bool fillBuffer();
 
   private:
     static unsigned int seed;

common/rdr/TLSInStream.cxx

   delete saved_exception;
 }
 
-bool TLSInStream::fillBuffer(size_t maxSize)
+bool TLSInStream::fillBuffer()
 {
-  size_t n = readTLS((U8*) end, maxSize);
+  size_t n = readTLS((U8*) end, availSpace());
   if (n == 0)
     return false;
   end += n;

common/rdr/TLSInStream.h

     virtual ~TLSInStream();
 
   private:
-    virtual bool fillBuffer(size_t maxSize);
+    virtual bool fillBuffer();
     size_t readTLS(U8* buf, size_t len);
     static ssize_t pull(gnutls_transport_ptr_t str, void* data, size_t size);
 

common/rdr/ZlibInStream.cxx

   zs = NULL;
 }
 
-bool ZlibInStream::fillBuffer(size_t maxSize)
+bool ZlibInStream::fillBuffer()
 {
   if (!underlying)
     throw Exception("ZlibInStream overrun: no underlying stream");
 
   zs->next_out = (U8*)end;
-  zs->avail_out = maxSize;
+  zs->avail_out = availSpace();
 
   if (!underlying->hasData(1))
     return false;

common/rdr/ZlibInStream.h

     void init();
     void deinit();
 
-    virtual bool fillBuffer(size_t maxSize);
+    virtual bool fillBuffer();
 
   private:
     InStream* underlying;