Fixed an interesting ideosyncacy in Bu::Hash in a safe way, I should try to do

this with the Bu::Archive next.  Basically, there's one generic template
function that will convert anything that can safely cast to a uint32_t and that
supports direct comparisson, and doesn't have it's own override already to be
a Hash key, such as char, uint8_t, uint64_t, etc.

The Telnet protocol handler does everything I need it too for now, next up for
it is escape sequence handling, it would be nice to make this general too, by
using the termcap database or something, but there is an ANSI/ISO standard now,
I may just go ahead and use that.  Also, it looks like it'd be pretty easy to
make the canonical mode editing functions be pluggable to facilitate different
types of editing, but that can be done down the road as well.

6 files changed, 733 insertions, 78 deletions

diff --git a/src/hash.cpp b/src/hash.cpp
index a207c29..9b8a1c1 100644
--- a/src/hash.cpp
+++ b/src/hash.cpp
@@ -2,26 +2,6 @@
 
 namespace Bu { subExceptionDef( HashException ) }
 
-template<> uint32_t Bu::__calcHashCode<int>( const int &k )
-{
-        return k;
-}
-
-template<> bool Bu::__cmpHashKeys<int>( const int &a, const int &b )
-{
-        return a == b;
-}
-
-template<> uint32_t Bu::__calcHashCode<unsigned int>( const unsigned int &k )
-{
-        return k;
-}
-
-template<> bool Bu::__cmpHashKeys<unsigned int>( const unsigned int &a, const unsigned int &b )
-{
-        return a == b;
-}
-
 template<>
 uint32_t Bu::__calcHashCode<const char *>( const char * const &k )
 {
diff --git a/src/hash.h b/src/hash.h
index 62b19c9..be57786 100644
--- a/src/hash.h
+++ b/src/hash.h
@@ -1008,12 +1008,16 @@ namespace Bu
                 challoc ca;
                 sizecalc szCalc;
         };
+        
+        template<typename T> uint32_t __calcHashCode( const T &k )
+        {
+                return static_cast<uint32_t>( k );
+        }
 
-        template<> uint32_t __calcHashCode<int>( const int &k );
-        template<> bool __cmpHashKeys<int>( const int &a, const int &b );
-
-        template<> uint32_t __calcHashCode<unsigned int>( const unsigned int &k );
-        template<> bool __cmpHashKeys<unsigned int>( const unsigned int &a, const unsigned int &b );
+        template<typename T> bool __cmpHashKeys( const T &a, const T &b )
+        {
+                return (a == b);
+        }
 
         template<> uint32_t __calcHashCode<const char *>( const char * const &k );
         template<> bool __cmpHashKeys<const char *>( const char * const &a, const char * const &b );
diff --git a/src/protocolhttp.h b/src/protocolhttp.h
index e2612f5..85510e3 100644
--- a/src/protocolhttp.h
+++ b/src/protocolhttp.h
@@ -11,7 +11,14 @@
 namespace Bu
 {
         /**
-         *
+         * An HTTP Protocol handler.  Yes, I know that HTTP stands for Hyper Text
+         * Transfer Protocol, and that the Protocol part is redundant, but in this
+         * case the word Protocol is refering to the Libbu++ construct Bu::Protocol,
+         * and not a means of encoding conversations.  Anyway, this class represents
+         * a general HTTP server processor.  Every time a request comes in it calls
+         * the onRequest function in a subclass with the method and URI that were
+         * requested.  The sub-class can then do whatever it needs to to send back
+         * a response.
          */
         class ProtocolHttp : public Protocol
         {
diff --git a/src/protocoltelnet.cpp b/src/protocoltelnet.cpp
index b0209db..e4fc926 100644
--- a/src/protocoltelnet.cpp
+++ b/src/protocoltelnet.cpp
@@ -1,30 +1,69 @@
 #include "bu/protocoltelnet.h"
 #include "bu/client.h"
 
-#define CODE_SE         '\xf0'  /**< End of subnegotiation params. */
-#define CODE_NOP        '\xf1'  /**< No operation (keep-alive). */
-#define CODE_DM         '\xf2'  /**< Datastream side of a Synch. */
-#define CODE_BRK        '\xf3'  /**< Break character. */
-#define CODE_IP         '\xf4' /**< Interrupt Process character. */
-#define CODE_AO         '\xf5' /**< Abort Output character. */
-#define CODE_AYT        '\xf6' /**< Are You There? character. */
-#define CODE_EC         '\xf7' /**< Erase Character character. */
-#define CODE_EL         '\xf8'  /**< Erase Line character. */
-#define CODE_GA         '\xf9' /**< Go Ahead signal. */
-#define CODE_SB         '\xfa'  /**< Begin subnegotiation options. */
-#define CODE_WILL       '\xfb'  /**< Desire to do something. */
-#define CODE_WONT       '\xfc'  /**< Refuse to perform. */
-#define CODE_DO         '\xfd'  /**< Request option. */
-#define CODE_DONT       '\xfe'  /**< Demand a stop. */
-
-#define CODE_IAC        '\xff'  /**< Interpret-As-Command. */
-
-#define OPT_BINARY      '\x00'  /**< Binary mode (file transfers?). */
-#define OPT_ECHO        '\x01'  /**< (local) Echo mode. */
+/* We apparently at least want defs for the lower 13, not sure we care about
+ * the rest of the chars, maybe escape.
+ */
+#define CH_NUL          '\x00'  /* NUL */
+#define CH_SOH          '\x01'  /* Start Of Heading */
+#define CH_STX          '\x02'  /* Start of Text */
+#define CH_ETX          '\x03'  /* End of Text */
+#define CH_EOT          '\x04'  /* End of transmission */
+#define CH_ENQ          '\x05'  /* Enquiery */
+#define CH_ACK          '\x06'  /* Acknowledge */
+#define CH_BEL          '\x07'  /* Bell */
+#define CH_BS           '\x08'  /* Backspace */
+#define CH_TAB          '\x09'  /* Horizontal Tab */
+#define CH_LF           '\x0A'  /* NL Line feed, new line */
+#define CH_VT           '\x0B'  /* Vertical Tab */
+#define CH_FF           '\x0C'  /* Form feed, new page */
+#define CH_CR           '\x0D'  /* Carriage return */
+#define CH_ESC          '\x1B'  /* Escape */
+#define CH_DEL          '\x7F'  /* Delete */
+
+#define CODE_SE         '\xf0'  /* End of subnegotiation params. */
+#define CODE_NOP        '\xf1'  /* No operation (keep-alive). */
+#define CODE_DM         '\xf2'  /* Datastream side of a Synch. */
+#define CODE_BRK        '\xf3'  /* Break character. */
+#define CODE_IP         '\xf4'  /* Interrupt Process character. */
+#define CODE_AO         '\xf5'  /* Abort Output character. */
+#define CODE_AYT        '\xf6'  /* Are You There? character. */
+#define CODE_EC         '\xf7'  /* Erase Character character. */
+#define CODE_EL         '\xf8'  /* Erase Line character. */
+#define CODE_GA         '\xf9'  /* Go Ahead signal. */
+#define CODE_SB         '\xfa'  /* Begin subnegotiation options. */
+#define CODE_WILL       '\xfb'  /* Desire to do something. */
+#define CODE_WONT       '\xfc'  /* Refuse to perform. */
+#define CODE_DO         '\xfd'  /* Request option. */
+#define CODE_DONT       '\xfe'  /* Demand a stop. */
+
+#define CODE_IAC        '\xff'  /* Interpret-As-Command. */
+
+#define OPT_BINARY      '\x00'  /* Binary mode (file transfers?). */
+#define OPT_ECHO        '\x01'  /* (local) Echo mode. */
+#define OPT_SUPGA       '\x03'  /* Suppress Go Ahead signals. */
+#define OPT_STATUS      '\x05'  /* Allow status messages. */
+#define OPT_TIMING      '\x06'  /* Place a timing mark in the code. */
+#define OPT_EXASCII     '\x11'  /* Extended ASCII. */
+#define OPT_LOGOUT      '\x12'  /* Logout. */
+#define OPT_TTYPE       '\x18'  /* Terminal Type. */
+#define OPT_NAWS        '\x1f'  /* Negotiate about window size. */
+#define OPT_TSPEED      '\x20'  /* Terminal Speed. */
+#define OPT_NEWENV      '\x27'  /* New Environment Option. */
+#define OPT_EXOPL       '\xff'  /* Can we, will we, handle extended options. */
+
+#ifndef __TELNET_DEBUG
+# define printCode( a ) (void)0
+# define printOpt( a ) (void)0
+#endif
 
 Bu::ProtocolTelnet::ProtocolTelnet() :
         oBinary(        *this, OPT_BINARY ),
-        oEcho(          *this, OPT_ECHO )
+        oEcho(          *this, OPT_ECHO ),
+        oNAWS(          *this, OPT_NAWS ),
+        oSuppressGA(*this, OPT_SUPGA ),
+        bCanonical( true ),
+        bSubOpt( false )
 {
 }
 
@@ -34,13 +73,410 @@ Bu::ProtocolTelnet::~ProtocolTelnet()
 
 void Bu::ProtocolTelnet::onNewConnection( Bu::Client *pClient )
 {
+        this->pClient = pClient;
 }
 
 void Bu::ProtocolTelnet::onNewData( Bu::Client *pClient )
 {
+        char bc;
+        int iLeft;
+        while( (iLeft = pClient->getInputSize()) )
+        {
+                if( bSubOpt )
+                {
+                        pClient->peek( &bc, 1 );
+                        if( bc == CODE_IAC )
+                        {
+                                if( iLeft <= 1 ) return;
+                                char bc2;
+                                printCode( CODE_IAC );
+                                pClient->peek( &bc2, 1, 1 );
+                                printCode( bc2 );
+                                if( bc2 == CODE_SE )
+                                {
+                                        bSubOpt = false;
+                                        onSubOpt();
+                                }
+                                else if( bc2 == CODE_IAC )
+                                {
+                                        sSubBuf += CODE_IAC;
+                                }
+                                else
+                                {
+                                        // Error of some sort.
+                                }
+                                pClient->seek( 1 );
+                        }
+                        else
+                        {
+                                sSubBuf += bc;
+                        }
+                        pClient->seek( 1 );
+                }
+                else
+                {
+                        pClient->peek( &bc, 1 );
+                        if( bc == CODE_IAC )
+                        {
+                                if( iLeft <= 1 ) return;
+                                char bc2;
+                                pClient->peek( &bc2, 1, 1 );
+                                printCode( bc );
+                                printCode( bc2 );
+
+                                switch( bc2 )
+                                {
+                                        case CODE_WILL:
+                                                if( iLeft <= 2 ) return;
+                                                {
+                                                        char bc3;
+                                                        pClient->peek( &bc3, 1, 2 );
+                                                        pClient->seek( 1 );
+                                                        printOpt( bc3 );
+                                                        onWill( bc3 );
+                                                }
+                                                break;
+
+                                        case CODE_WONT:
+                                                if( iLeft <= 2 ) return;
+                                                {
+                                                        char bc3;
+                                                        pClient->peek( &bc3, 1, 2 );
+                                                        pClient->seek( 1 );
+                                                        printOpt( bc3 );
+                                                        onWont( bc3 );
+                                                }
+                                                break;
+
+                                        case CODE_DO:
+                                                if( iLeft <= 2 ) return;
+                                                {
+                                                        char bc3;
+                                                        pClient->peek( &bc3, 1, 2 );
+                                                        pClient->seek( 1 );
+                                                        printOpt( bc3 );
+                                                        onDo( bc3 );
+                                                }
+                                                break;
+
+                                        case CODE_DONT:
+                                                if( iLeft <= 2 ) return;
+                                                {
+                                                        char bc3;
+                                                        pClient->peek( &bc3, 1, 2 );
+                                                        pClient->seek( 1 );
+                                                        printOpt( bc3 );
+                                                        onDont( bc3 );
+                                                }
+                                                break;
+
+                                        case CODE_SB:
+                                                if( iLeft <= 2 ) return;
+                                                {
+                                                        pClient->peek( &cSubOpt, 1, 2 );
+                                                        pClient->seek( 1 );
+                                                        printOpt( cSubOpt );
+                                                        bSubOpt = true;
+                                                }
+                                                break;
+
+                                        case CODE_IAC:
+                                                sDataBuf += CODE_IAC;
+                                                printCode( CODE_IAC );
+                                                break;
+                                }
+                                pClient->seek( 1 );
+#ifdef __TELNET_DEBUG
+                                printf("\n");
+#endif
+                        }
+                        else if( bc == CODE_SB )
+                        {
+                        }
+                        else
+                        {
+                                // This is where control code handling goes
+                                // Also, possibly, character code conversion, although I'm not
+                                // sure that really matters anymore, go ASCII/UTF-8
+                                if( bCanonical )
+                                {
+                                        if( bc < 0x20 || bc >= CH_DEL )
+                                        {
+                                                if( bc == CH_CR )
+                                                {
+                                                        if( iLeft <= 1 ) return;
+                                                        char bc2;
+                                                        pClient->peek( &bc2, 1, 1 );
+                                                        if( bc2 == CH_NUL || bc2 == CH_LF )
+                                                        {
+                                                                onCtlChar( bc );
+                                                                gotLine( sDataBuf );
+                                                                sDataBuf.clear();
+                                                        }
+                                                        pClient->seek( 1 );
+                                                }
+                                                else
+                                                {
+                                                        onCtlChar( bc );
+                                                }
+                                        }
+                                        else
+                                        {
+                                                sDataBuf += bc;
+                                                if( oEcho.isLocalSet() )
+                                                {
+                                                        pClient->write( &bc, 1 );
+#ifdef __TELNET_DEBUG
+                                                        printf("%c", bc );
+                                                        fflush( stdout );
+#endif
+                                                }
+                                        }
+                                }
+                                else
+                                {
+                                        sDataBuf += bc;
+                                        if( oEcho.isLocalSet() )
+                                        {
+                                                pClient->write( &bc, 1 );
+                                        }
+                                }
+                        }
+                        pClient->seek( 1 );
+                }
+        }
+
+        // It's true, this code will not be executed if we only have half of an
+        // IAC code or multibyte escape sequence or something, but then again, it
+        // shouldn't be called then, and really, shouldn't be, it'll be called soon
+        // enough, when we get the rest of that code.
+        if( !bCanonical )
+        {
+                gotData( sDataBuf );
+        }
+}
+
+void Bu::ProtocolTelnet::setCanonical( bool bCon )
+{
+        bCanonical = bCon;
+}
+
+bool Bu::ProtocolTelnet::isCanonical()
+{
+        return bCanonical;
+}
+
+void Bu::ProtocolTelnet::write( const Bu::FString &sData )
+{
+        pClient->write( sData );
+}
+
+void Bu::ProtocolTelnet::write( char *pData, int iSize )
+{
+        pClient->write( pData, iSize );
+}
+
+void Bu::ProtocolTelnet::write( char cData )
+{
+        pClient->write( &cData, 1 );
+}
+
+void Bu::ProtocolTelnet::onWill( char cCode )
+{
+        try
+        {
+                Option *pOpt = hOpts[cCode];
+                if( pOpt->isRemoteEnabled() )
+                {
+                        pOpt->fOpts |= Option::fRemoteIs;
+                        char buf[3] = { CODE_IAC, CODE_DO, cCode };
+                        pClient->write( buf, 3 );
+                }
+                else
+                {
+                        char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+                        pClient->write( buf, 3 );
+                }
+
+        }
+        catch( Bu::HashException &e )
+        {
+                char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+                pClient->write( buf, 3 );
+        }
+}
+
+void Bu::ProtocolTelnet::onWont( char cCode )
+{
+        try
+        {
+                Option *pOpt = hOpts[cCode];
+
+                pOpt->fOpts &= ~Option::fRemoteIs;
+                char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+                pClient->write( buf, 3 );
+        }
+        catch( Bu::HashException &e )
+        {
+                char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+                pClient->write( buf, 3 );
+        }
+}
+
+void Bu::ProtocolTelnet::onDo( char cCode )
+{
+        try
+        {
+                Option *pOpt = hOpts[cCode];
+                if( pOpt->isLocalEnabled() )
+                {
+                        pOpt->fOpts |= Option::fLocalIs;
+                        char buf[3] = { CODE_IAC, CODE_WILL, cCode };
+                        pClient->write( buf, 3 );
+                }
+                else
+                {
+                        char buf[3] = { CODE_IAC, CODE_WONT, cCode };
+                        pClient->write( buf, 3 );
+                }
+
+        }
+        catch( Bu::HashException &e )
+        {
+                char buf[3] = { CODE_IAC, CODE_WONT, cCode };
+                pClient->write( buf, 3 );
+        }
+}
+
+void Bu::ProtocolTelnet::onDont( char cCode )
+{
+        try
+        {
+                Option *pOpt = hOpts[cCode];
+
+                pOpt->fOpts &= ~Option::fLocalIs;
+                char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+                pClient->write( buf, 3 );
+        }
+        catch( Bu::HashException &e )
+        {
+                char buf[3] = { CODE_IAC, CODE_DONT, cCode };
+                pClient->write( buf, 3 );
+        }
 }
 
+void Bu::ProtocolTelnet::onSubOpt()
+{
+        switch( cSubOpt )
+        {
+                case OPT_NAWS:
+                        {
+                                uint16_t iWidth, iHeight;
+                                ((char *)&iWidth)[1] = sSubBuf[0];
+                                ((char *)&iWidth)[0] = sSubBuf[1];
+                                ((char *)&iHeight)[1] = sSubBuf[2];
+                                ((char *)&iHeight)[0] = sSubBuf[3];
+                                onSubNAWS( iWidth, iHeight );
+                        }
+                        break;
 
+                default:
+                        onSubUnknown( cSubOpt, sSubBuf );
+                        break;
+        }
+
+        sSubBuf.clear();
+}
+
+void Bu::ProtocolTelnet::onCtlChar( char cChr )
+{
+#ifdef __TELNET_DEBUG 
+        switch( cChr )
+        {
+                case CH_NUL:    printf("NUL "); break;
+                case CH_SOH:    printf("SOH "); break;
+                case CH_STX:    printf("STX "); break;
+                case CH_ETX:    printf("ETX "); break;
+                case CH_EOT:    printf("EOT "); break;
+                case CH_ENQ:    printf("ENQ "); break;
+                case CH_ACK:    printf("ACK "); break;
+                case CH_BEL:    printf("BEL "); break;
+                case CH_BS:             printf("BS ");  break;
+                case CH_TAB:    printf("TAB "); break;
+                case CH_LF:             printf("LF ");  break;
+                case CH_VT:             printf("VT ");  break;
+                case CH_FF:             printf("FF ");  break;
+                case CH_CR:             printf("CR ");  break;
+                case CH_ESC:    printf("ESC "); break;
+                case CH_DEL:    printf("DEL "); break;
+                default:                printf("!![%02x] ", cChr );     break;
+        }
+        fflush( stdout );
+#endif
+
+        switch( cChr )
+        {
+                case CH_DEL:
+                        {
+                                if( sDataBuf.getSize() > 0 )
+                                {
+                                        sDataBuf.resize( sDataBuf.getSize()-1 );
+                                        char buf[3] = { CH_BS, ' ', CH_BS };
+                                        pClient->write( buf, 3 );
+                                }
+                        }
+                        break;
+
+        }
+}
+
+#ifdef __TELNET_DEBUG
+void Bu::ProtocolTelnet::printCode( char cCode )
+{
+        switch( cCode )
+        {
+                case CODE_SE:           printf("SE ");          break;
+                case CODE_NOP:          printf("NOP ");         break;
+                case CODE_DM:           printf("DM ");          break;
+                case CODE_BRK:          printf("BRK ");         break;
+                case CODE_IP:           printf("IP ");          break;
+                case CODE_AO:           printf("AO ");          break;
+                case CODE_AYT:          printf("AYT ");         break;
+                case CODE_EC:           printf("EC ");          break;
+                case CODE_EL:           printf("EL ");          break;
+                case CODE_GA:           printf("GA ");          break;
+                case CODE_SB:           printf("SB ");          break;
+                case CODE_WILL:         printf("WILL ");        break;
+                case CODE_WONT:         printf("WONT ");        break;
+                case CODE_DO:           printf("DO ");          break;
+                case CODE_DONT:         printf("DONT ");        break;
+                case CODE_IAC:          printf("IAC ");         break;
+                default:                        printf("??%02x ", cCode );      break;
+        }
+        fflush( stdout );
+}
+
+void Bu::ProtocolTelnet::printOpt( char cOpt )
+{
+        switch( cOpt )
+        {
+                case OPT_BINARY:        printf("BINARY ");      break;
+                case OPT_ECHO:          printf("ECHO ");        break;
+                case OPT_SUPGA:         printf("SUPGA ");       break;
+                case OPT_STATUS:        printf("STATUS ");      break;
+                case OPT_TIMING:        printf("TIMING ");      break;
+                case OPT_EXASCII:       printf("EXASCII ");     break;
+                case OPT_LOGOUT:        printf("LOGOUT ");      break;
+                case OPT_TTYPE:         printf("TTYPE ");       break;
+                case OPT_NAWS:          printf("NAWS ");        break;
+                case OPT_TSPEED:        printf("TSPEED ");      break;
+                case OPT_NEWENV:        printf("NEWENV ");      break;
+                case OPT_EXOPL:         printf("EXOPL ");       break;
+                default:                        printf("??%02x ", cOpt);        break;
+        }
+        fflush( stdout );
+}
+#endif
 
 Bu::ProtocolTelnet::Option::Option( Bu::ProtocolTelnet &rPT, char cCode ) :
         rPT( rPT ),
@@ -68,19 +504,31 @@ void Bu::ProtocolTelnet::Option::localSet( bool bSet )
 {
         if( bSet == (bool)(fOpts&fLocalIs) ) return;
 
-        char buf[2];
+        char buf[3] = { CODE_IAC, 0, cCode };
 
         if( bSet )
         {
-                buf[0] = CODE_WILL;
-                buf[1] = cCode;
-                rPT.pClient->write( buf, 2 );
+                buf[1] = CODE_WILL;
+                rPT.pClient->write( buf, 3 );
+#ifdef __TELNET_DEBUG
+                printf("<= ");
+                rPT.printCode( buf[0] );
+                rPT.printCode( buf[1] );
+                rPT.printOpt( buf[2] );
+                printf("\n");
+#endif
         }
         else
         {
-                buf[0] = CODE_WONT;
-                buf[1] = cCode;
-                rPT.pClient->write( buf, 2 );
+                buf[1] = CODE_WONT;
+                rPT.pClient->write( buf, 3 );
+#ifdef __TELNET_DEBUG
+                printf("<= ");
+                rPT.printCode( buf[0] );
+                rPT.printCode( buf[1] );
+                rPT.printOpt( buf[2] );
+                printf("\n");
+#endif
         }
 }
 
@@ -101,21 +549,33 @@ void Bu::ProtocolTelnet::Option::remoteEnable( bool bSet )
 
 void Bu::ProtocolTelnet::Option::remoteSet( bool bSet )
 {
-        if( bSet == (bool)(fOpts&fRemoteIs) ) return;
+        //if( bSet == (bool)(fOpts&fRemoteIs) ) return;
 
-        char buf[2];
+        char buf[3] = { CODE_IAC, 0, cCode };
 
         if( bSet )
         {
-                buf[0] = CODE_DO;
-                buf[1] = cCode;
-                rPT.pClient->write( buf, 2 );
+                buf[1] = CODE_DO;
+                rPT.pClient->write( buf, 3 );
+#ifdef __TELNET_DEBUG
+                printf("<= ");
+                rPT.printCode( buf[0] );
+                rPT.printCode( buf[1] );
+                rPT.printOpt( buf[2] );
+                printf("\n");
+#endif
         }
         else
         {
-                buf[0] = CODE_DONT;
-                buf[1] = cCode;
-                rPT.pClient->write( buf, 2 );
+                buf[1] = CODE_DONT;
+                rPT.pClient->write( buf, 3 );
+#ifdef __TELNET_DEBUG
+                printf("<= ");
+                rPT.printCode( buf[0] );
+                rPT.printCode( buf[1] );
+                rPT.printOpt( buf[2] );
+                printf("\n");
+#endif
         }
 }
 
diff --git a/src/protocoltelnet.h b/src/protocoltelnet.h
index 3a606b5..f773f1e 100644
--- a/src/protocoltelnet.h
+++ b/src/protocoltelnet.h
@@ -3,35 +3,131 @@
 
 #include "bu/protocol.h"
 #include "bu/hash.h"
+#include "bu/fstring.h"
+
+// #define __TELNET_DEBUG
 
 namespace Bu
 {
+        /**
+         * Telnet Protocol handler.  This attempts to provide useful and general
+         * support for most of the most commonly used Telnet extensions in a simple
+         * and easy to use way.  The Option variables control the settings that can
+         * be used on the line, and control which virtual "callbacks" will be called
+         * when different events happen.
+         *
+         * To setup initial values and to disable any options you wish override the
+         * onNewConnection function in your own class, like this:
+         *@code
+         class MyTelnet : public Bu::ProtocolTelnet
+         {
+         public:
+                ...
+
+                virtual void onNewConnection( class Bu::Client *pClient )
+                {
+                        // Call the parent class' onNewConnection to get everything all
+                        // set up.
+                        Bu::ProtocolTelnet::onNewConnection( pClient );
+
+                        // These functions disable the option to send files via telnet,
+                        // disabling the remote option means that we won't accept this
+                        // option (binary data being sent to us) from the client.
+                        //
+                        // Disabling the local option means that the client cannot ask us
+                        // to send them binary data.
+                        oBinary.enableRemote( false );
+                        oBinary.enableLocal( false );
+
+                        // This requests that the client send us window size updates
+                        // whenever the size of their window changes, and an initial set to
+                        // boot.
+                        //
+                        // To see if this option is set later, try oNAWS.isRemoteSet(), but
+                        // wait a little while, asking immediatly will always return false,
+                        // since the remote side has yet to receive our request.
+                        oNAWS.remoteSet();
+                }
+        }
+         @endcode
+         *
+         */
         class ProtocolTelnet : public Protocol
         {
         public:
                 ProtocolTelnet();
                 virtual ~ProtocolTelnet();
 
+                /**
+                 * If you override this function in a child class, make sure to call
+                 * this version of it as the very first thing that you do, before you
+                 * set any options.  See the example in the class docs.
+                 */
                 virtual void onNewConnection( class Bu::Client *pClient );
+
+                /**
+                 * You should never override this function unless you really, really
+                 * know what you're doing.  If you want to get data after each line
+                 * entered (in canonical mode) or after any data arrives (non canonical
+                 * mode) then override the gotLine and gotData functions, respectively.
+                 */
                 virtual void onNewData( class Bu::Client *pClient );
 
-                enum OptMode
-                {
-                        optOff,
-                        optOn,
-                        optDesire,
-                        optRefuse
-                };
+                /**
+                 * Override this function to be notified of lines being submitted by
+                 * the client.  This function is only called in canonical mode, after
+                 * all edits are performed on the data.  In this mode weather you use
+                 * the line or not, the data will be cleared from the buffer when this
+                 * function returns, any changes made to the buffer will be destroyed.
+                 */
+                virtual void gotLine( Bu::FString &sLine ){};
 
-                OptMode getLocalOptBinary();
-                void setLocalOptBinary( OptMode eMode );
-                OptMode getRemoteOptBinary();
-                void setRemoteOptBinary( OptMode eMode );
+                /**
+                 * Override this function to be notified of any new data that comes in
+                 * from the client.  This function is only called in non-canonical mode,
+                 * and includes all raw data minus telnet control codes and ansi
+                 * escape sequences.  In this mode control of the buffer is up to the
+                 * child class in this function, the buffer will never be cleared unless
+                 * it happens in this function's override.
+                 */
+                virtual void gotData( Bu::FString &sData ){};
 
-                OptMode getLocalOptEcho();
-                void setLocalOptEcho( OptMode eMode );
-                OptMode getRemoteOptEcho();
-                void setRemoteOptEcho( OptMode eMode );
+                /**
+                 * Using this function to enable or disable canonical mode only affects
+                 * the way the data is processed and which virtual functions are called
+                 * during processing.  It does not affect options set locally or
+                 * remotely.  Setting this to false will enable char-at-a-time mode,
+                 * effectively disabling internal line-editing code.  Characters
+                 * such as backspace that are detected will not be handled and will be
+                 * sent to the user override.  The subclass will also be notified every
+                 * time new data is available, not just whole lines.
+                 *
+                 * When set to true (the default), line editing control codes will be
+                 * interpreted and used, and the subclass will only be notified when
+                 * complete lines are available in the buffer.
+                 */
+                void setCanonical( bool bCon=true );
+                bool isCanonical();
+
+                void write( const Bu::FString &sData );
+                void write( char *pData, int iSize );
+                void write( char cData );
+
+        public:
+                /**
+                 * If you wish to know the current dimensions of the client window,
+                 * override this function, it will be called whenever the size changes.
+                 */
+                virtual void onSubNAWS( uint16_t iWidth, uint16_t iHeight ){};
+
+                /**
+                 * This function is called whenever an unknown sub negotiation option is
+                 * sent over the line.  This doesn't mean that it's malformatted, it
+                 * just means that this class doesn't support that option yet, but you
+                 * can handle it yourself if you'd like.  Feel free to change the
+                 * sSubBuf, it will be cleared as soon as this function returns anyway.
+                 */
+                virtual void onSubUnknown( char cSubOpt, Bu::FString &sSubBuf ){};
 
         private:
                 /**
@@ -75,15 +171,38 @@ namespace Bu
                         char fOpts;
                         char cCode;
                 };
+                friend class Bu::ProtocolTelnet::Option;
 
                 Hash<char, Option *> hOpts;
 
+        public:
                 Option oBinary;
                 Option oEcho;
+                Option oNAWS;
+                Option oSuppressGA;
 
+        private:
+                void onWill( char cCode );
+                void onWont( char cCode );
+                void onDo( char cCode );
+                void onDont( char cCode );
+                void onSubOpt();
+                void onCtlChar( char cChr );
+
+#ifdef __TELNET_DEBUG
+                void printCode( char cCode );
+                void printOpt( char cOpt );
+#endif
+
+        private:
                 Client *pClient;
 
-        friend class Bu::ProtocolTelnet::Option;
+                Bu::FString sDataBuf;   /**< Buffer for regular line data. */
+                Bu::FString sSubBuf;    /**< Buffer for subnegotiation data. */
+                char cSubOpt;   /**< Which suboption are we processing. */
+
+                bool bCanonical;        /**< Are we canonicalizing incoming data? */
+                bool bSubOpt;           /**< Are we processing a suboption right now? */
         };
 }
 
diff --git a/src/tests/telnetsrv.cpp b/src/tests/telnetsrv.cpp
new file mode 100644
index 0000000..39e3217
--- /dev/null
+++ b/src/tests/telnetsrv.cpp
@@ -0,0 +1,85 @@
+#include "bu/server.h"
+#include "bu/protocoltelnet.h"
+#include "bu/client.h"
+
+class MyTelnet : public Bu::ProtocolTelnet
+{
+public:
+        MyTelnet()
+        {
+        }
+
+        virtual ~MyTelnet()
+        {
+        }
+
+        virtual void onNewConnection( Bu::Client *pClient )
+        {
+                Bu::ProtocolTelnet::onNewConnection( pClient );
+
+                //oNAWS.remoteSet();
+                oEcho.localSet();
+                oSuppressGA.remoteSet( true );
+                oSuppressGA.localSet( true );
+                setCanonical();
+        }
+
+        virtual void onSubNAWS( uint16_t iWidth, uint16_t iHeight )
+        {
+                printf("New dim = (%dx%d)\n", iWidth, iHeight );
+        }
+
+        virtual void gotLine( Bu::FString &sLine )
+        {
+                printf("Line: \"%s\"\n", sLine.getStr() );
+                write("\n\r", 2 );
+        }
+
+private:
+
+};
+
+class TelServer : public Bu::Server
+{
+public:
+        TelServer()
+        {
+        }
+
+        virtual ~TelServer()
+        {
+        }
+
+        virtual void onNewConnection( Bu::Client *pClient, int iPort )
+        {
+                printf("New connection.\n");
+
+                pClient->setProtocol( new MyTelnet() );
+        }
+
+        virtual void onClosedConnection( Bu::Client *pClient )
+        {
+                printf("Lost connection.\n");
+
+                delete pClient->getProtocol();
+        }
+
+private:
+
+};
+
+int main( int argc, char *argv[] )
+{
+        TelServer ts;
+        
+        ts.addPort( 4000 );
+        ts.setTimeout( 0, 5000 );
+
+        printf("Initializing server on port: 4000\n");
+
+        for(;;)
+        {
+                ts.scan();
+        }
+}
+