Telnet.cpp

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