1 files changed, 16 insertions, 3 deletions

diff --git a/src/stable/clientbuf.cpp b/src/stable/clientbuf.cpp
index 493e577..4e59120 100644
--- a/src/stable/clientbuf.cpp
+++ b/src/stable/clientbuf.cpp
@@ -2,10 +2,12 @@
 
 #include "bu/mutexlocker.h"
 
+#include "bu/sio.h"
+
 Bu::ClientBuf::ClientBuf() :
     accClientRaw( *this ),
     accServer( *this ),
-    accClientFiltered( &accClient ),
+    //accClientFiltered( &accClientRaw ),
     accClient( *this )
 {
 }
@@ -156,7 +158,7 @@ Bu::String Bu::ClientBuf::ClientAccessRaw::getLocation() const
 /////////
 // ClientAccess
 ///
-
+#define accClientFiltered accClientRaw
 Bu::ClientBuf::ClientAccess::ClientAccess( Bu::ClientBuf &rBuf ) :
     rBuf( rBuf )
 {
@@ -173,16 +175,19 @@ void Bu::ClientBuf::ClientAccess::close()
 
 Bu::size Bu::ClientBuf::ClientAccess::read( void *pBufRaw, size iBytes )
 {
+    Bu::println("ClientAccess::read( ptr, %1 )").arg( iBytes );
     char *pBuf = (char *)pBufRaw;
     Bu::MutexLocker l( mAccess );
     // Read from QueueBuf first
     Bu::size ps = qbPeek.read( pBuf, iBytes );
+    Bu::println("ClientAccess::read: attempted qbPeek, got %1\n>%2<").arg( ps ).arg( Bu::String(pBuf, ps) );
     iBytes -= ps;
     pBuf += ps;
     // Request space left? Try the client
     if( iBytes > 0 )
     {
         ps += rBuf.accClientFiltered.read( pBuf, iBytes );
+        Bu::println("ClientAccess::read: attempted completion from socket buffer, got %1\n>%2<").arg( ps ).arg( Bu::String(pBuf, ps) );
     }
     return ps;
 }
@@ -190,22 +195,26 @@ Bu::size Bu::ClientBuf::ClientAccess::read( void *pBufRaw, size iBytes )
 Bu::size Bu::ClientBuf::ClientAccess::peek( void *pData, int iBytes,
         int iOffset )
 {
+    Bu::println("ClientAccess::peek( ptr, %1, %2 )").arg( iBytes ).arg( iOffset );
     Bu::MutexLocker l( mAccess );
     // Do we have enough data in the peek buffer to handle this?
     if( qbPeek.getSize() < iBytes+iOffset )
     {
+        Bu::println("ClientAccess::peek: Insufficient buffered data (%1)").arg( qbPeek.getSize() );
         // Nope, make an attempt to fill it in.
         int nDiff = iBytes-qbPeek.getSize();
         // We have to make our own buffer, since iBytes+nOffeset could be bigger
         // than pData.
         char *pTmp = new char[nDiff];
         Bu::size ps = rBuf.accClientFiltered.read( pTmp, nDiff );
+        Bu::println("ClientAccess::peek: Tried to fill buffer, read %1 of needed %2\n>%3<").arg( ps ).arg( nDiff ).arg( Bu::String(pTmp, ps) );
         if( ps > 0 )
         {
             // Add the data read to the peek buffer.
             qbPeek.write( pTmp, ps );
         }
         delete[] pTmp;
+        Bu::println("ClientAccess::peek: buffer left with %1").arg( qbPeek.getSize() );
     }
 
     return qbPeek.peek( pData, iBytes, iOffset );
@@ -225,13 +234,15 @@ Bu::size Bu::ClientBuf::ClientAccess::tell()
 
 void Bu::ClientBuf::ClientAccess::seek( Bu::size offset )
 {
+    Bu::println("ClientAccess::seek( %1 )").arg( offset );
     Bu::MutexLocker l( mAccess );
     // For this type of stream seek is basically a destructive skip. It's like
     // reading the data but with no output buffer. Let's remove data from the
     // peek buffer first.
     if( qbPeek.getSize() > 0 )
     {
-        Bu::size amount = Bu::buMax( qbPeek.getSize(), offset );
+        Bu::size amount = Bu::buMin( qbPeek.getSize(), offset );
+        Bu::println("ClientAccess::seek: buffered: %1, amount: %2").arg( qbPeek.getSize() ).arg( amount );
         qbPeek.seek( amount );
         offset -= amount;
     }
@@ -239,6 +250,7 @@ void Bu::ClientBuf::ClientAccess::seek( Bu::size offset )
     // If there's offset left, then apply it to the underlying stream
     if( offset > 0 )
     {
+        Bu::println("ClientAccess::seek: seeking remaining %1 in socket buffer").arg( offset );
         rBuf.accClientFiltered.seek( offset );
     }
 }
@@ -329,6 +341,7 @@ Bu::String Bu::ClientBuf::ClientAccess::getLocation() const
 {
     return "ClientBuf";
 }
+#undef accClientFiltered
 
 /////////
 // ServerAccess