Session.cpp

   1 #include <iostream>
   2 #include <string.h>
   3 #include <errno.h>
   4 #include <fcntl.h>
   5 #include "Session.hpp"
   6 #include "SessionController.hpp"
   7 #include "String.hpp"
   8 #include "Exceptions.hpp"
   9
  10 int Session::m_counter = 0;
  11
  12 Session::Session( int controlSock, const SessionControllerPtr& sessionController, const AuthPtr& auth )
  13         : m_control( new Telnet( controlSock ) )
  14         , m_controlSock( controlSock )
  15         , m_id( m_counter++ )
  16         , m_state( S_GREETING )
  17         , m_sessionController( sessionController )
  18         , m_auth( auth )
  19 {
  20         std::cout << "[Session] Initializing session " << m_id << std::endl;
  21
  22         // Set socket to non-blocking
  23         if( fcntl( m_controlSock, F_SETFL, O_NONBLOCK ) == -1 )
  24         {
  25                 throw strerror( errno );
  26         }
  27 }
  28
  29 Session::~Session()
  30 {
  31         if( m_controlSock != 0 )
  32         {
  33                 std::cout << "[Session] Closing control socket " << m_id << std::endl;
  34                 close( m_controlSock );
  35         }
  36 }
  37
  38 SessionPtr Session::Create( int controlSock, const SessionControllerPtr& sessionController, const AuthPtr& auth )
  39 {
  40         SessionPtr ret( new Session( controlSock, sessionController, auth ) );
  41         ret->m_this = ret;
  42
  43         return ret;
  44 }
  45
  46 void Session::Tick()
  47 {
  48         try
  49         {
  50                 try
  51                 {
  52                         switch( m_state )
  53                         {
  54                         case S_GREETING:
  55                                 SendGreeting();
  56                                 m_state = S_LOGIN;
  57                                 break;
  58
  59                         case S_LOGIN:
  60                                 if( AwaitLogin() )
  61                                 {
  62                                         m_state = S_PASSWORD;
  63                                 }
  64                                 break;
  65
  66                         case S_PASSWORD:
  67                         {
  68                                 PassState state = AwaitPassword();
  69
  70                                 if( state == PS_LOGGEDIN )
  71                                 {
  72                                         m_state = S_READY;
  73                                 }
  74                                 else if( state == PS_BADPASS )
  75                                 {
  76                                         m_state = S_LOGIN;
  77                                 }
  78                                 break;
  79                         }
  80
  81                         case S_READY:
  82                                 AwaitReady();
  83                                 break;
  84
  85                         default:
  86                                 break;
  87                         }
  88                 }
  89                 catch( SyntaxError& e )
  90                 {
  91                         SendSyntaxError();
  92                 }
  93                 catch( QuitRequested& e )
  94                 {
  95                         m_control->Write( "221 Bye" );
  96                         Remove();
  97                 }
  98         }
  99         catch( ConnectionTerminated& e )
 100         {
 101                 std::cout << "[Session] Connection " << m_id << " terminated\n";
 102                 Remove();
 103         }
 104 }
 105
 106 void Session::Remove()
 107 {
 108         SessionControllerPtr sessionController = m_sessionController.lock();
 109
 110         if( !sessionController )
 111         {
 112                 throw "Session lost SessionController";
 113         }
 114
 115         sessionController->Remove( m_this.lock() );
 116 }
 117
 118 void Session::SendGreeting()
 119 {
 120         m_control->Write( "220 Dumb FTP Server ready" );
 121 }
 122
 123 void Session::SendSyntaxError()
 124 {
 125         m_control->Write( "500 Syntax error" );
 126 }
 127
 128 void Session::SendNotLoggedIn()
 129 {
 130         m_control->Write( "530 Not logged in" );
 131 }
 132
 133 bool Session::AwaitLogin()
 134 {
 135         if( m_control->Read() )
 136         {
 137                 Command cmd = GetCommand();
 138
 139                 if( cmd[0] == "USER" )
 140                 {
 141                         if( cmd.size() != 2 )
 142                         {
 143                                 SendSyntaxError();
 144                                 return false;
 145                         }
 146
 147                         if( m_auth->Login( cmd[1] ) )
 148                         {
 149                                 m_control->Write( "331 Need password" );
 150                                 m_user = cmd[1];
 151                                 return true;
 152                         }
 153                         else
 154                         {
 155                                 SendNotLoggedIn();
 156                                 return false;
 157                         }
 158                 }
 159                 else if( cmd[0] == "QUIT" )
 160                 {
 161                         throw QuitRequestedException;
 162                 }
 163                 else
 164                 {
 165                         SendNotLoggedIn();
 166                 }
 167         }
 168
 169         return false;
 170 }
 171
 172 Session::PassState Session::AwaitPassword()
 173 {
 174         if( m_control->Read() )
 175         {
 176                 Command cmd = GetCommand();
 177
 178                 if( cmd[0] == "PASS" )
 179                 {
 180                         if( cmd.size() != 2 )
 181                         {
 182                                 SendSyntaxError();
 183                                 return PS_BADPASS;
 184                         }
 185
 186                         if( m_auth->Password( cmd[1] ) )
 187                         {
 188                                 m_control->Write( "230 Logged in" );
 189                                 return PS_LOGGEDIN;
 190                         }
 191                         else
 192                         {
 193                                 SendNotLoggedIn();
 194                                 return PS_BADPASS;
 195                         }
 196                 }
 197                 else if( cmd[0] == "QUIT" )
 198                 {
 199                         throw QuitRequestedException;
 200                 }
 201                 else
 202                 {
 203                         SendNotLoggedIn();
 204                         return PS_BADPASS;
 205                 }
 206         }
 207
 208         return PS_NONE;
 209 }
 210
 211 void Session::AwaitReady()
 212 {
 213         if( m_control->Read() )
 214         {
 215                 Command cmd = GetCommand();
 216
 217                 if( cmd[0] == "QUIT" )
 218                 {
 219                         throw QuitRequestedException;
 220                 }
 221                 else if( cmd[0] == "NOOP" )
 222                 {
 223                         m_control->Write( "200 OK" );
 224                 }
 225                 else if( cmd[0] == "MODE" )
 226                 {
 227                         HandleMode( cmd );
 228                 }
 229                 else if( cmd[0] == "TYPE" )
 230                 {
 231                         HandleType( cmd );
 232                 }
 233                 else if( cmd[0] == "STRU" )
 234                 {
 235                         HandleStru( cmd );
 236                 }
 237                 else
 238                 {
 239                         throw SyntaxErrorException;
 240                 }
 241         }
 242 }
 243
 244 void Session::HandleMode( const Command& cmd )
 245 {
 246         if( cmd.size() != 2 )
 247         {
 248                 throw SyntaxErrorException;
 249         }
 250
 251         std::string param = cmd[1];
 252         ToUpper( param );
 253
 254         if( param == "S" )
 255         {
 256                 m_control->Write( "200 OK" );
 257         }
 258         else if( param == "B" || param == "C" )
 259         {
 260                 m_control->Write( "504 Not implemented" );
 261         }
 262         else
 263         {
 264                 throw SyntaxErrorException;
 265         }
 266 }
 267
 268 void Session::HandleType( const Command& cmd )
 269 {
 270         if( cmd.size() < 2 || cmd.size() > 3)
 271         {
 272                 throw SyntaxErrorException;
 273         }
 274
 275         std::string param = cmd[1];
 276         ToUpper( param );
 277
 278         if( param == "A" )
 279         {
 280                 if( cmd.size() == 3 )
 281                 {
 282                         std::string param2 = cmd[2];
 283                         ToUpper( param2 );
 284
 285                         if( param2 != "N" )
 286                         {
 287                                 m_control->Write( "504 Not implemented" );
 288                                 return;
 289                         }
 290                 }
 291
 292                 m_control->Write( "200 OK" );
 293         }
 294         else if( param == "E" || param == "I" || param == "L" )
 295         {
 296                 m_control->Write( "504 Not implemented" );
 297         }
 298         else
 299         {
 300                 throw SyntaxErrorException;
 301         }
 302 }
 303
 304 void Session::HandleStru( const Command& cmd )
 305 {
 306         if( cmd.size() != 2 )
 307         {
 308                 throw SyntaxErrorException;
 309         }
 310
 311         std::string param = cmd[1];
 312         ToUpper( param );
 313
 314         if( param == "F" )
 315         {
 316                 m_control->Write( "200 OK" );
 317         }
 318         else if( param == "R" )
 319         {
 320                 throw "STRU R not implemented";
 321         }
 322         else if( param == "P" )
 323         {
 324                 m_control->Write( "504 Not implemented" );
 325         }
 326         else
 327         {
 328                 throw SyntaxErrorException;
 329         }
 330 }