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