Session.cpp

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