Session.cpp

   1 #include <iostream>
   2 #include <string.h>
   3 #include <unistd.h>
   4 #include <errno.h>
   5 #include <fcntl.h>
   6 #include <netinet/in.h>
   7 #include <arpa/inet.h>
   8 #include <sys/socket.h>
   9 #include <boost/lexical_cast.hpp>
  10 #include "Session.hpp"
  11 #include "SessionController.hpp"
  12 #include "String.hpp"
  13 #include "Exceptions.hpp"
  14 #include "Server.hpp"
  15 #include "Log.hpp"
  16
  17 int Session::m_counter = 0;
  18
  19 Session::Session( int controlSock, const SessionControllerPtr& sessionController, const AuthPtr& auth, const std::string& ip, const ServerWPtr& server )
  20         : m_control( Telnet::Create( controlSock ) )
  21         , m_controlSock( controlSock )
  22         , m_listenSock( 0 )
  23         , m_dataPort( 20 )
  24         , m_id( m_counter++ )
  25         , m_state( S_GREETING )
  26         , m_sessionController( sessionController )
  27         , m_auth( auth )
  28         , m_server( server )
  29         , m_ip( ip )
  30 {
  31         sockaddr_in addr;
  32         socklen_t size = sizeof( sockaddr_in );
  33
  34         if( getpeername( m_controlSock, (sockaddr*)&addr, &size ) == -1 )
  35         {
  36                 g_log->Print( strerror( errno ) );
  37                 throw ServerCrashException;
  38         }
  39
  40         m_dataAddress = inet_ntoa( addr.sin_addr );
  41
  42         g_log->Print( std::string("[Session] Initializing session ") + boost::lexical_cast<std::string>( m_id ) + " for " + m_dataAddress );
  43 }
  44
  45 Session::~Session()
  46 {
  47         if( m_controlSock != 0 )
  48         {
  49                 g_log->Print( std::string("[Session] Closing control socket ") + boost::lexical_cast<std::string>( m_id ) );
  50                 close( m_controlSock );
  51         }
  52
  53         if( m_listenSock != 0 )
  54         {
  55                 close( m_listenSock );
  56         }
  57
  58         // Data (RFile) needs to be freed before Filesystem (RFs) on symbian
  59         m_data.reset();
  60         m_filesystem.reset();
  61 }
  62
  63 SessionPtr Session::Create( int controlSock, const SessionControllerPtr& sessionController, const AuthPtr& auth, const std::string& ip, const ServerWPtr& server )
  64 {
  65         SessionPtr ret( new Session( controlSock, sessionController, auth, ip, server ) );
  66         ret->m_this = ret;
  67
  68         return ret;
  69 }
  70
  71 void Session::Tick()
  72 {
  73         try
  74         {
  75                 try
  76                 {
  77                         switch( m_state )
  78                         {
  79                         case S_GREETING:
  80                                 SendGreeting();
  81                                 m_state = S_LOGIN;
  82                                 break;
  83
  84                         case S_LOGIN:
  85                                 if( AwaitLogin() )
  86                                 {
  87                                         m_state = S_PASSWORD;
  88                                 }
  89                                 break;
  90
  91                         case S_PASSWORD:
  92                         {
  93                                 PassState state = AwaitPassword();
  94
  95                                 if( state == PS_LOGGEDIN )
  96                                 {
  97                                         m_state = S_READY;
  98                                 }
  99                                 else if( state == PS_BADPASS )
 100                                 {
 101                                         m_state = S_LOGIN;
 102                                 }
 103                                 break;
 104                         }
 105
 106                         case S_READY:
 107                                 AwaitReady();
 108                                 break;
 109
 110                         default:
 111                                 break;
 112                         }
 113
 114                         if( m_data )
 115                         {
 116                                 m_data->Tick();
 117                         }
 118                 }
 119                 catch( SyntaxError& e )
 120                 {
 121                         SendSyntaxError();
 122                 }
 123                 catch( QuitRequested& e )
 124                 {
 125                         m_control->Write( "221 Bye" );
 126                         Remove();
 127                 }
 128                 catch( SessionError& e )
 129                 {
 130                         g_log->Print( std::string("[Session] ") + boost::lexical_cast<std::string>( m_id ) + " encountered problems (" + strerror( errno ) + ")" );
 131                         Remove();
 132                 }
 133         }
 134         catch( ConnectionTerminated& e )
 135         {
 136                 g_log->Print( std::string("[Session] Connection ") + boost::lexical_cast<std::string>( m_id ) + " terminated" );
 137                 Remove();
 138         }
 139 }
 140
 141 void Session::Remove()
 142 {
 143         SessionControllerPtr sessionController = m_sessionController.lock();
 144         sessionController->Remove( m_this.lock() );
 145 }
 146
 147 void Session::SendGreeting()
 148 {
 149         ServerPtr server = m_server.lock();
 150         const std::list<std::string> welcome = server->GetWelcomeMessage();
 151
 152         for( std::list<std::string>::const_iterator it = welcome.begin(); it != welcome.end(); ++it )
 153         {
 154                 m_control->Write( "220-" + *it );
 155         }
 156
 157         m_control->Write( "220 Dumb FTP Server ready" );
 158 }
 159
 160 void Session::SendSyntaxError()
 161 {
 162         m_control->Write( "500 Syntax error" );
 163 }
 164
 165 void Session::SendNotLoggedIn()
 166 {
 167         m_control->Write( "530 Not logged in" );
 168 }
 169
 170 void Session::SendDataConnectionBusy()
 171 {
 172         // Is it the correct answer?
 173         m_control->Write( "425 File transfer already takes place" );
 174 }
 175
 176 void Session::SendSyst()
 177 {
 178         // Is it even relevant?
 179         m_control->Write( "215 UNIX" );
 180 }
 181
 182 bool Session::AwaitLogin()
 183 {
 184         if( m_control->Read() )
 185         {
 186                 Command cmd = GetCommand();
 187
 188                 if( cmd[0] == "USER" )
 189                 {
 190                         if( cmd.size() != 2 )
 191                         {
 192                                 SendSyntaxError();
 193                                 return false;
 194                         }
 195
 196                         if( m_auth->Login( cmd[1] ) )
 197                         {
 198                                 m_control->Write( "331 Need password" );
 199                                 m_user = cmd[1];
 200                                 return true;
 201                         }
 202                         else
 203                         {
 204                                 SendNotLoggedIn();
 205                                 return false;
 206                         }
 207                 }
 208                 else if( cmd[0] == "QUIT" )
 209                 {
 210                         throw QuitRequestedException;
 211                 }
 212                 else
 213                 {
 214                         SendNotLoggedIn();
 215                 }
 216         }
 217
 218         return false;
 219 }
 220
 221 Session::PassState Session::AwaitPassword()
 222 {
 223         if( m_control->Read() )
 224         {
 225                 Command cmd = GetCommand();
 226
 227                 if( cmd[0] == "PASS" )
 228                 {
 229                         if( cmd.size() != 2 )
 230                         {
 231                                 SendSyntaxError();
 232                                 return PS_BADPASS;
 233                         }
 234
 235                         if( m_auth->Password( m_user, cmd[1] ) )
 236                         {
 237                                 m_control->Write( "230 Logged in" );
 238
 239                                 m_filesystem.reset( new Filesystem( m_auth->GetRoot( m_user ) ) );
 240
 241                                 g_log->Print( std::string("[Session] User ") + m_user + " logged in on session " + boost::lexical_cast<std::string>( m_id ) );
 242
 243                                 return PS_LOGGEDIN;
 244                         }
 245                         else
 246                         {
 247                                 SendNotLoggedIn();
 248                                 return PS_BADPASS;
 249                         }
 250                 }
 251                 else if( cmd[0] == "QUIT" )
 252                 {
 253                         throw QuitRequestedException;
 254                 }
 255                 else
 256                 {
 257                         SendNotLoggedIn();
 258                         return PS_BADPASS;
 259                 }
 260         }
 261
 262         return PS_NONE;
 263 }
 264
 265 void Session::AwaitReady()
 266 {
 267         if( m_control->Read() )
 268         {
 269                 Command cmd = GetCommand();
 270
 271                 if( cmd[0] == "QUIT" )
 272                 {
 273                         throw QuitRequestedException;
 274                 }
 275                 else if( cmd[0] == "NOOP" )
 276                 {
 277                         m_control->Write( "200 OK" );
 278                 }
 279                 else if( cmd[0] == "MODE" )
 280                 {
 281                         HandleMode( cmd );
 282                 }
 283                 else if( cmd[0] == "TYPE" )
 284                 {
 285                         HandleType( cmd );
 286                 }
 287                 else if( cmd[0] == "STRU" )
 288                 {
 289                         HandleStru( cmd );
 290                 }
 291                 else if( cmd[0] == "PWD" )
 292                 {
 293                         PrintDirectory();
 294                 }
 295                 else if( cmd[0] == "CWD" )
 296                 {
 297                         ChangeDirectory( cmd );
 298                 }
 299                 else if( cmd[0] == "CDUP" )
 300                 {
 301                         ChangeDirectory( ".." );
 302                 }
 303                 else if( cmd[0] == "SYST" )
 304                 {
 305                         SendSyst();
 306                 }
 307                 else if( cmd[0] == "PORT" )
 308                 {
 309                         HandlePort( cmd );
 310                 }
 311                 else if( cmd[0] == "RETR" )
 312                 {
 313                         HandleRetr( cmd );
 314                 }
 315                 else if( cmd[0] == "STOR" )
 316                 {
 317                         HandleStor( cmd );
 318                 }
 319                 else if( cmd[0] == "ABOR" )
 320                 {
 321                         HandleAbor();
 322                 }
 323                 else if( cmd[0] == "LIST" )
 324                 {
 325                         HandleList( cmd );
 326                 }
 327                 else if( cmd[0] == "PASV" )
 328                 {
 329                         HandlePasv( cmd );
 330                 }
 331                 else if( cmd[0] == "DELE" )
 332                 {
 333                         HandleDele( cmd );
 334                 }
 335                 else if( cmd[0] == "MKD" )
 336                 {
 337                         HandleMkd( cmd );
 338                 }
 339                 else if( cmd[0] == "RMD" )
 340                 {
 341                         HandleRmd( cmd );
 342                 }
 343                 else
 344                 {
 345                         throw SyntaxErrorException;
 346                 }
 347         }
 348 }
 349
 350 void Session::HandleMode( const Command& cmd )
 351 {
 352         if( cmd.size() != 2 )
 353         {
 354                 throw SyntaxErrorException;
 355         }
 356
 357         std::string param = cmd[1];
 358         ToUpper( param );
 359
 360         if( param == "S" )
 361         {
 362                 m_control->Write( "200 OK" );
 363         }
 364         else if( param == "B" || param == "C" )
 365         {
 366                 m_control->Write( "504 Not implemented" );
 367         }
 368         else
 369         {
 370                 throw SyntaxErrorException;
 371         }
 372 }
 373
 374 void Session::HandleType( const Command& cmd )
 375 {
 376         if( cmd.size() < 2 || cmd.size() > 3)
 377         {
 378                 throw SyntaxErrorException;
 379         }
 380
 381         std::string param = cmd[1];
 382         ToUpper( param );
 383
 384         if( param == "A" )
 385         {
 386                 if( cmd.size() == 3 )
 387                 {
 388                         std::string param2 = cmd[2];
 389                         ToUpper( param2 );
 390
 391                         if( param2 != "N" )
 392                         {
 393                                 m_control->Write( "504 Not implemented" );
 394                                 return;
 395                         }
 396                 }
 397
 398                 m_control->Write( "200 OK" );
 399         }
 400         else if( param == "I" )
 401         {
 402                 m_control->Write( "200 OK" );
 403         }
 404         else if( param == "E" || param == "L" )
 405         {
 406                 m_control->Write( "504 Not implemented" );
 407         }
 408         else
 409         {
 410                 throw SyntaxErrorException;
 411         }
 412 }
 413
 414 void Session::HandleStru( const Command& cmd )
 415 {
 416         if( cmd.size() != 2 )
 417         {
 418                 throw SyntaxErrorException;
 419         }
 420
 421         std::string param = cmd[1];
 422         ToUpper( param );
 423
 424         if( param == "F" )
 425         {
 426                 m_control->Write( "200 OK" );
 427         }
 428         else if( param == "R" )
 429         {
 430                 throw SessionErrorException;
 431         }
 432         else if( param == "P" )
 433         {
 434                 m_control->Write( "504 Not implemented" );
 435         }
 436         else
 437         {
 438                 throw SyntaxErrorException;
 439         }
 440 }
 441
 442 void Session::HandlePort( const Command& cmd )
 443 {
 444         if( cmd.size() != 2 )
 445         {
 446                 throw SyntaxErrorException;
 447         }
 448
 449         if( m_listenSock )
 450         {
 451                 close( m_listenSock );
 452                 m_listenSock = 0;
 453         }
 454
 455         PortVector pv = SplitPort( cmd[1] );
 456         if( pv.size() != 6 )
 457         {
 458                 throw SyntaxErrorException;
 459         }
 460
 461         m_dataAddress = pv[0] + "." + pv[1] + "." + pv[2] + "." + pv[3];
 462         m_dataPort = ( boost::lexical_cast<int>( pv[4] ) << 8 ) + boost::lexical_cast<int>( pv[5] );
 463
 464         m_control->Write( "200 OK" );
 465 }
 466
 467 void Session::HandleRetr( const Command& cmd )
 468 {
 469         if( m_data )
 470         {
 471                 SendDataConnectionBusy();
 472         }
 473         else
 474         {
 475                 Upload( cmd );
 476         }
 477 }
 478
 479 void Session::HandleStor( const Command& cmd )
 480 {
 481         if( m_data )
 482         {
 483                 SendDataConnectionBusy();
 484         }
 485         else
 486         {
 487                 Download( cmd );
 488         }
 489 }
 490
 491 void Session::HandleAbor()
 492 {
 493         if( !m_data )
 494         {
 495                 m_control->Write( "225 No data connection" );
 496         }
 497         else
 498         {
 499                 g_log->Print( std::string("[Session] Data connection aborted on session ") + boost::lexical_cast<std::string>( m_id ) );
 500
 501                 m_data.reset();
 502
 503                 m_control->Write( "426 File transfer aborted" );
 504                 m_control->Write( "226 Data connection closed" );
 505         }
 506 }
 507
 508 void Session::HandleList( const Command& cmd )
 509 {
 510         std::string path( "." );
 511
 512         if( cmd.size() > 1 && cmd[1].size() > 0 && cmd[1][0] != '-' )
 513         {
 514                 path = cmd[1];
 515         }
 516
 517         std::list<std::string> list = m_filesystem->GetListing( path );
 518
 519         if( list.empty() )
 520         {
 521                 m_control->Write( "450 Some problems" );
 522                 return;
 523         }
 524
 525         m_data.reset( new Data( m_this, list ) );
 526
 527         if( !OpenDataConnection() )
 528         {
 529                 m_control->Write( "425 Can't open data connection" );
 530                 m_data.reset();
 531         }
 532         else
 533         {
 534                 m_control->Write( std::string( "150 Listing " ) + path );
 535                 g_log->Print( std::string("[Session] Sending listing on session ") + boost::lexical_cast<std::string>( m_id ) );
 536         }
 537 }
 538
 539 void Session::HandlePasv( const Command& cmd )
 540 {
 541         if( cmd.size() != 1 )
 542         {
 543                 throw SyntaxErrorException;
 544         }
 545
 546         if( !m_listenSock )
 547         {
 548                 if( ( m_listenSock = socket( PF_INET, SOCK_STREAM, 0 ) ) == -1 )
 549                 {
 550                         throw SessionErrorException;
 551                 }
 552
 553                 sockaddr_in addr;
 554                 addr.sin_family = AF_INET;
 555                 addr.sin_port = 0;
 556                 inet_aton( m_ip.c_str(), &addr.sin_addr );
 557                 memset( addr.sin_zero, 0, sizeof( addr.sin_zero ) );
 558
 559                 if( bind( m_listenSock, (sockaddr*)&addr, sizeof( addr ) ) == -1 )
 560                 {
 561                         throw SessionErrorException;
 562                 }
 563
 564                 if( listen( m_listenSock, 1 ) == -1 )
 565                 {
 566                         throw SessionErrorException;
 567                 }
 568         }
 569
 570         sockaddr_in addr;
 571         socklen_t len = sizeof( addr );
 572         if( getsockname( m_listenSock, (sockaddr*)&addr, &len ) == -1 )
 573         {
 574                 throw SessionErrorException;
 575         }
 576
 577         int port = ntohs( addr.sin_port );
 578         std::string ip = inet_ntoa( addr.sin_addr );
 579
 580         std::replace( ip.begin(), ip.end(), '.', ',' );
 581
 582         m_control->Write( std::string( "227 Entering passive mode " ) + ip +
 583                         "," + boost::lexical_cast<std::string>( port >> 8 ) +
 584                         "," + boost::lexical_cast<std::string>( port & 0xFF ) );
 585 }
 586
 587 void Session::HandleDele( const Command& cmd )
 588 {
 589         if( cmd.size() != 2 )
 590         {
 591                 throw SyntaxErrorException;
 592         }
 593
 594         if( m_filesystem->Delete( cmd[1] ) )
 595         {
 596                 m_control->Write( std::string( "250 Deleted " ) + cmd[1] );
 597         }
 598         else
 599         {
 600                 m_control->Write( std::string( "550 No access to " ) + cmd[1] + " (" + strerror( errno ) + ")" );
 601         }
 602 }
 603
 604 void Session::HandleMkd( const Command& cmd )
 605 {
 606         if( cmd.size() != 2 )
 607         {
 608                 throw SyntaxErrorException;
 609         }
 610
 611         std::string ret = m_filesystem->MkDir( cmd[1] );
 612
 613         if( ret != "" )
 614         {
 615                 m_control->Write( std::string( "257 \"" + ret + "\" created" ) );
 616         }
 617         else
 618         {
 619                 m_control->Write( "550 Directory not created" );
 620         }
 621 }
 622
 623 void Session::HandleRmd( const Command& cmd )
 624 {
 625         if( cmd.size() != 2 )
 626         {
 627                 throw SyntaxErrorException;
 628         }
 629
 630         if( m_filesystem->RmDir( cmd[1] ) )
 631         {
 632                 m_control->Write( "250 OK" );
 633         }
 634         else
 635         {
 636                 m_control->Write( "550 No access" );
 637         }
 638 }
 639
 640 void Session::PrintDirectory()
 641 {
 642         m_control->Write( std::string( "257 " ) + m_filesystem->GetPath() );
 643 }
 644
 645 void Session::ChangeDirectory( const Command& cmd )
 646 {
 647         if( cmd.size() != 2 )
 648         {
 649                 throw SyntaxErrorException;
 650         }
 651
 652         ChangeDirectory( cmd[1] );
 653 }
 654
 655 void Session::ChangeDirectory( const std::string& cd )
 656 {
 657         if( m_filesystem->ChangeDirectory( cd ) )
 658         {
 659                 m_control->Write( std::string( "200 Changed directory to " ) + m_filesystem->GetPath() );
 660         }
 661         else
 662         {
 663                 m_control->Write( "550 Requested action not taken" );
 664         }
 665 }
 666
 667 void Session::Upload( const Command& cmd )
 668 {
 669 #ifdef SYMBIAN
 670         RFile* f;
 671 #else
 672         FILE* f;
 673 #endif
 674
 675         if( cmd.size() != 2 )
 676         {
 677                 throw SyntaxErrorException;
 678         }
 679
 680         if( !m_filesystem->FileExists( cmd[1] ) )
 681         {
 682                 m_control->Write( std::string( "550 File " ) + cmd[1] + " not found" );
 683                 return;
 684         }
 685
 686 #ifdef SYMBIAN
 687         if( ( f = m_filesystem->FileOpenSymbian( cmd[1], Filesystem::M_READ ) ) == NULL )
 688 #else
 689         if( ( f = m_filesystem->FileOpen( cmd[1], Filesystem::M_READ ) ) == NULL )
 690 #endif
 691         {
 692                 m_control->Write( std::string( "450 File " ) + cmd[1] + " not accessible" );
 693                 return;
 694         }
 695
 696         m_data.reset( new Data( m_this, f, Data::M_UPLOAD ) );
 697
 698         if( !OpenDataConnection() )
 699         {
 700                 m_control->Write( "425 Can't open data connection" );
 701                 m_data.reset();
 702         }
 703         else
 704         {
 705                 m_control->Write( std::string( "150 Sending " ) + cmd[1] );
 706                 g_log->Print( std::string("[Session] Opened new upload on session ") + boost::lexical_cast<std::string>( m_id ) );
 707         }
 708 }
 709
 710 void Session::Download( const Command& cmd )
 711 {
 712 #ifdef SYMBIAN
 713         RFile* f;
 714 #else
 715         FILE* f;
 716 #endif
 717
 718         if( cmd.size() != 2 )
 719         {
 720                 throw SyntaxErrorException;
 721         }
 722
 723 #ifdef SYMBIAN
 724         if( ( f = m_filesystem->FileOpenSymbian( cmd[1], Filesystem::M_WRITE ) ) == NULL )
 725 #else
 726         if( ( f = m_filesystem->FileOpen( cmd[1], Filesystem::M_WRITE ) ) == NULL )
 727 #endif
 728         {
 729                 m_control->Write( std::string( "450 File " ) + cmd[1] + " not accessible" );
 730                 return;
 731         }
 732
 733         m_data.reset( new Data( m_this, f, Data::M_DOWNLOAD ) );
 734
 735         if( !OpenDataConnection() )
 736         {
 737                 m_control->Write( "425 Can't open data connection" );
 738                 m_data.reset();
 739         }
 740         else
 741         {
 742                 m_control->Write( std::string( "150 Receiving " ) + cmd[1] );
 743                 g_log->Print( std::string("[Session] Opened new download on session ") + boost::lexical_cast<std::string>( m_id ) );
 744         }
 745 }
 746
 747 void Session::DataConnectionFinished()
 748 {
 749         g_log->Print( std::string("[Session] Data connection closed on session ") + boost::lexical_cast<std::string>( m_id ) );
 750
 751         m_control->Write( "226 File transfer completed" );
 752
 753         m_data.reset();
 754 }
 755
 756 void Session::DataConnectionError()
 757 {
 758         g_log->Print( std::string("[Session] Data connection error on session ") + boost::lexical_cast<std::string>( m_id ) );
 759
 760         m_control->Write( "426 Data connection lost" );
 761
 762         m_data.reset();
 763 }
 764
 765 void Session::OutOfSpace()
 766 {
 767         g_log->Print( std::string("[Session] Out of space on session ") + boost::lexical_cast<std::string>( m_id ) );
 768
 769         m_control->Write( "552 No space left" );
 770
 771         m_data.reset();
 772 }
 773
 774 bool Session::OpenDataConnection()
 775 {
 776         bool ok;
 777
 778         if( m_listenSock )
 779         {
 780                 ok = m_data->Accept( m_listenSock );
 781                 close( m_listenSock );
 782                 m_listenSock = 0;
 783         }
 784         else
 785         {
 786                 ok = m_data->Connect( m_dataAddress, m_dataPort );
 787         }
 788
 789         return ok;
 790 }
 791
 792 std::list<int> Session::GetFds() const
 793 {
 794         std::list<int> ret;
 795
 796         // Server starts by sending greeting, not waiting for data
 797         if( m_state == S_GREETING )
 798         {
 799                 ret.push_back( -m_controlSock );
 800         }
 801         else
 802         {
 803                 ret.push_back( m_controlSock );
 804         }
 805
 806         if( m_listenSock != 0 )
 807         {
 808                 ret.push_back( m_listenSock );
 809         }
 810
 811         if( m_data && m_data->GetSock() != 0 )
 812         {
 813                 // Hack, mark write descriptors as negative
 814                 if( m_data->GetMode() == Data::M_DOWNLOAD )
 815                 {
 816                         ret.push_back( m_data->GetSock() );
 817                 }
 818                 else    // M_UPLOAD, M_LISTING
 819                 {
 820                         ret.push_back( -m_data->GetSock() );
 821                 }
 822         }
 823
 824         return ret;
 825 }