The reorg is being put in trunk, I think it's ready. Now we just get to find

out how many applications won't work anymore :)

1 files changed, 96 insertions, 0 deletions

diff --git a/src/server.cpp b/src/server.cpp
new file mode 100644
index 0000000..d07a597
--- /dev/null
+++ b/src/server.cpp
@@ -0,0 +1,96 @@
+#include "bu/server.h"
+#include <errno.h>
+#include "bu/serversocket.h"
+#include "bu/client.h"
+#include "bu/socket.h"
+
+Bu::Server::Server() :
+        nTimeoutSec( 0 ),
+        nTimeoutUSec( 0 )
+{
+        FD_ZERO( &fdActive );
+}
+
+Bu::Server::~Server()
+{
+}
+
+void Bu::Server::addPort( int nPort, int nPoolSize )
+{
+        ServerSocket *s = new ServerSocket( nPort, nPoolSize );
+        int nSocket = s->getSocket();
+        FD_SET( nSocket, &fdActive );
+        hServers.insert( nSocket, s );
+}
+
+void Bu::Server::addPort( const FString &sAddr, int nPort, int nPoolSize )
+{
+        ServerSocket *s = new ServerSocket( sAddr, nPort, nPoolSize );
+        int nSocket = s->getSocket();
+        FD_SET( nSocket, &fdActive );
+        hServers.insert( nSocket, s );
+}
+
+void Bu::Server::setTimeout( int nTimeoutSec, int nTimeoutUSec )
+{
+        this->nTimeoutSec = nTimeoutSec;
+        this->nTimeoutUSec = nTimeoutUSec;
+}
+
+void Bu::Server::scan()
+{
+        struct timeval xTimeout = { nTimeoutSec, nTimeoutUSec };
+        
+        fd_set fdRead = fdActive;
+        fd_set fdWrite = fdActive;
+        fd_set fdException = fdActive;
+
+        if( TEMP_FAILURE_RETRY( select( FD_SETSIZE, &fdRead, NULL, &fdException, &xTimeout ) ) < 0 )
+        {
+                throw ExceptionBase("Error attempting to scan open connections.");
+        }
+
+        for( int j = 0; j < FD_SETSIZE; j++ )
+        {
+                if( FD_ISSET( j, &fdRead ) )
+                {
+                        if( hServers.has( j ) )
+                        {
+                                ServerSocket *pSrv = hServers.get( j );
+                                addClient( pSrv->accept(), pSrv->getPort() );
+                        }
+                        else
+                        {
+                                Client *pClient = hClients.get( j );
+                                pClient->processInput();
+                                if( !pClient->isOpen() )
+                                {
+                                        onClosedConnection( pClient );
+                                        hClients.erase( j );
+                                        FD_CLR( j, &fdActive );
+                                }
+                        }
+                }
+        }
+
+        // Now we just try to write all the pending data on all the sockets.
+        // this could be done better eventually, if we care about the socket
+        // wanting to accept writes (using a select).
+        for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
+        {
+                (*i)->processOutput();
+        }
+}
+
+void Bu::Server::addClient( int nSocket, int nPort )
+{
+        FD_SET( nSocket, &fdActive );
+
+        Client *c = new Client(
+                new Bu::Socket( nSocket )
+                );
+        hClients.insert( nSocket, c );
+
+        onNewConnection( c, nPort );
+}
+