Discovered that the Bu::Client::disconnect() function didn't do anything. That

has been fixed, it now safely disconnects after emptying the Client's outgoing
buffer.

Added some more helpers to Bu::FString.

Added the beginings of ProtocolHttp using a new method for processing protocols
that's based more strongly on an NFA state machine, this makes sense, but I
never had the desire to actually try implementing it before.  It's working
pretty well.

6 files changed, 275 insertions, 8 deletions

diff --git a/src/client.cpp b/src/client.cpp
index d416700..19d2778 100644
--- a/src/client.cpp
+++ b/src/client.cpp
@@ -11,7 +11,8 @@
 Bu::Client::Client( Bu::Socket *pSocket ) :
         pSocket( pSocket ),
         pProto( NULL ),
-        nRBOffset( 0 )
+        nRBOffset( 0 ),
+        bWantsDisconnect( false )
 {
 }
 
@@ -205,5 +206,15 @@ const Bu::Socket *Bu::Client::getSocket() const
 
 void Bu::Client::disconnect()
 {
+        bWantsDisconnect = true;
 }
 
+bool Bu::Client::wantsDisconnect()
+{
+        return bWantsDisconnect;
+}
+
+void Bu::Client::close()
+{
+        pSocket->close();
+}
diff --git a/src/client.h b/src/client.h
index 4188a49..0b670e2 100644
--- a/src/client.h
+++ b/src/client.h
@@ -44,13 +44,12 @@ namespace Bu
                 void clearProtocol();
 
                 bool isOpen();
+                void close();
 
                 const Bu::Socket *getSocket() const;
 
-                /**
-                 *@todo Make this not suck.
-                 */
                 void disconnect();
+                bool wantsDisconnect();
 
         private:
                 Bu::Socket *pSocket;
@@ -58,6 +57,7 @@ namespace Bu
                 Bu::FString sReadBuf;
                 int nRBOffset;
                 Bu::FString sWriteBuf;
+                bool bWantsDisconnect;
         };
 }
 
diff --git a/src/fstring.h b/src/fstring.h
index 9de6a56..0306aa1 100644
--- a/src/fstring.h
+++ b/src/fstring.h
@@ -605,10 +605,26 @@ namespace Bu
 
                 /**
                  * Find the index of the first occurrance of (sText)
-                 *@param sText (const char *) The string to search for.
+                 *@param sText (const chr *) The string to search for.
                  *@returns (long) The index of the first occurrance. -1 for not found.
                  */
-                long find( const char *sText )
+                long find( const chr cChar )
+                {
+                        flatten();
+                        for( long j = 0; j < pFirst->nLength; j++ )
+                        {
+                                if( pFirst->pData[j] == cChar )
+                                        return j;
+                        }
+                        return -1;
+                }
+                
+                /**
+                 * Find the index of the first occurrance of cChar
+                 *@param cChar (const chr) The character to search for.
+                 *@returns (long) The index of the first occurrance. -1 for not found.
+                 */
+                long find( const chr *sText )
                 {
                         long nTLen = strlen( sText );
                         flatten();
@@ -622,10 +638,10 @@ namespace Bu
 
                 /**
                  * Do a reverse search for (sText)
-                 *@param sText (const char *) The string to search for.
+                 *@param sText (const chr *) The string to search for.
                  *@returns (long) The index of the last occurrance. -1 for not found.
                  */
-                long rfind( const char *sText )
+                long rfind( const chr *sText )
                 {
                         long nTLen = strlen( sText );
                         flatten();
diff --git a/src/protocolhttp.cpp b/src/protocolhttp.cpp
new file mode 100644
index 0000000..6f2ae68
--- /dev/null
+++ b/src/protocolhttp.cpp
@@ -0,0 +1,163 @@
+#include <dirent.h>
+#include <sys/wait.h>
+#include <errno.h>
+#include "protocolhttp.h"
+
+#define CRLF "\x0D\x0A"
+#define CR '\x0D'
+#define LF '\x0A'
+
+using namespace Bu;
+
+Bu::ProtocolHttp::ProtocolHttp()
+{
+}
+
+Bu::ProtocolHttp::~ProtocolHttp()
+{
+}
+
+void Bu::ProtocolHttp::onNewConnection( Bu::Client *pClient )
+{
+        this->pClient = pClient;
+
+        iState = 0;
+}
+
+#define SDB( i ) printf("state %d: %d, \"%s\"\n", i, tt, sToken.getStr() )
+
+void Bu::ProtocolHttp::onNewData( Bu::Client *pClient )
+{
+        for(;;)
+        {
+                Bu::FString sToken;
+                TokenType tt = getToken( sToken );
+
+                if( tt == ttOutOfData )
+                        return;
+
+                switch( iState )
+                {
+                        case 0:         // Initial header
+                                SDB( 0 );
+                                sMethod = sToken;
+                                iState = 1;
+                                break;
+
+                        case 1:         // Misc headers
+                                SDB( 1 );
+                                sPath = sToken;
+                                iState = 2;
+                                break;
+
+                        case 2:         // Content
+                                SDB( 2 );
+                                if( strncmp( sToken.getStr(), "HTTP/", 5 ) )
+                                {
+                                        printf("not http, disconnect.\n");
+                                        pClient->disconnect();
+                                        return;
+                                }
+                                else
+                                {
+                                        char *s, *s2;
+                                        s = sToken.getStr()+5;
+                                        iMajor = strtol( s, &s2, 10 );
+                                        iMinor = strtol( s2+1, NULL, 10 );
+                                        printf("HTTP: %d.%d\n", iMajor, iMinor );
+                                        iState = 3;
+                                }
+                                break;
+
+                        case 3:
+                                SDB( 3 );
+                                pClient->disconnect();
+                                return;
+                                break;
+                }
+        }
+}
+
+Bu::ProtocolHttp::TokenType Bu::ProtocolHttp::getToken( Bu::FString &line )
+{
+        char s;
+        int jmax = pClient->getInputSize();
+        bool bNonWS = false;
+        
+        for( int j = 0; j < jmax; j++ )
+        {
+                pClient->peek( &s, 1, j );
+                if( iState > 2 && isSeperator( s ) )
+                {
+                        if( j == 0 )
+                        {
+                                line += s;
+                                pClient->seek( 1 );
+                                return ttSeperator;
+                        }
+                        else
+                        {
+                                pClient->seek( j );
+                                return ttString;
+                        }
+                }
+                else if( isWS( s ) )
+                {
+                        if( bNonWS )
+                        {
+                                pClient->seek( j );
+                                return ttString;
+                        }
+                }
+                else if( s == CR )
+                {
+                        if( pClient->getInputSize() < 3 )
+                                return ttOutOfData;
+                        
+                        char ss[2];
+                        pClient->peek( ss, 2, j+1 );
+                        if( ss[0] == LF && ss[1] != ' ' && ss[1] != '\t' )
+                        {
+                                if( bNonWS )
+                                {
+                                        pClient->seek( j );
+                                        return ttString;
+                                }
+                                else
+                                {
+                                        pClient->seek( 2 );
+                                        return ttNewline;
+                                }
+                        }
+                        
+                        j += 2;
+                        if( bNonWS )
+                        {
+                                pClient->seek( j );
+                                return ttString;
+                        }
+                }
+                else
+                {
+                        line += s;
+                        bNonWS = true;
+                }
+        }
+
+        return ttOutOfData;
+}
+
+bool Bu::ProtocolHttp::isWS( char buf )
+{
+        return (buf == ' ' || buf == '\t');
+}
+
+bool Bu::ProtocolHttp::isSeperator( char buf )
+{
+        return (buf == '(' || buf == ')' || buf == '<' || buf == '>' ||
+                        buf == '@' || buf == ',' || buf == ';' || buf == ':' ||
+                        buf == '\\' || buf == '\"' || buf == '/' || buf == '[' ||
+                        buf == ']' || buf == '?' || buf == '=' || buf == '{' ||
+                        buf == '}' );
+}
+
diff --git a/src/protocolhttp.h b/src/protocolhttp.h
new file mode 100644
index 0000000..e10cb23
--- /dev/null
+++ b/src/protocolhttp.h
@@ -0,0 +1,63 @@
+#ifndef BU_PROTOCOL_HTTP_H
+#define BU_PROTOCOL_HTTP_H
+
+#include <stdint.h>
+#include <sys/types.h>
+
+#include "bu/protocol.h"
+#include "bu/client.h"
+#include "bu/fstring.h"
+
+namespace Bu
+{
+        /**
+         *
+         */
+        class ProtocolHttp : public Protocol
+        {
+        public: /* Types */
+                typedef Bu::List<Bu::FString> TokenList;
+
+        public: /* Interface */
+                ProtocolHttp();
+                virtual ~ProtocolHttp();
+
+                virtual void onNewConnection( Bu::Client *pClient );
+                virtual void onNewData( Bu::Client *pClient );
+        
+        private:
+                enum TokenType
+                {
+                        ttOutOfData,
+                        ttString,
+                        ttNewline,
+                        ttDoubleNewline,
+                        ttSeperator
+                };
+                /**
+                 * Read an HTTP line, this is up to the first CRLF that isn't followed
+                 * by a continuation character, converting it to one line as it reads.
+                 *@param line All data read will be appended to line, even if no
+                 * end-of-line is read.
+                 *@returns True if an end-of-line is read and the line should be
+                 * processed, false if the end-of-line has not been reached, and more
+                 * data needs to be read before this operation can continue.
+                 */
+                TokenType getToken( Bu::FString &line );
+                bool isWS( char buf );
+                bool isSeperator( char buf );
+
+        private: /* state */
+                Bu::Client *pClient;
+                TokenList lTokens;
+
+                int iState;
+
+                Bu::FString sMethod;
+                Bu::FString sPath;
+                int iMajor;
+                int iMinor;
+        };
+}
+
+#endif
diff --git a/src/server.cpp b/src/server.cpp
index 53b4301..29d4822 100644
--- a/src/server.cpp
+++ b/src/server.cpp
@@ -74,12 +74,26 @@ void Bu::Server::scan()
                 }
         }
 
+        Bu::List<int> lDelete;
         // 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();
+                if( (*i)->wantsDisconnect() )
+                {
+                        lDelete.append( i.getKey() );
+                }
+        }
+
+        for( Bu::List<int>::iterator i = lDelete.begin(); i != lDelete.end(); i++ )
+        {
+                Client *pClient = hClients.get( *i );
+                onClosedConnection( pClient );
+                pClient->close();
+                hClients.erase( *i );
+                FD_CLR( *i, &fdActive );
         }
 }