Completely redesigned Server and Client.

Like, seriously, they're almost completely different.

1 files changed, 87 insertions, 81 deletions

diff --git a/src/stable/tcpsocket.cpp b/src/stable/sockettcp.cpp
index d036063..d61f92f 100644
--- a/src/stable/tcpsocket.cpp
+++ b/src/stable/sockettcp.cpp
@@ -14,7 +14,7 @@
 #include <sys/time.h>
 #include <errno.h>
 #include <fcntl.h>
-#include "bu/tcpsocket.h"
+#include "bu/sockettcp.h"
 
 #include "bu/config.h"
 
@@ -29,10 +29,10 @@
 
 #define RBS (1024*2)
 
-namespace Bu { subExceptionDef( TcpSocketException ) }
+namespace Bu { subExceptionDef( SocketTcpException ) }
 
-Bu::TcpSocket::TcpSocket( handle nTcpSocket ) :
-    nTcpSocket( nTcpSocket ),
+Bu::SocketTcp::SocketTcp( handle nSocketTcp ) :
+    nSocketTcp( nSocketTcp ),
     bActive( true ),
     bBlocking( true )
 {
@@ -42,9 +42,9 @@ Bu::TcpSocket::TcpSocket( handle nTcpSocket ) :
     setAddress();
 }
 
-Bu::TcpSocket::TcpSocket( const Bu::String &sAddr, int nPort, int nTimeout,
+Bu::SocketTcp::SocketTcp( const Bu::String &sAddr, int nPort, int nTimeout,
         bool bBlocking ) :
-    nTcpSocket( 0 ),
+    nSocketTcp( 0 ),
     bActive( false ),
     bBlocking( true )
 {
@@ -53,12 +53,12 @@ Bu::TcpSocket::TcpSocket( const Bu::String &sAddr, int nPort, int nTimeout,
 #endif
 
     /* Create the socket. */
-    nTcpSocket = bu_socket( PF_INET, SOCK_STREAM, 0 );
+    nSocketTcp = bu_socket( PF_INET, SOCK_STREAM, 0 );
     
 #ifdef WIN32
-    if( nTcpSocket == INVALID_SOCKET )
+    if( nSocketTcp == INVALID_SOCKET )
 #else
-    if( nTcpSocket < 0 )
+    if( nSocketTcp < 0 )
 #endif
     {
         throw ExceptionBase("Couldn't create socket.\n");
@@ -83,12 +83,12 @@ Bu::TcpSocket::TcpSocket( const Bu::String &sAddr, int nPort, int nTimeout,
             sAddr.getStr(), ibuf, &aiHints, &pAddr )) != 0 )
         {
             close();
-            throw Bu::TcpSocketException("Couldn't resolve hostname %s (%s).\n",
+            throw Bu::SocketTcpException("Couldn't resolve hostname %s (%s).\n",
                 sAddr.getStr(), bu_gai_strerror(ret));
         }
 
         bu_connect(
-            nTcpSocket,
+            nSocketTcp,
             pAddr->ai_addr,
             pAddr->ai_addrlen
             );
@@ -106,17 +106,17 @@ Bu::TcpSocket::TcpSocket( const Bu::String &sAddr, int nPort, int nTimeout,
         int retval;
         
         FD_ZERO(&rfds);
-        FD_SET(nTcpSocket, &rfds);
+        FD_SET(nSocketTcp, &rfds);
         FD_ZERO(&wfds);
-        FD_SET(nTcpSocket, &wfds);
+        FD_SET(nSocketTcp, &wfds);
         FD_ZERO(&efds);
-        FD_SET(nTcpSocket, &efds);
+        FD_SET(nSocketTcp, &efds);
 
         struct timeval tv;
         tv.tv_sec = nTimeout;
         tv.tv_usec = 0;
         
-        retval = bu_select( nTcpSocket+1, &rfds, &wfds, &efds, &tv );
+        retval = bu_select( nSocketTcp+1, &rfds, &wfds, &efds, &tv );
 
         if( retval == 0 )
         {
@@ -130,49 +130,49 @@ Bu::TcpSocket::TcpSocket( const Bu::String &sAddr, int nPort, int nTimeout,
         setBlocking( bBlocking );
 }
 
-Bu::TcpSocket::~TcpSocket()
+Bu::SocketTcp::~SocketTcp()
 {
     close();
 }
 
-void Bu::TcpSocket::close()
+void Bu::SocketTcp::close()
 {
     if( bActive )
     {
 #ifndef WIN32
-        fsync( nTcpSocket );
+        fsync( nSocketTcp );
 #endif
 #ifdef WIN32
  #ifndef SHUT_RDWR
   #define SHUT_RDWR (SD_BOTH)
  #endif
 #endif
-        bu_shutdown( nTcpSocket, SHUT_RDWR );
-        ::close( nTcpSocket );
+        bu_shutdown( nSocketTcp, SHUT_RDWR );
+        ::close( nSocketTcp );
     }
     bActive = false;
 }
 
-Bu::size Bu::TcpSocket::read( void *pBuf, Bu::size nBytes )
+Bu::size Bu::SocketTcp::read( void *pBuf, Bu::size nBytes )
 {
     fd_set rfds;
     FD_ZERO(&rfds);
-    FD_SET(nTcpSocket, &rfds);
+    FD_SET(nSocketTcp, &rfds);
     struct timeval tv = {0, 0};
-    if( bu_select( nTcpSocket+1, &rfds, NULL, NULL, &tv ) < 0 )
+    if( bu_select( nSocketTcp+1, &rfds, NULL, NULL, &tv ) < 0 )
     {
         int iErr = errno;
         close();
-        throw TcpSocketException( TcpSocketException::cRead, strerror(iErr) );
+        throw SocketTcpException( SocketTcpException::cRead, strerror(iErr) );
     }
-    if( FD_ISSET( nTcpSocket, &rfds ) || bBlocking )
+    if( FD_ISSET( nSocketTcp, &rfds ) || bBlocking )
     {
         int nRead = TEMP_FAILURE_RETRY( 
-            bu_recv( nTcpSocket, (char *) pBuf, nBytes, 0 ) );
+            bu_recv( nSocketTcp, (char *) pBuf, nBytes, 0 ) );
         if( nRead == 0 && nBytes > 0 )
         {
             close();
-            throw TcpSocketException( TcpSocketException::cClosed, "TcpSocket closed.");
+            throw SocketTcpException( SocketTcpException::cClosed, "SocketTcp closed.");
         }
         if( nRead < 0 )
         {
@@ -184,14 +184,14 @@ Bu::size Bu::TcpSocket::read( void *pBuf, Bu::size nBytes )
             if( errno == ENETRESET || errno == ECONNRESET )
             {
                 close();
-                throw TcpSocketException( TcpSocketException::cClosed,
+                throw SocketTcpException( SocketTcpException::cClosed,
                     strerror(errno) );
             }
             if( errno == EAGAIN )
                 return 0;
             int iErr = errno;
             close();
-            throw TcpSocketException( TcpSocketException::cRead, strerror(iErr) );
+            throw SocketTcpException( SocketTcpException::cRead, strerror(iErr) );
 #endif
         }
         return nRead;
@@ -199,7 +199,7 @@ Bu::size Bu::TcpSocket::read( void *pBuf, Bu::size nBytes )
     return 0;
 }
 
-Bu::size Bu::TcpSocket::read( void *pBuf, Bu::size nBytes,
+Bu::size Bu::SocketTcp::read( void *pBuf, Bu::size nBytes,
         uint32_t nSec, uint32_t nUSec )
 {
     struct timeval tv;
@@ -207,7 +207,7 @@ Bu::size Bu::TcpSocket::read( void *pBuf, Bu::size nBytes,
     
     fd_set rfds;
     FD_ZERO(&rfds);
-    FD_SET(nTcpSocket, &rfds);
+    FD_SET(nSocketTcp, &rfds);
 
 #ifdef WIN32
     DWORD dwStart = GetTickCount();
@@ -224,7 +224,7 @@ Bu::size Bu::TcpSocket::read( void *pBuf, Bu::size nBytes,
     {
         tv.tv_sec = nSec;
         tv.tv_usec = nUSec;
-        bu_select( nTcpSocket+1, &rfds, NULL, NULL, &tv );
+        bu_select( nSocketTcp+1, &rfds, NULL, NULL, &tv );
         nRead += read( ((char *)pBuf)+nRead, nBytes-nRead );
         if( nRead >= nBytes )
             break;
@@ -243,13 +243,13 @@ Bu::size Bu::TcpSocket::read( void *pBuf, Bu::size nBytes,
     return nRead;
 }
 
-Bu::size Bu::TcpSocket::write( const void *pBuf, Bu::size nBytes )
+Bu::size Bu::SocketTcp::write( const void *pBuf, Bu::size nBytes )
 {
 //#ifdef WIN32
     int nWrote = TEMP_FAILURE_RETRY( 
-        bu_send( nTcpSocket, (const char *) pBuf, nBytes, 0 ) );
+        bu_send( nSocketTcp, (const char *) pBuf, nBytes, 0 ) );
 //#else
-//  int nWrote = TEMP_FAILURE_RETRY( ::write( nTcpSocket, pBuf, nBytes ) );
+//  int nWrote = TEMP_FAILURE_RETRY( ::write( nSocketTcp, pBuf, nBytes ) );
 //#endif
     if( nWrote < 0 )
     {
@@ -260,19 +260,19 @@ Bu::size Bu::TcpSocket::write( const void *pBuf, Bu::size nBytes )
 #else
         if( errno == EAGAIN ) return 0;
 #endif
-        throw TcpSocketException( TcpSocketException::cWrite, strerror(errno) );
+        throw SocketTcpException( SocketTcpException::cWrite, strerror(errno) );
     }
     return nWrote;
 }
 
-Bu::size Bu::TcpSocket::write( const void *pBuf, Bu::size nBytes, uint32_t nSec, uint32_t nUSec )
+Bu::size Bu::SocketTcp::write( const void *pBuf, Bu::size nBytes, uint32_t nSec, uint32_t nUSec )
 {
     struct timeval tv;
     Bu::size nWrote = 0;
     
     fd_set wfds;
     FD_ZERO(&wfds);
-    FD_SET(nTcpSocket, &wfds);
+    FD_SET(nSocketTcp, &wfds);
 
 #ifdef WIN32
     DWORD dwStart = GetTickCount();
@@ -289,7 +289,7 @@ Bu::size Bu::TcpSocket::write( const void *pBuf, Bu::size nBytes, uint32_t nSec,
     {
         tv.tv_sec = nSec;
         tv.tv_usec = nUSec;
-        bu_select( nTcpSocket+1, NULL, &wfds, NULL, &tv );
+        bu_select( nSocketTcp+1, NULL, &wfds, NULL, &tv );
         nWrote += write( ((char *)pBuf)+nWrote, nBytes-nWrote );
         if( nWrote >= nBytes )
             break;
@@ -308,101 +308,101 @@ Bu::size Bu::TcpSocket::write( const void *pBuf, Bu::size nBytes, uint32_t nSec,
     return nWrote;
 }
 
-Bu::size Bu::TcpSocket::tell()
+Bu::size Bu::SocketTcp::tell()
 {
     throw UnsupportedException();
 }
 
-void Bu::TcpSocket::seek( Bu::size )
+void Bu::SocketTcp::seek( Bu::size )
 {
     throw UnsupportedException();
 }
 
-void Bu::TcpSocket::setPos( Bu::size )
+void Bu::SocketTcp::setPos( Bu::size )
 {
     throw UnsupportedException();
 }
 
-void Bu::TcpSocket::setPosEnd( Bu::size )
+void Bu::SocketTcp::setPosEnd( Bu::size )
 {
     throw UnsupportedException();
 }
 
-bool Bu::TcpSocket::isEos()
+bool Bu::SocketTcp::isEos()
 {
     return !bActive;
 }
 
-bool Bu::TcpSocket::canRead()
+bool Bu::SocketTcp::canRead()
 {
     fd_set rfds;
     FD_ZERO(&rfds);
-    FD_SET(nTcpSocket, &rfds);
+    FD_SET(nSocketTcp, &rfds);
     struct timeval tv = { 0, 0 };
-    int retval = bu_select( nTcpSocket+1, &rfds, NULL, NULL, &tv );
+    int retval = bu_select( nSocketTcp+1, &rfds, NULL, NULL, &tv );
     if( retval == -1 )
-        throw TcpSocketException(
-            TcpSocketException::cBadRead,
+        throw SocketTcpException(
+            SocketTcpException::cBadRead,
             "Bad Read error"
             );
 
-    if( !FD_ISSET( nTcpSocket, &rfds ) )
+    if( !FD_ISSET( nSocketTcp, &rfds ) )
         return false;
     return true;
 }
 
-bool Bu::TcpSocket::canWrite()
+bool Bu::SocketTcp::canWrite()
 {
     fd_set wfds;
     FD_ZERO(&wfds);
-    FD_SET(nTcpSocket, &wfds);
+    FD_SET(nSocketTcp, &wfds);
     struct timeval tv = { 0, 0 };
-    int retval = bu_select( nTcpSocket+1, NULL, &wfds, NULL, &tv );
+    int retval = bu_select( nSocketTcp+1, NULL, &wfds, NULL, &tv );
     if( retval == -1 )
-        throw TcpSocketException(
-            TcpSocketException::cBadRead,
+        throw SocketTcpException(
+            SocketTcpException::cBadRead,
             "Bad Read error"
             );
-    if( !FD_ISSET( nTcpSocket, &wfds ) )
+    if( !FD_ISSET( nSocketTcp, &wfds ) )
         return false;
     return true;
 }
 
-bool Bu::TcpSocket::isReadable()
+bool Bu::SocketTcp::isReadable()
 {
     return true;
 }
 
-bool Bu::TcpSocket::isWritable()
+bool Bu::SocketTcp::isWritable()
 {
     return true;
 }
 
-bool Bu::TcpSocket::isSeekable()
+bool Bu::SocketTcp::isSeekable()
 {
     return false;
 }
 
-bool Bu::TcpSocket::isBlocking()
+bool Bu::SocketTcp::isBlocking()
 {
 #ifndef WIN32
-    return ((fcntl( nTcpSocket, F_GETFL, 0 ) & O_NONBLOCK) != O_NONBLOCK);
+    return ((fcntl( nSocketTcp, F_GETFL, 0 ) & O_NONBLOCK) != O_NONBLOCK);
 #else
     return false;
 #endif
 }
 
-void Bu::TcpSocket::setBlocking( bool bBlocking )
+void Bu::SocketTcp::setBlocking( bool bBlocking )
 {
     this->bBlocking = bBlocking;
 #ifndef WIN32
     if( bBlocking )
     {
-        fcntl( nTcpSocket, F_SETFL, fcntl( nTcpSocket, F_GETFL, 0 ) & (~O_NONBLOCK) );
+        fcntl( nSocketTcp, F_SETFL, fcntl( nSocketTcp, F_GETFL, 0 ) & (~O_NONBLOCK) );
     }
     else
     {
-        fcntl( nTcpSocket, F_SETFL, fcntl( nTcpSocket, F_GETFL, 0 ) | O_NONBLOCK );
+        fcntl( nSocketTcp, F_SETFL, fcntl( nSocketTcp, F_GETFL, 0 ) | O_NONBLOCK );
     }
 #else
     u_long iMode;
@@ -416,67 +416,73 @@ void Bu::TcpSocket::setBlocking( bool bBlocking )
     // socket based on the numerical value of iMode.
     // If iMode = 0, blocking is enabled; 
     // If iMode != 0, non-blocking mode is enabled.
-    bu_ioctlsocket(nTcpSocket, FIONBIO, &iMode);
+    bu_ioctlsocket(nSocketTcp, FIONBIO, &iMode);
 #endif  
 }
 
-void Bu::TcpSocket::setSize( Bu::size )
+void Bu::SocketTcp::setSize( Bu::size )
 {
 }
 
-void Bu::TcpSocket::flush()
+void Bu::SocketTcp::flush()
 {
 }
 
-bool Bu::TcpSocket::isOpen()
+bool Bu::SocketTcp::isOpen()
 {
     return bActive;
 }
 
-void Bu::TcpSocket::setAddress()
+void Bu::SocketTcp::setAddress()
 {
     struct sockaddr_in addr;
     socklen_t len = sizeof(addr);
     addr.sin_family = AF_INET;
-    bu_getpeername( nTcpSocket, (sockaddr *)(&addr), &len );
+    bu_getpeername( nSocketTcp, (sockaddr *)(&addr), &len );
     sAddress = bu_inet_ntoa( addr.sin_addr );
 }
 
-Bu::String Bu::TcpSocket::getAddress() const
+Bu::String Bu::SocketTcp::getAddress() const
 {
     return sAddress;
 }
 
-Bu::TcpSocket::operator Bu::TcpSocket::handle() const
+Bu::SocketTcp::operator Bu::SocketTcp::handle() const
 {
-    return nTcpSocket;
+    return nSocketTcp;
 }
 
-Bu::TcpSocket::handle Bu::TcpSocket::getHandle() const
+Bu::SocketTcp::handle Bu::SocketTcp::getHandle() const
 {
-    return nTcpSocket;
+    return nSocketTcp;
 }
 
-Bu::TcpSocket::handle Bu::TcpSocket::takeHandle()
+Bu::SocketTcp::handle Bu::SocketTcp::takeHandle()
 {
-    handle nRet = nTcpSocket;
+    handle nRet = nSocketTcp;
     bActive = false;
-    nTcpSocket = 0;
+    nSocketTcp = 0;
     return nRet;
 }
 
-Bu::size Bu::TcpSocket::getSize() const
+Bu::size Bu::SocketTcp::getSize() const
 {
     throw UnsupportedException();
 }
 
-Bu::size Bu::TcpSocket::getBlockSize() const
+Bu::size Bu::SocketTcp::getBlockSize() const
 {
     return 1500; //TODO: Fix this, it's stupid.
 }
 
-Bu::String Bu::TcpSocket::getLocation() const
+Bu::String Bu::SocketTcp::getLocation() const
 {
     return getAddress();
 }
 
+bool Bu::SocketTcp::getFd( int &rFdOut ) const
+{
+    rFdOut = nSocketTcp;
+    return true;
+}
+