modules/access/ftp.c

   1 /*****************************************************************************
   2  * ftp.c: FTP input module
   3  *****************************************************************************
   4  * Copyright (C) 2001-2006 VLC authors and VideoLAN
   5  * Copyright © 2006 Rémi Denis-Courmont
   6  * $Id$
   7  *
   8  * Authors: Laurent Aimar <fenrir@via.ecp.fr> - original code
   9  *          Rémi Denis-Courmont <rem # videolan.org> - EPSV support
  10  *
  11  * This program is free software; you can redistribute it and/or modify it
  12  * under the terms of the GNU Lesser General Public License as published by
  13  * the Free Software Foundation; either version 2.1 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  19  * GNU Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * along with this program; if not, write to the Free Software Foundation,
  23  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  24  *****************************************************************************/
  25
  26 /*****************************************************************************
  27  * Preamble
  28  *****************************************************************************/
  29 #ifdef HAVE_CONFIG_H
  30 # include "config.h"
  31 #endif
  32
  33 #include <assert.h>
  34 #include <stdint.h>
  35 #include <errno.h>
  36
  37 #include <vlc_common.h>
  38 #include <vlc_plugin.h>
  39 #include <vlc_access.h>
  40 #include <vlc_dialog.h>
  41 #include <vlc_input_item.h>
  42 #include <vlc_network.h>
  43 #include <vlc_url.h>
  44 #include <vlc_tls.h>
  45 #include <vlc_sout.h>
  46 #include <vlc_charset.h>
  47 #include <vlc_interrupt.h>
  48 #include <vlc_keystore.h>
  49
  50 #ifndef IPPORT_FTP
  51 # define IPPORT_FTP 21u
  52 #endif
  53
  54 #ifndef IPPORT_FTPS
  55 # define IPPORT_FTPS 990u
  56 #endif
  57
  58 /*****************************************************************************
  59  * Module descriptor
  60  *****************************************************************************/
  61 static int   InOpen ( vlc_object_t * );
  62 static void  InClose( vlc_object_t * );
  63 #ifdef ENABLE_SOUT
  64 static int  OutOpen ( vlc_object_t * );
  65 static void OutClose( vlc_object_t * );
  66 #endif
  67
  68 #define USER_TEXT N_("Username")
  69 #define USER_LONGTEXT N_("Username that will be used for the connection, " \
  70         "if no username is set in the URL.")
  71 #define PASS_TEXT N_("Password")
  72 #define PASS_LONGTEXT N_("Password that will be used for the connection, " \
  73         "if no username or password are set in URL.")
  74 #define ACCOUNT_TEXT N_("FTP account")
  75 #define ACCOUNT_LONGTEXT N_("Account that will be " \
  76     "used for the connection.")
  77
  78 #define LOGIN_DIALOG_TITLE _("FTP authentication")
  79 #define LOGIN_DIALOG_TEXT _("Please enter a valid login and password for " \
  80         "the ftp connexion to %s")
  81
  82 vlc_module_begin ()
  83     set_shortname( "FTP" )
  84     set_description( N_("FTP input") )
  85     set_capability( "access", 0 )
  86     set_category( CAT_INPUT )
  87     set_subcategory( SUBCAT_INPUT_ACCESS )
  88     add_string( "ftp-user", NULL, USER_TEXT, USER_LONGTEXT, false )
  89     add_string( "ftp-pwd", NULL, PASS_TEXT, PASS_LONGTEXT, false )
  90     add_string( "ftp-account", "anonymous", ACCOUNT_TEXT,
  91                 ACCOUNT_LONGTEXT, false )
  92     add_shortcut( "ftp", "ftps", "ftpes" )
  93     set_callbacks( InOpen, InClose )
  94
  95 #ifdef ENABLE_SOUT
  96     add_submodule ()
  97         set_shortname( "FTP" )
  98         set_description( N_("FTP upload output") )
  99         set_capability( "sout access", 0 )
 100         set_category( CAT_SOUT )
 101         set_subcategory( SUBCAT_SOUT_ACO )
 102         add_shortcut( "ftp", "ftps", "ftpes" )
 103         set_callbacks( OutOpen, OutClose )
 104 #endif
 105 vlc_module_end ()
 106
 107 /*****************************************************************************
 108  * Local prototypes
 109  *****************************************************************************/
 110 static ssize_t Read( stream_t *, void *, size_t );
 111 static int Seek( stream_t *, uint64_t );
 112 static int Control( stream_t *, int, va_list );
 113 static int DirRead( stream_t *, input_item_node_t * );
 114 #ifdef ENABLE_SOUT
 115 static int OutSeek( sout_access_out_t *, off_t );
 116 static ssize_t Write( sout_access_out_t *, block_t * );
 117 #endif
 118
 119 static int LoginUserPwd( vlc_object_t *, access_sys_t *,
 120                          const char *, const char *, bool * );
 121 static void FeaturesCheck( void *, const char * );
 122
 123 typedef struct ftp_features_t
 124 {
 125     bool b_unicode;
 126     bool b_authtls;
 127     bool b_mlst;
 128 } ftp_features_t;
 129
 130 enum tls_mode_e
 131 {
 132     NONE = 0,
 133     IMPLICIT,/* ftps */
 134     EXPLICIT /* ftpes */
 135 };
 136
 137 struct access_sys_t
 138 {
 139     vlc_url_t  url;
 140
 141     ftp_features_t   features;
 142     vlc_tls_creds_t *p_creds;
 143     enum tls_mode_e  tlsmode;
 144     vlc_tls_t *cmd;
 145     vlc_tls_t *data;
 146
 147     char       sz_epsv_ip[NI_MAXNUMERICHOST];
 148     bool       out;
 149     uint64_t   offset;
 150     uint64_t   size;
 151 };
 152 #define GET_OUT_SYS( p_this ) \
 153     ((access_sys_t *)(((sout_access_out_t *)(p_this))->p_sys))
 154
 155 static int ftp_SendCommand( vlc_object_t *obj, access_sys_t *sys,
 156                             const char *fmt, ... )
 157 {
 158     size_t fmtlen = strlen( fmt );
 159     char fmtbuf[fmtlen + 3];
 160
 161     memcpy( fmtbuf, fmt, fmtlen );
 162     memcpy( fmtbuf + fmtlen, "\r\n", 3 );
 163
 164     va_list args;
 165     char *cmd;
 166     int val;
 167
 168     va_start( args, fmt );
 169     val = vasprintf( &cmd, fmtbuf, args );
 170     va_end( args );
 171     if( unlikely(val == -1) )
 172         return -1;
 173
 174     if( strncmp( cmd, "PASS ", 5 ) && strncmp( cmd, "ACCT ", 5 ) )
 175         msg_Dbg( obj, "sending request: \"%.*s\" (%d bytes)", val-2, cmd, val );
 176     else
 177         msg_Dbg( obj, "sending request: \"%.*s XXXX\" (XX bytes)", 4, cmd );
 178
 179     if( vlc_tls_Write( sys->cmd, cmd, val ) != val )
 180     {
 181         msg_Err( obj, "request failure" );
 182         val = -1;
 183     }
 184     else
 185         val = 0;
 186     free( cmd );
 187     return val;
 188 }
 189
 190 static char *ftp_GetLine( vlc_object_t *obj, access_sys_t *sys )
 191 {
 192     char *resp = vlc_tls_GetLine( sys->cmd );
 193     if( resp == NULL )
 194         msg_Err( obj, "response failure" );
 195     return resp;
 196 }
 197
 198 /* TODO support this s**t :
 199  RFC 959 allows the client to send certain TELNET strings at any moment,
 200  even in the middle of a request:
 201
 202  * \377\377.
 203  * \377\376x where x is one byte.
 204  * \377\375x where x is one byte. The server is obliged to send \377\374x
 205  *                                immediately after reading x.
 206  * \377\374x where x is one byte.
 207  * \377\373x where x is one byte. The server is obliged to send \377\376x
 208  *                                immediately after reading x.
 209  * \377x for any other byte x.
 210
 211  These strings are not part of the requests, except in the case \377\377,
 212  where the request contains one \377. */
 213 static int ftp_RecvReply( vlc_object_t *obj, access_sys_t *sys,
 214                           char **restrict strp,
 215                           void (*cb)(void *, const char *), void *opaque )
 216 {
 217     char *resp = ftp_GetLine( obj, sys );
 218     if( resp == NULL )
 219         return -1;
 220
 221     char *end;
 222     unsigned code = strtoul( resp, &end, 10 );
 223     if( (end - resp) != 3 || (*end != '-' && *end != ' ') )
 224     {
 225         msg_Err( obj, "malformatted response" );
 226         goto error;
 227     }
 228     msg_Dbg( obj, "received response: \"%s\"", resp );
 229
 230     if( *end == '-' ) /* Multi-line response */
 231     {
 232         bool done;
 233
 234         *end = ' ';
 235         do
 236         {
 237             char *line = ftp_GetLine( obj, sys );
 238             if( line == NULL )
 239                 goto error;
 240
 241             done = !strncmp( resp, line, 4 );
 242             if( !done )
 243                 cb( opaque, line );
 244             free( line );
 245         }
 246         while( !done );
 247     }
 248
 249     if( strp != NULL )
 250         *strp = resp;
 251     else
 252         free( resp );
 253     return code;
 254 error:
 255     free( resp );
 256     return -1;
 257 }
 258
 259 static int ftp_RecvAnswer( vlc_object_t *obj, access_sys_t *sys,
 260                            int *restrict codep, char **restrict strp,
 261                            void (*cb)(void *, const char *), void *opaque )
 262 {
 263     char *str;
 264     int val = ftp_RecvReply( obj, sys, &str, cb, opaque );
 265     if( (val / 100) == 1 )
 266     {   /* There can be zero or one preliminary reply per command */
 267         free( str );
 268         val = ftp_RecvReply( obj, sys, &str, cb, opaque );
 269     }
 270
 271     if( val >= 0 )
 272     {
 273         if( codep != NULL )
 274             *codep = val;
 275         if( strp != NULL )
 276             *strp = str;
 277         else
 278             free( str );
 279         val /= 100;
 280     }
 281     else
 282     {
 283         if( codep != NULL )
 284             *codep = 500;
 285         if( strp != NULL )
 286             *strp = NULL;
 287     }
 288     return val;
 289 }
 290
 291 static void DummyLine( void *data, const char *str )
 292 {
 293     (void) data; (void) str;
 294 }
 295
 296 static int ftp_RecvCommand( vlc_object_t *obj, access_sys_t *sys,
 297                             int *restrict codep, char **restrict strp )
 298 {
 299     return ftp_RecvAnswer( obj, sys, codep, strp, DummyLine, NULL );
 300 }
 301
 302 static int ftp_RecvCommandInit( vlc_object_t *obj, access_sys_t *sys )
 303 {
 304     int val = ftp_RecvReply( obj, sys, NULL, DummyLine, NULL );
 305     if( val >= 0 )
 306         val /= 100;
 307     return val;
 308 }
 309
 310 static int ftp_StartStream( vlc_object_t *, access_sys_t *, uint64_t, bool );
 311 static int ftp_StopStream ( vlc_object_t *, access_sys_t * );
 312
 313 static int readTLSMode( vlc_object_t *obj, access_sys_t *p_sys,
 314                         const char * psz_access )
 315 {
 316     if ( !strncmp( psz_access, "ftps", 4 ) )
 317         p_sys->tlsmode = IMPLICIT;
 318     else
 319     if ( !strncmp( psz_access, "ftpes", 5 ) )
 320         p_sys->tlsmode = EXPLICIT;
 321     else
 322     {
 323         p_sys->p_creds = NULL;
 324         p_sys->tlsmode = NONE;
 325         return 0;
 326     }
 327
 328     p_sys->p_creds = vlc_tls_ClientCreate( obj );
 329     return (p_sys->p_creds != NULL) ? 0 : -1;
 330 }
 331
 332 static int createCmdTLS( vlc_object_t *p_access, access_sys_t *p_sys,
 333                          const char *psz_session_name )
 334 {
 335     /* TLS/SSL handshake */
 336     vlc_tls_t *secure = vlc_tls_ClientSessionCreate( p_sys->p_creds,
 337                                                      p_sys->cmd,
 338                                                      p_sys->url.psz_host,
 339                                                      psz_session_name,
 340                                                      NULL, NULL );
 341     if( secure == NULL )
 342     {
 343         msg_Err( p_access, "cannot establish FTP/TLS session on command channel" );
 344         return -1;
 345     }
 346     p_sys->cmd = secure;
 347     return 0;
 348 }
 349
 350 static void clearCmd( access_sys_t *p_sys )
 351 {
 352     if( p_sys->cmd != NULL )
 353     {
 354         vlc_tls_Close( p_sys->cmd );
 355         p_sys->cmd = NULL;
 356     }
 357 }
 358
 359 static int Login( vlc_object_t *p_access, access_sys_t *p_sys, const char *path )
 360 {
 361     int i_answer;
 362
 363     /* *** Open a TCP connection with server *** */
 364     p_sys->cmd = vlc_tls_SocketOpenTCP( p_access, p_sys->url.psz_host,
 365                                         p_sys->url.i_port );
 366     if( p_sys->cmd == NULL )
 367     {
 368         msg_Err( p_access, "connection failed" );
 369         vlc_dialog_display_error( p_access, _("Network interaction failed"), "%s",
 370             _("VLC could not connect with the given server.") );
 371         goto error;
 372     }
 373
 374     if ( p_sys->tlsmode == IMPLICIT ) /* FTPS Mode */
 375     {
 376         if ( createCmdTLS( p_access, p_sys, "ftps") < 0 )
 377             goto error;
 378     }
 379
 380     while( ftp_RecvCommand( p_access, p_sys, &i_answer, NULL ) == 1 );
 381
 382     if( i_answer / 100 != 2 )
 383     {
 384         msg_Err( p_access, "connection rejected" );
 385         vlc_dialog_display_error( p_access, _("Network interaction failed"), "%s",
 386             _("VLC's connection to the given server was rejected.") );
 387         goto error;
 388     }
 389
 390     msg_Dbg( p_access, "connection accepted (%d)", i_answer );
 391
 392     /* Features check first */
 393     if( ftp_SendCommand( p_access, p_sys, "FEAT" ) < 0
 394      || ftp_RecvAnswer( p_access, p_sys, NULL, NULL,
 395                         FeaturesCheck, &p_sys->features ) < 0 )
 396     {
 397          msg_Err( p_access, "cannot get server features" );
 398          goto error;
 399     }
 400
 401     /* Create TLS Session */
 402     if( p_sys->tlsmode == EXPLICIT )
 403     {
 404         if ( ! p_sys->features.b_authtls )
 405         {
 406             msg_Err( p_access, "Server does not support TLS" );
 407             goto error;
 408         }
 409
 410         if( ftp_SendCommand( p_access, p_sys, "AUTH TLS" ) < 0
 411          || ftp_RecvCommand( p_access, p_sys, &i_answer, NULL ) < 0
 412          || i_answer != 234 )
 413         {
 414              msg_Err( p_access, "cannot switch to TLS: server replied with code %d",
 415                       i_answer );
 416              goto error;
 417         }
 418
 419         if( createCmdTLS( p_access, p_sys, "ftpes") < 0 )
 420         {
 421             goto error;
 422         }
 423     }
 424
 425     if( p_sys->tlsmode != NONE )
 426     {
 427         if( ftp_SendCommand( p_access, p_sys, "PBSZ 0" ) < 0 ||
 428             ftp_RecvCommand( p_access, p_sys, &i_answer, NULL ) < 0 ||
 429             i_answer != 200 )
 430         {
 431             msg_Err( p_access, "Can't truncate Protection buffer size for TLS" );
 432             goto error;
 433         }
 434
 435         if( ftp_SendCommand( p_access, p_sys, "PROT P" ) < 0 ||
 436             ftp_RecvCommand( p_access, p_sys, &i_answer, NULL ) < 0 ||
 437             i_answer != 200 )
 438         {
 439             msg_Err( p_access, "Can't set Data channel protection" );
 440             goto error;
 441         }
 442     }
 443
 444     vlc_url_t url;
 445     vlc_credential credential;
 446     if( vlc_UrlParseFixup( &url, path ) != 0 )
 447     {
 448         vlc_UrlClean( &url );
 449         goto error;
 450     }
 451     vlc_credential_init( &credential, &url );
 452     bool b_logged = false;
 453
 454     /* First: try credentials from url / option */
 455     vlc_credential_get( &credential, p_access, "ftp-user", "ftp-pwd",
 456                         NULL, NULL );
 457     do
 458     {
 459         const char *psz_username = credential.psz_username;
 460
 461         if( psz_username == NULL ) /* use anonymous by default */
 462             psz_username = "anonymous";
 463
 464         if( LoginUserPwd( p_access, p_sys, psz_username,
 465                           credential.psz_password, &b_logged ) != 0
 466          || b_logged )
 467             break;
 468     }
 469     while( vlc_credential_get( &credential, p_access, "ftp-user", "ftp-pwd",
 470                                LOGIN_DIALOG_TITLE, LOGIN_DIALOG_TEXT,
 471                                url.psz_host ) );
 472
 473     if( b_logged )
 474     {
 475         vlc_credential_store( &credential, p_access );
 476         vlc_credential_clean( &credential );
 477         vlc_UrlClean( &url );
 478         return 0;
 479     }
 480     vlc_credential_clean( &credential );
 481     vlc_UrlClean( &url );
 482 error:
 483     clearCmd( p_sys );
 484     return -1;
 485 }
 486
 487 static int LoginUserPwd( vlc_object_t *p_access, access_sys_t *p_sys,
 488                          const char *psz_user, const char *psz_pwd,
 489                          bool *p_logged )
 490 {
 491     int i_answer;
 492
 493     /* Send credentials over channel */
 494     if( ftp_SendCommand( p_access, p_sys, "USER %s", psz_user ) < 0 ||
 495         ftp_RecvCommand( p_access, p_sys, &i_answer, NULL ) < 0 )
 496         return -1;
 497
 498     switch( i_answer / 100 )
 499     {
 500         case 2:
 501             /* X.509 auth successful after AUTH TLS / RFC 2228 sec. 4 */
 502             if ( i_answer == 232 )
 503                 msg_Dbg( p_access, "user accepted and authenticated" );
 504             else
 505                 msg_Dbg( p_access, "user accepted" );
 506             break;
 507         case 3:
 508             msg_Dbg( p_access, "password needed" );
 509
 510             if( ftp_SendCommand( p_access, p_sys, "PASS %s", psz_pwd ) < 0 ||
 511                 ftp_RecvCommand( p_access, p_sys, &i_answer, NULL ) < 0 )
 512                 return -1;
 513
 514             switch( i_answer / 100 )
 515             {
 516                 case 2:
 517                     msg_Dbg( p_access, "password accepted" );
 518                     break;
 519                 case 3:
 520                 {
 521                     char *psz;
 522                     msg_Dbg( p_access, "account needed" );
 523                     psz = var_InheritString( p_access, "ftp-account" );
 524                     if( ftp_SendCommand( p_access, p_sys, "ACCT %s",
 525                                          psz ) < 0 ||
 526                         ftp_RecvCommand( p_access, p_sys, &i_answer, NULL ) < 0 )
 527                     {
 528                         free( psz );
 529                         return -1;
 530                     }
 531                     free( psz );
 532
 533                     if( i_answer / 100 != 2 )
 534                     {
 535                         msg_Err( p_access, "account rejected" );
 536                         vlc_dialog_display_error( p_access,
 537                           _("Network interaction failed"),
 538                           "%s", _("Your account was rejected.") );
 539                         return -1;
 540                     }
 541                     msg_Dbg( p_access, "account accepted" );
 542                     break;
 543                 }
 544
 545                 default:
 546                     msg_Warn( p_access, "password rejected" );
 547                     *p_logged = false;
 548                     return 0;
 549             }
 550             break;
 551         default:
 552             msg_Warn( p_access, "user rejected" );
 553             *p_logged = false;
 554             return 0;
 555     }
 556
 557     *p_logged = true;
 558     return 0;
 559 }
 560
 561 static void FeaturesCheck( void *opaque, const char *feature )
 562 {
 563     ftp_features_t *features = opaque;
 564
 565     if( strcasestr( feature, "UTF8" ) != NULL )
 566         features->b_unicode = true;
 567     else
 568     if( strcasestr( feature, "AUTH TLS" ) != NULL )
 569         features->b_authtls = true;
 570
 571     if( strcasestr( feature, "MLST" ) != NULL )
 572         features->b_mlst = true;
 573 }
 574
 575 static const char *IsASCII( const char *str )
 576 {
 577     int8_t c;
 578     for( const char *p = str; (c = *p) != '\0'; p++ )
 579         if( c < 0 )
 580             return NULL;
 581     return str;
 582 }
 583
 584 static int Connect( vlc_object_t *p_access, access_sys_t *p_sys, const char *path )
 585 {
 586     if( Login( p_access, p_sys, path ) < 0 )
 587         return -1;
 588
 589     /* Extended passive mode */
 590     if( ftp_SendCommand( p_access, p_sys, "EPSV ALL" ) < 0 )
 591     {
 592         msg_Err( p_access, "cannot request extended passive mode" );
 593         goto error;
 594     }
 595
 596     if( ftp_RecvCommand( p_access, p_sys, NULL, NULL ) == 2 )
 597     {
 598         int fd = vlc_tls_GetFD(p_sys->cmd);
 599         if( net_GetPeerAddress( fd, p_sys->sz_epsv_ip, NULL ) )
 600             goto error;
 601     }
 602     else
 603     {
 604         /* If ESPV ALL fails, we fallback to PASV.
 605          * We have to restart the connection in case there is a NAT that
 606          * understands EPSV ALL in the way, and hence won't allow PASV on
 607          * the initial connection.
 608          */
 609         msg_Info( p_access, "FTP Extended passive mode disabled" );
 610         clearCmd( p_sys );
 611
 612         if( Login( p_access, p_sys, path ) )
 613             goto error;
 614     }
 615
 616     if( p_sys->url.psz_path &&
 617         (p_sys->features.b_unicode ? IsUTF8 : IsASCII)(p_sys->url.psz_path) == NULL )
 618     {
 619         msg_Err( p_access, "unsupported path: \"%s\"", p_sys->url.psz_path );
 620         goto error;
 621     }
 622
 623     /* check binary mode support */
 624     if( ftp_SendCommand( p_access, p_sys, "TYPE I" ) < 0 ||
 625         ftp_RecvCommand( p_access, p_sys, NULL, NULL ) != 2 )
 626     {
 627         msg_Err( p_access, "cannot set binary transfer mode" );
 628         goto error;
 629     }
 630
 631     return 0;
 632
 633 error:
 634     clearCmd( p_sys );
 635     return -1;
 636 }
 637
 638
 639 static int parseURL( vlc_url_t *url, const char *path, enum tls_mode_e mode )
 640 {
 641     if( path == NULL )
 642         return VLC_EGENERIC;
 643
 644     /* *** Parse URL and get server addr/port and path *** */
 645     while( *path == '/' )
 646         path++;
 647
 648     vlc_UrlParseFixup( url, path );
 649
 650     if( url->psz_host == NULL || *url->psz_host == '\0' )
 651         return VLC_EGENERIC;
 652
 653     if( url->i_port <= 0 )
 654     {
 655         if( mode == IMPLICIT )
 656             url->i_port = IPPORT_FTPS;
 657         else
 658             url->i_port = IPPORT_FTP; /* default port */
 659     }
 660
 661     if( url->psz_path == NULL )
 662         return VLC_SUCCESS;
 663     /* FTP URLs are relative to user's default directory (RFC1738 §3.2)
 664     For absolute path use ftp://foo.bar//usr/local/etc/filename */
 665     /* FIXME: we should issue a series of CWD, one per slash */
 666     if( url->psz_path )
 667     {
 668         assert( url->psz_path[0] == '/' );
 669         url->psz_path++;
 670     }
 671
 672     char *type = strstr( url->psz_path, ";type=" );
 673     if( type )
 674     {
 675         *type = '\0';
 676         if( strchr( "iI", type[6] ) == NULL )
 677             return VLC_EGENERIC; /* ASCII and directory not supported */
 678     }
 679     vlc_uri_decode( url->psz_path );
 680     return VLC_SUCCESS;
 681 }
 682
 683
 684 /****************************************************************************
 685  * Open: connect to ftp server and ask for file
 686  ****************************************************************************/
 687 static int InOpen( vlc_object_t *p_this )
 688 {
 689     stream_t     *p_access = (stream_t*)p_this;
 690     access_sys_t *p_sys;
 691     char         *psz_arg;
 692     bool          b_directory;
 693
 694     /* Init p_access */
 695     p_sys = p_access->p_sys = (access_sys_t*)vlc_obj_calloc( p_this, 1, sizeof( access_sys_t ) );
 696     if( !p_sys )
 697         return VLC_ENOMEM;
 698     p_sys->data = NULL;
 699     p_sys->out = false;
 700     p_sys->offset = 0;
 701     p_sys->size = UINT64_MAX;
 702
 703     if( readTLSMode( p_this, p_sys, p_access->psz_name ) )
 704         goto exit_error;
 705
 706     if( parseURL( &p_sys->url, p_access->psz_url, p_sys->tlsmode ) )
 707         goto exit_error;
 708
 709     if( Connect( p_this, p_sys, p_access->psz_url ) )
 710         goto exit_error;
 711
 712     do {
 713         /* get size */
 714         if( p_sys->url.psz_path == NULL || !*p_sys->url.psz_path )
 715         {
 716             b_directory = true;
 717             break;
 718         }
 719
 720         if( ftp_SendCommand( p_this, p_sys, "SIZE %s",
 721                              p_sys->url.psz_path ) < 0 )
 722             goto error;
 723
 724         int val = ftp_RecvCommand( p_this, p_sys, NULL, &psz_arg );
 725         if( val == 2 )
 726         {
 727             b_directory = false;
 728             p_sys->size = atoll( &psz_arg[4] );
 729             free( psz_arg );
 730             msg_Dbg( p_access, "file size: %"PRIu64, p_sys->size );
 731             break;
 732         }
 733         if( val >= 0 )
 734             free( psz_arg );
 735
 736         if( ftp_SendCommand( p_this, p_sys, "CWD %s",
 737                              p_sys->url.psz_path ) < 0 )
 738             goto error;
 739
 740         if( ftp_RecvCommand( p_this, p_sys, NULL, NULL ) == 2 )
 741         {
 742             b_directory = true;
 743             break;
 744         }
 745
 746         msg_Err( p_this, "file or directory does not exist" );
 747         goto error;
 748     } while (0);
 749
 750     if( b_directory )
 751     {
 752         p_access->pf_readdir = DirRead;
 753         p_access->pf_control = access_vaDirectoryControlHelper;
 754     } else
 755         ACCESS_SET_CALLBACKS( Read, NULL, Control, Seek ); \
 756
 757     /* Start the 'stream' */
 758     if( ftp_StartStream( p_this, p_sys, 0, b_directory ) < 0 )
 759     {
 760         msg_Err( p_this, "cannot retrieve file" );
 761         goto error;
 762     }
 763
 764     return VLC_SUCCESS;
 765
 766 error:
 767     clearCmd( p_sys );
 768
 769 exit_error:
 770     vlc_UrlClean( &p_sys->url );
 771     vlc_tls_Delete( p_sys->p_creds );
 772     return VLC_EGENERIC;
 773 }
 774
 775 #ifdef ENABLE_SOUT
 776 static int OutOpen( vlc_object_t *p_this )
 777 {
 778     sout_access_out_t *p_access = (sout_access_out_t *)p_this;
 779     access_sys_t      *p_sys;
 780
 781     p_sys = vlc_obj_calloc( p_this, 1, sizeof( *p_sys ) );
 782     if( !p_sys )
 783         return VLC_ENOMEM;
 784
 785     /* Init p_access */
 786     p_sys->data = NULL;
 787     p_sys->out = true;
 788
 789     if( readTLSMode( p_this, p_sys, p_access->psz_access ) )
 790         goto exit_error;
 791
 792     if( parseURL( &p_sys->url, p_access->psz_path, p_sys->tlsmode ) )
 793         goto exit_error;
 794     if( p_sys->url.psz_path == NULL )
 795     {
 796         msg_Err( p_this, "no filename specified" );
 797         goto exit_error;
 798     }
 799
 800     if( Connect( p_this, p_sys, p_access->psz_path ) )
 801         goto exit_error;
 802
 803     /* Start the 'stream' */
 804     if( ftp_StartStream( p_this, p_sys, 0, false ) < 0 )
 805     {
 806         msg_Err( p_access, "cannot store file" );
 807         clearCmd( p_sys );
 808         goto exit_error;
 809     }
 810
 811     p_access->pf_seek = OutSeek;
 812     p_access->pf_write = Write;
 813     p_access->p_sys = (void *)p_sys;
 814
 815     return VLC_SUCCESS;
 816
 817 exit_error:
 818     vlc_UrlClean( &p_sys->url );
 819     vlc_tls_Delete( p_sys->p_creds );
 820     return VLC_EGENERIC;
 821 }
 822 #endif
 823
 824 /*****************************************************************************
 825  * Close: free unused data structures
 826  *****************************************************************************/
 827 static void Close( vlc_object_t *p_access, access_sys_t *p_sys )
 828 {
 829     msg_Dbg( p_access, "stopping stream" );
 830     ftp_StopStream( p_access, p_sys );
 831
 832     if( ftp_SendCommand( p_access, p_sys, "QUIT" ) < 0 )
 833     {
 834         msg_Warn( p_access, "cannot quit" );
 835     }
 836     else
 837     {
 838         ftp_RecvCommand( p_access, p_sys, NULL, NULL );
 839     }
 840
 841     clearCmd( p_sys );
 842
 843     /* free memory */
 844     vlc_UrlClean( &p_sys->url );
 845     vlc_tls_Delete( p_sys->p_creds );
 846 }
 847
 848 static void InClose( vlc_object_t *p_this )
 849 {
 850     Close( p_this, ((stream_t *)p_this)->p_sys);
 851 }
 852
 853 #ifdef ENABLE_SOUT
 854 static void OutClose( vlc_object_t *p_this )
 855 {
 856     Close( p_this, GET_OUT_SYS(p_this));
 857 }
 858 #endif
 859
 860
 861 /*****************************************************************************
 862  * Seek: try to go at the right place
 863  *****************************************************************************/
 864 static int SeekCommon( vlc_object_t *p_access, access_sys_t *p_sys,
 865                        uint64_t i_pos )
 866 {
 867     msg_Dbg( p_access, "seeking to %"PRIu64, i_pos );
 868
 869     ftp_StopStream( p_access, p_sys );
 870
 871     if( ftp_StartStream( p_access, p_sys, i_pos, false ) < 0 )
 872         return VLC_EGENERIC;
 873     return VLC_SUCCESS;
 874 }
 875
 876 static int Seek( stream_t *p_access, uint64_t i_pos )
 877 {
 878     access_sys_t *p_sys = p_access->p_sys;
 879
 880     int val = SeekCommon( (vlc_object_t *)p_access, p_sys, i_pos );
 881     if( val )
 882         return val;
 883
 884     p_sys->offset = i_pos;
 885
 886     return VLC_SUCCESS;
 887 }
 888
 889 #ifdef ENABLE_SOUT
 890 static int OutSeek( sout_access_out_t *p_access, off_t i_pos )
 891 {
 892     return SeekCommon((vlc_object_t *)p_access, GET_OUT_SYS(p_access), i_pos);
 893 }
 894 #endif
 895
 896 /*****************************************************************************
 897  * Read:
 898  *****************************************************************************/
 899 static ssize_t Read( stream_t *p_access, void *p_buffer, size_t i_len )
 900 {
 901     access_sys_t *p_sys = p_access->p_sys;
 902
 903     if( p_sys->data == NULL )
 904         return 0;
 905     assert( !p_sys->out );
 906
 907     ssize_t i_read = vlc_tls_Read( p_sys->data, p_buffer, i_len, false );
 908     if( i_read >= 0 )
 909         p_sys->offset += i_read;
 910     else if( errno != EINTR && errno != EAGAIN )
 911     {
 912         msg_Err( p_access, "receive error: %s", vlc_strerror_c(errno) );
 913         i_read = 0;
 914     }
 915
 916     return i_read;
 917 }
 918
 919 /*****************************************************************************
 920  * DirRead:
 921  *****************************************************************************/
 922 static int DirRead (stream_t *p_access, input_item_node_t *p_current_node)
 923 {
 924     access_sys_t *p_sys = p_access->p_sys;
 925     int i_ret = VLC_SUCCESS;
 926
 927     assert( p_sys->data != NULL );
 928     assert( !p_sys->out );
 929
 930     struct vlc_readdir_helper rdh;
 931     vlc_readdir_helper_init( &rdh, p_access, p_current_node );
 932
 933     while (i_ret == VLC_SUCCESS)
 934     {
 935         char *psz_file;
 936         int type = ITEM_TYPE_UNKNOWN;
 937
 938         char *psz_line = vlc_tls_GetLine( p_sys->data );
 939         if( psz_line == NULL )
 940             break;
 941
 942         if( p_sys->features.b_mlst )
 943         {
 944             /* MLST Format is key=val;key=val...; FILENAME */
 945             if( strstr( psz_line, "type=dir" ) )
 946                 type = ITEM_TYPE_DIRECTORY;
 947             if( strstr( psz_line, "type=file" ) )
 948                 type = ITEM_TYPE_FILE;
 949
 950             /* Get the filename or fail */
 951             psz_file = strchr( psz_line, ' ' );
 952             if( psz_file )
 953                 psz_file++;
 954             else
 955             {
 956                 msg_Warn( p_access, "Empty filename in MLST list" );
 957                 free( psz_line );
 958                 continue;
 959             }
 960         }
 961         else
 962             psz_file = psz_line;
 963
 964         char *psz_uri;
 965         char *psz_filename = vlc_uri_encode( psz_file );
 966         if( psz_filename != NULL &&
 967             asprintf( &psz_uri, "%s://%s:%d%s%s/%s",
 968                       ( p_sys->tlsmode == NONE ) ? "ftp" :
 969                       ( ( p_sys->tlsmode == IMPLICIT ) ? "ftps" : "ftpes" ),
 970                       p_sys->url.psz_host, p_sys->url.i_port,
 971                       p_sys->url.psz_path ? "/" : "",
 972                       p_sys->url.psz_path ? p_sys->url.psz_path : "",
 973                       psz_filename ) != -1 )
 974         {
 975             i_ret = vlc_readdir_helper_additem( &rdh, psz_uri, NULL, psz_file,
 976                                                 type, ITEM_NET );
 977             free( psz_uri );
 978         }
 979         free( psz_filename );
 980         free( psz_line );
 981     }
 982
 983     vlc_readdir_helper_finish( &rdh, i_ret == VLC_SUCCESS );
 984     return i_ret;
 985 }
 986
 987 /*****************************************************************************
 988  * Write:
 989  *****************************************************************************/
 990 #ifdef ENABLE_SOUT
 991 static ssize_t Write( sout_access_out_t *p_access, block_t *p_buffer )
 992 {
 993     access_sys_t *p_sys = GET_OUT_SYS(p_access);
 994     size_t i_write = 0;
 995
 996     assert( p_sys->data != NULL );
 997
 998     while( p_buffer != NULL )
 999     {
1000         block_t *p_next = p_buffer->p_next;
1001
1002         i_write += vlc_tls_Write( p_sys->data,
1003                                   p_buffer->p_buffer, p_buffer->i_buffer );
1004         block_Release( p_buffer );
1005
1006         p_buffer = p_next;
1007     }
1008
1009     return i_write;
1010 }
1011 #endif
1012
1013 /*****************************************************************************
1014  * Control:
1015  *****************************************************************************/
1016 static int Control( stream_t *p_access, int i_query, va_list args )
1017 {
1018     access_sys_t *sys = p_access->p_sys;
1019     bool    *pb_bool;
1020     int64_t *pi_64;
1021
1022     switch( i_query )
1023     {
1024         case STREAM_CAN_SEEK:
1025             pb_bool = va_arg( args, bool * );
1026             *pb_bool = true;
1027             break;
1028         case STREAM_CAN_FASTSEEK:
1029             pb_bool = va_arg( args, bool * );
1030             *pb_bool = false;
1031             break;
1032         case STREAM_CAN_PAUSE:
1033             pb_bool = va_arg( args, bool * );
1034             *pb_bool = true;    /* FIXME */
1035             break;
1036         case STREAM_CAN_CONTROL_PACE:
1037             pb_bool = va_arg( args, bool * );
1038             *pb_bool = true;    /* FIXME */
1039             break;
1040         case STREAM_GET_SIZE:
1041             if( sys->size == UINT64_MAX )
1042                 return VLC_EGENERIC;
1043             *va_arg( args, uint64_t * ) = sys->size;
1044             break;
1045
1046         case STREAM_GET_PTS_DELAY:
1047             pi_64 = va_arg( args, int64_t * );
1048             *pi_64 = INT64_C(1000)
1049                    * var_InheritInteger( p_access, "network-caching" );
1050             break;
1051
1052         case STREAM_SET_PAUSE_STATE:
1053             pb_bool = va_arg( args, bool * );
1054             if ( !pb_bool )
1055                  return Seek( p_access, sys->offset );
1056             break;
1057
1058         default:
1059             return VLC_EGENERIC;
1060
1061     }
1062     return VLC_SUCCESS;
1063 }
1064
1065 static int ftp_StartStream( vlc_object_t *p_access, access_sys_t *p_sys,
1066                             uint64_t i_start, bool b_directory )
1067 {
1068     char psz_ipv4[16], *psz_ip = p_sys->sz_epsv_ip;
1069     int  i_answer;
1070     char *psz_arg, *psz_parser;
1071     int  i_port;
1072
1073     assert( p_sys->data == NULL );
1074
1075     if( ( ftp_SendCommand( p_access, p_sys, *psz_ip ? "EPSV" : "PASV" ) < 0 )
1076      || ( ftp_RecvCommand( p_access, p_sys, &i_answer, &psz_arg ) != 2 ) )
1077     {
1078         msg_Err( p_access, "cannot set passive mode" );
1079         return VLC_EGENERIC;
1080     }
1081
1082     psz_parser = strchr( psz_arg, '(' );
1083     if( psz_parser == NULL )
1084     {
1085         free( psz_arg );
1086         msg_Err( p_access, "cannot parse passive mode response" );
1087         return VLC_EGENERIC;
1088     }
1089
1090     if( *psz_ip )
1091     {
1092         if( sscanf( psz_parser, "(%*3c%u", &i_port ) < 1 )
1093         {
1094             free( psz_arg );
1095             msg_Err( p_access, "cannot parse passive mode response" );
1096             return VLC_EGENERIC;
1097         }
1098     }
1099     else
1100     {
1101         unsigned a1, a2, a3, a4, p1, p2;
1102
1103         if( ( sscanf( psz_parser, "(%u,%u,%u,%u,%u,%u", &a1, &a2, &a3, &a4,
1104                       &p1, &p2 ) < 6 ) || ( a1 > 255 ) || ( a2 > 255 )
1105          || ( a3 > 255 ) || ( a4 > 255 ) || ( p1 > 255 ) || ( p2 > 255 ) )
1106         {
1107             free( psz_arg );
1108             msg_Err( p_access, "cannot parse passive mode response" );
1109             return VLC_EGENERIC;
1110         }
1111
1112         sprintf( psz_ipv4, "%u.%u.%u.%u", a1, a2, a3, a4 );
1113         psz_ip = psz_ipv4;
1114         i_port = (p1 << 8) | p2;
1115     }
1116     free( psz_arg );
1117
1118     msg_Dbg( p_access, "ip:%s port:%d", psz_ip, i_port );
1119
1120     if( ftp_SendCommand( p_access, p_sys, "TYPE I" ) < 0 ||
1121         ftp_RecvCommand( p_access, p_sys, &i_answer, NULL ) != 2 )
1122     {
1123         msg_Err( p_access, "cannot set binary transfer mode" );
1124         return VLC_EGENERIC;
1125     }
1126
1127     if( i_start > 0 )
1128     {
1129         if( ftp_SendCommand( p_access, p_sys, "REST %"PRIu64, i_start ) < 0 ||
1130             ftp_RecvCommand( p_access, p_sys, &i_answer, NULL ) > 3 )
1131         {
1132             msg_Err( p_access, "cannot set restart offset" );
1133             return VLC_EGENERIC;
1134         }
1135     }
1136
1137     msg_Dbg( p_access, "waiting for data connection..." );
1138     p_sys->data = vlc_tls_SocketOpenTCP( p_access, psz_ip, i_port );
1139     if( p_sys->data == NULL )
1140     {
1141         msg_Err( p_access, "failed to connect with server" );
1142         return VLC_EGENERIC;
1143     }
1144     msg_Dbg( p_access, "connection with \"%s:%d\" successful",
1145              psz_ip, i_port );
1146
1147     if( b_directory )
1148     {
1149         if( p_sys->features.b_mlst &&
1150             ftp_SendCommand( p_access, p_sys, "MLSD" ) >= 0 &&
1151             ftp_RecvCommandInit( p_access, p_sys ) == 1 )
1152         {
1153             msg_Dbg( p_access, "Using MLST extension to list" );
1154         }
1155         else
1156         if( ftp_SendCommand( p_access, p_sys, "NLST" ) < 0 ||
1157             ftp_RecvCommandInit( p_access, p_sys ) == 1 )
1158         {
1159             msg_Err( p_access, "cannot list directory contents" );
1160             return VLC_EGENERIC;
1161         }
1162     }
1163     else
1164     {
1165         /* "1xx" message */
1166         assert( p_sys->url.psz_path );
1167         if( ftp_SendCommand( p_access, p_sys, "%s %s",
1168                              p_sys->out ? "STOR" : "RETR",
1169                              p_sys->url.psz_path ) < 0
1170          || ftp_RecvCommandInit( p_access, p_sys ) != 1 )
1171         {
1172             msg_Err( p_access, "cannot retrieve file" );
1173             return VLC_EGENERIC;
1174         }
1175     }
1176
1177     if( p_sys->tlsmode != NONE )
1178     {
1179         /* FIXME: Do Reuse TLS Session */
1180         /* TLS/SSL handshake */
1181         vlc_tls_t *secure = vlc_tls_ClientSessionCreate( p_sys->p_creds,
1182                             p_sys->data, p_sys->url.psz_host,
1183                             ( p_sys->tlsmode == EXPLICIT ) ? "ftpes-data"
1184                                                            : "ftps-data",
1185                                                          NULL, NULL );
1186         if( secure == NULL )
1187         {
1188             msg_Err( p_access, "cannot establish FTP/TLS session for data" \
1189                              ": server not allowing new session ?" );
1190             return VLC_EGENERIC;
1191         }
1192         p_sys->data = secure;
1193     }
1194
1195     return VLC_SUCCESS;
1196 }
1197
1198 static int ftp_StopStream ( vlc_object_t *p_access, access_sys_t *p_sys )
1199 {
1200     int ret = VLC_SUCCESS;
1201
1202     if( ftp_SendCommand( p_access, p_sys, "ABOR" ) < 0 )
1203     {
1204         msg_Warn( p_access, "cannot abort file" );
1205         ret = VLC_EGENERIC;
1206     }
1207
1208     if( p_sys->data != NULL )
1209     {
1210         vlc_tls_Close( p_sys->data );
1211         p_sys->data = NULL;
1212
1213         if( ret == VLC_SUCCESS )
1214             /* Read the final response from RETR/STOR, i.e. 426 or 226 */
1215             ftp_RecvCommand( p_access, p_sys, NULL, NULL );
1216     }
1217
1218     if( ret == VLC_SUCCESS )
1219         /* Read the response from ABOR, i.e. 226 or 225 */
1220         ftp_RecvCommand( p_access, p_sys, NULL, NULL );
1221
1222     return ret;
1223 }