Telnet.cpp

   1 #include <iostream>
   2 #include <sys/types.h>
   3 #include <sys/socket.h>
   4 #include <string.h>
   5 #include <errno.h>
   6 #include <sys/select.h>
   7 #include "Telnet.hpp"
   8 #include "Exceptions.hpp"
   9 #include "Log.hpp"
  10
  11 static const char CRLF[] = { 13, 10, 0 };
  12 static const char IAC[] = { 255, 0 };
  13
  14 Telnet::Telnet( int sock )
  15         : m_sock( sock )
  16 {
  17 }
  18
  19 Telnet::~Telnet()
  20 {
  21 }
  22
  23 TelnetPtr Telnet::Create( int sock )
  24 {
  25         TelnetPtr ret( new Telnet( sock ) );
  26         ret->m_this = ret;
  27         ret->m_cmd.reset( new TelnetCommand( ret ) );
  28
  29         return ret;
  30 }
  31
  32 bool Telnet::Read()
  33 {
  34         std::string buf;
  35
  36         // Read all that's waiting on the socket
  37         for(;;)
  38         {
  39                 char tmpBuf[BufSize];
  40
  41                 fd_set fd;
  42                 FD_ZERO( &fd );
  43                 FD_SET( m_sock, &fd );
  44                 timeval tv;
  45                 tv.tv_sec = 0;
  46                 tv.tv_usec = 0;
  47                 select( m_sock + 1, &fd, NULL, NULL, &tv );
  48                 if( !FD_ISSET( m_sock, &fd ) )
  49                 {
  50                         break;
  51                 }
  52
  53                 int size = recv( m_sock, tmpBuf, BufSize, 0 );
  54
  55                 if( size == -1 )
  56                 {
  57                         throw SessionErrorException;
  58                 }
  59                 else if( size == 0 )
  60                 {
  61                         throw ConnectionTerminatedException;
  62                 }
  63
  64                 buf.append( tmpBuf, size );
  65         }
  66
  67         // Parse telnet commands
  68         for( unsigned int i=0; i<buf.size(); i++ )
  69         {
  70                 if( m_cmd->ParsingCommand() || (unsigned char)buf[i] == 255 )
  71                 {
  72                         if( !m_cmd->Parse( buf[i] ) )
  73                         {
  74                                 throw SessionErrorException;
  75                         }
  76                 }
  77                 else
  78                 {
  79                         m_readBuf += buf[i];
  80                 }
  81         }
  82
  83         return m_readBuf.find( CRLF ) != std::string::npos;
  84 }
  85
  86 void Telnet::Write( const std::string& msg )
  87 {
  88 #ifdef DEBUG
  89         g_log->Print( "> " + msg );
  90 #endif
  91
  92         std::string buf;
  93         for( unsigned int i=0; i<msg.size(); i++ )
  94         {
  95                 buf += msg[i];
  96
  97                 if( (unsigned char)msg[i] == 255 )
  98                 {
  99                         buf.append( IAC );
 100                 }
 101         }
 102         buf.append( CRLF );
 103
 104         unsigned int pos = 0;
 105         char *ptr = (char*)buf.c_str();
 106
 107         while( pos != buf.size() )
 108         {
 109                 int size = send( m_sock, ptr, buf.size() - pos, 0 );
 110
 111                 if( size == -1 )
 112                 {
 113                         throw SessionErrorException;
 114                 }
 115                 else if( size == 0 )
 116                 {
 117                         throw ConnectionTerminatedException;
 118                 }
 119
 120                 pos += size;
 121                 ptr += size;
 122         }
 123 }
 124
 125 std::string Telnet::GetBuf()
 126 {
 127         std::string ret;
 128
 129         unsigned int pos = m_readBuf.find( CRLF );
 130         if( pos == std::string::npos )
 131         {
 132                 throw SessionErrorException;
 133         }
 134
 135         ret = m_readBuf.substr( 0, pos );
 136
 137         m_readBuf.erase( 0, pos + 2 );
 138
 139 #ifdef DEBUG
 140         g_log->Print( "< " + ret );
 141 #endif
 142
 143         return ret;
 144 }
 145
 146 void Telnet::EraseCharacter()
 147 {
 148         if( m_readBuf.size() > 0 )
 149         {
 150                 m_readBuf.erase( m_readBuf.end() - 1 );
 151         }
 152 }
 153
 154 void Telnet::EraseLine()
 155 {
 156         throw SessionErrorException;
 157 }