modules/access/sftp.c

   1 /*****************************************************************************
   2  * sftp.c: SFTP input module
   3  *****************************************************************************
   4  * Copyright (C) 2009 VLC authors and VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Rémi Duraffort <ivoire@videolan.org>
   8  *          Petri Hintukainen <phintuka@gmail.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU Lesser General Public License as published by
  12  * the Free Software Foundation; either version 2.1 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with this program; if not, write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #include <vlc_common.h>
  33 #include <vlc_plugin.h>
  34
  35 #include <assert.h>
  36
  37 #include <vlc_access.h>
  38 #include <vlc_input_item.h>
  39 #include <vlc_network.h>
  40 #include <vlc_url.h>
  41 #include <vlc_keystore.h>
  42
  43 #include <libssh2.h>
  44 #include <libssh2_sftp.h>
  45
  46
  47 /*****************************************************************************
  48  * Module descriptor
  49  *****************************************************************************/
  50 static int  Open ( vlc_object_t* );
  51 static void Close( vlc_object_t* );
  52
  53 #define PORT_TEXT N_("SFTP port")
  54 #define PORT_LONGTEXT N_("SFTP port number to use on the server")
  55 #define USER_TEXT N_("Username")
  56 #define USER_LONGTEXT N_("Username that will be used for the connection, " \
  57         "if no username is set in the URL.")
  58 #define PASS_TEXT N_("Password")
  59 #define PASS_LONGTEXT N_("Password that will be used for the connection, " \
  60         "if no username or password are set in URL.")
  61
  62 vlc_module_begin ()
  63     set_shortname( "SFTP" )
  64     set_description( N_("SFTP input") )
  65     set_capability( "access", 0 )
  66     set_category( CAT_INPUT )
  67     set_subcategory( SUBCAT_INPUT_ACCESS )
  68     add_integer( "sftp-port", 22, PORT_TEXT, PORT_LONGTEXT, true )
  69     add_string( "sftp-user", NULL, USER_TEXT, USER_LONGTEXT, false )
  70     add_password( "sftp-pwd", NULL, PASS_TEXT, PASS_LONGTEXT, false )
  71     add_shortcut( "sftp" )
  72     set_callbacks( Open, Close )
  73 vlc_module_end ()
  74
  75
  76 /*****************************************************************************
  77  * Local prototypes
  78  *****************************************************************************/
  79 static ssize_t  Read( stream_t *, void *, size_t );
  80 static int      Seek( stream_t *, uint64_t );
  81 static int      Control( stream_t *, int, va_list );
  82
  83 static int DirRead( stream_t *, input_item_node_t * );
  84
  85 struct access_sys_t
  86 {
  87     int i_socket;
  88     LIBSSH2_SESSION* ssh_session;
  89     LIBSSH2_SFTP* sftp_session;
  90     LIBSSH2_SFTP_HANDLE* file;
  91     uint64_t filesize;
  92     char *psz_base_url;
  93 };
  94
  95 static int AuthKeyAgent( stream_t *p_access, const char *psz_username )
  96 {
  97     access_sys_t* p_sys = p_access->p_sys;
  98     int i_result = VLC_EGENERIC;
  99     LIBSSH2_AGENT *p_sshagent = NULL;
 100     struct libssh2_agent_publickey *p_identity = NULL,
 101                                    *p_prev_identity = NULL;
 102
 103     if( !psz_username || !psz_username[0] )
 104         return i_result;
 105
 106     p_sshagent = libssh2_agent_init( p_sys->ssh_session );
 107
 108     if( !p_sshagent )
 109     {
 110         msg_Dbg( p_access, "Failed to initialize key agent" );
 111         goto bailout;
 112     }
 113     if( libssh2_agent_connect( p_sshagent ) )
 114     {
 115         msg_Dbg( p_access, "Failed to connect key agent" );
 116         goto bailout;
 117     }
 118     if( libssh2_agent_list_identities( p_sshagent ) )
 119     {
 120         msg_Dbg( p_access, "Failed to request identities" );
 121         goto bailout;
 122     }
 123
 124     while( libssh2_agent_get_identity( p_sshagent, &p_identity, p_prev_identity ) == 0 )
 125     {
 126         msg_Dbg( p_access, "Using key %s", p_identity->comment );
 127         if( libssh2_agent_userauth( p_sshagent, psz_username, p_identity ) == 0 )
 128         {
 129             msg_Info( p_access, "Public key agent authentication succeeded" );
 130             i_result = VLC_SUCCESS;
 131             goto bailout;
 132         }
 133         msg_Dbg( p_access, "Public key agent authentication failed" );
 134         p_prev_identity = p_identity;
 135     }
 136
 137 bailout:
 138     if( p_sshagent )
 139     {
 140         libssh2_agent_disconnect( p_sshagent );
 141         libssh2_agent_free( p_sshagent );
 142     }
 143     return i_result;
 144 }
 145
 146
 147 static int AuthPublicKey( stream_t *p_access, const char *psz_home, const char *psz_username )
 148 {
 149     access_sys_t* p_sys = p_access->p_sys;
 150     int i_result = VLC_EGENERIC;
 151     char *psz_keyfile1 = NULL;
 152     char *psz_keyfile2 = NULL;
 153
 154     if( !psz_username || !psz_username[0] )
 155         return i_result;
 156
 157     if( asprintf( &psz_keyfile1, "%s/.ssh/id_rsa.pub", psz_home ) == -1 ||
 158         asprintf( &psz_keyfile2, "%s/.ssh/id_rsa",     psz_home ) == -1 )
 159         goto bailout;
 160
 161     if( libssh2_userauth_publickey_fromfile( p_sys->ssh_session, psz_username, psz_keyfile1, psz_keyfile2, NULL ) )
 162     {
 163         msg_Dbg( p_access, "Public key authentication failed" );
 164         goto bailout;
 165     }
 166
 167     msg_Info( p_access, "Public key authentication succeeded" );
 168     i_result = VLC_SUCCESS;
 169
 170  bailout:
 171     free( psz_keyfile1 );
 172     free( psz_keyfile2 );
 173     return i_result;
 174 }
 175
 176 /**
 177  * Connect to the sftp server and ask for a file
 178  * @param p_this: the vlc_object
 179  * @return VLC_SUCCESS if everything was fine
 180  */
 181 static int Open( vlc_object_t* p_this )
 182 {
 183     stream_t*   p_access = (stream_t*)p_this;
 184     access_sys_t* p_sys;
 185     vlc_url_t credential_url;
 186     vlc_credential credential;
 187     const char* psz_path;
 188     char* psz_remote_home = NULL;
 189     char* psz_home = NULL;
 190     int i_port;
 191     int i_ret;
 192     vlc_url_t url;
 193     size_t i_len;
 194     int i_type;
 195     int i_result = VLC_EGENERIC;
 196
 197     if( !p_access->psz_location )
 198         return VLC_EGENERIC;
 199
 200     p_sys = p_access->p_sys = vlc_calloc( p_this, 1, sizeof( access_sys_t ) );
 201     if( !p_sys ) return VLC_ENOMEM;
 202
 203     p_sys->i_socket = -1;
 204
 205     vlc_UrlParse( &credential_url, p_access->psz_url );
 206     vlc_credential_init( &credential, &credential_url );
 207
 208     /* Parse the URL */
 209     vlc_UrlParse( &url, p_access->psz_url );
 210     vlc_uri_decode( url.psz_path );
 211
 212     /* Check for some parameters */
 213     if( EMPTY_STR( url.psz_host ) )
 214     {
 215         msg_Err( p_access, "Unable to extract host from %s", p_access->psz_url );
 216         goto error;
 217     }
 218
 219     if( url.i_port <= 0 )
 220         i_port = var_InheritInteger( p_access, "sftp-port" );
 221     else
 222         i_port = url.i_port;
 223
 224
 225     /* Connect to the server using a regular socket */
 226     p_sys->i_socket = net_ConnectTCP( p_access, url.psz_host, i_port );
 227     if( p_sys->i_socket < 0 )
 228     {
 229         msg_Err( p_access, "Impossible to open the connection to %s:%i", url.psz_host, i_port );
 230         goto error;
 231     }
 232
 233     /* Create the ssh connexion and wait until the server answer */
 234     if( ( p_sys->ssh_session = libssh2_session_init() ) == NULL )
 235         goto error;
 236
 237     while( ( i_ret = libssh2_session_startup( p_sys->ssh_session,
 238                                               p_sys->i_socket ) )
 239            == LIBSSH2_ERROR_EAGAIN );
 240
 241     if( i_ret != 0 )
 242     {
 243         msg_Err( p_access, "Impossible to open the connection to %s:%i", url.psz_host, i_port );
 244         goto error;
 245     }
 246
 247     /* Set the socket in non-blocking mode */
 248     libssh2_session_set_blocking( p_sys->ssh_session, 1 );
 249
 250     /* List the know hosts */
 251     LIBSSH2_KNOWNHOSTS *ssh_knownhosts = libssh2_knownhost_init( p_sys->ssh_session );
 252     if( !ssh_knownhosts )
 253         goto error;
 254
 255     psz_home = config_GetUserDir( VLC_HOME_DIR );
 256     char *psz_knownhosts_file;
 257     if( asprintf( &psz_knownhosts_file, "%s/.ssh/known_hosts", psz_home ) != -1 )
 258     {
 259         libssh2_knownhost_readfile( ssh_knownhosts, psz_knownhosts_file,
 260                 LIBSSH2_KNOWNHOST_FILE_OPENSSH );
 261         free( psz_knownhosts_file );
 262     }
 263
 264     const char *fingerprint = libssh2_session_hostkey( p_sys->ssh_session, &i_len, &i_type );
 265     struct libssh2_knownhost *host;
 266     int knownhost_fingerprint_algo;
 267
 268     switch( i_type )
 269     {
 270         case LIBSSH2_HOSTKEY_TYPE_RSA:
 271             knownhost_fingerprint_algo = LIBSSH2_KNOWNHOST_KEY_SSHRSA;
 272             break;
 273
 274         case LIBSSH2_HOSTKEY_TYPE_DSS:
 275             knownhost_fingerprint_algo = LIBSSH2_KNOWNHOST_KEY_SSHDSS;
 276             break;
 277
 278         default:
 279             msg_Err( p_access, "Host uses unrecognized session-key algorithm" );
 280             libssh2_knownhost_free( ssh_knownhosts );
 281             goto error;
 282
 283     }
 284
 285     int check = libssh2_knownhost_check( ssh_knownhosts, url.psz_host,
 286                                          fingerprint, i_len,
 287                                          LIBSSH2_KNOWNHOST_TYPE_PLAIN |
 288                                          LIBSSH2_KNOWNHOST_KEYENC_RAW |
 289                                          knownhost_fingerprint_algo,
 290                                          &host );
 291
 292     libssh2_knownhost_free( ssh_knownhosts );
 293
 294     /* Check that it does match or at least that the host is unknown */
 295     switch(check)
 296     {
 297     case LIBSSH2_KNOWNHOST_CHECK_FAILURE:
 298     case LIBSSH2_KNOWNHOST_CHECK_NOTFOUND:
 299         msg_Dbg( p_access, "Unable to check the remote host" );
 300         break;
 301     case LIBSSH2_KNOWNHOST_CHECK_MATCH:
 302         msg_Dbg( p_access, "Succesfuly matched the host" );
 303         break;
 304     case LIBSSH2_KNOWNHOST_CHECK_MISMATCH:
 305         msg_Err( p_access, "The host does not match !! The remote key changed !!" );
 306         goto error;
 307     }
 308
 309     char* psz_userauthlist = NULL;
 310     do
 311     {
 312         if (!credential.psz_username || !credential.psz_username[0])
 313             continue;
 314
 315         psz_userauthlist = libssh2_userauth_list( p_sys->ssh_session, credential.psz_username, strlen( credential.psz_username ) );
 316         if (!psz_userauthlist) {
 317             msg_Err( p_access, "Host authentication list failed");
 318             goto error;
 319         }
 320
 321         /* TODO: Follow PreferredAuthentications in ssh_config */
 322
 323         if( strstr( psz_userauthlist, "publickey" ) != NULL &&
 324             ( AuthKeyAgent( p_access, credential.psz_username ) == VLC_SUCCESS ||
 325               AuthPublicKey( p_access, psz_home, credential.psz_username ) == VLC_SUCCESS ) )
 326             break;
 327         if( strstr( psz_userauthlist, "password" ) != NULL &&
 328             libssh2_userauth_password( p_sys->ssh_session,
 329                                        credential.psz_username,
 330                                        credential.psz_password ) == 0 )
 331         {
 332             vlc_credential_store( &credential, p_access );
 333             break;
 334         }
 335
 336         msg_Warn( p_access, "sftp auth failed for %s", credential.psz_username );
 337     } while( vlc_credential_get( &credential, p_access, "sftp-user", "sftp-pwd",
 338                                 _("SFTP authentication"),
 339                                 _("Please enter a valid login and password for "
 340                                 "the sftp connexion to %s"), url.psz_host ) );
 341
 342     /* Create the sftp session */
 343     p_sys->sftp_session = libssh2_sftp_init( p_sys->ssh_session );
 344
 345     if( !p_sys->sftp_session )
 346     {
 347         msg_Err( p_access, "Unable to initialize the SFTP session" );
 348         goto error;
 349     }
 350
 351     /* No path, default to user Home */
 352     if( !url.psz_path )
 353     {
 354         const size_t i_size = 1024;
 355         int i_read;
 356
 357         psz_remote_home = malloc( i_size );
 358         if( !psz_remote_home )
 359             goto error;
 360
 361         i_read = libssh2_sftp_symlink_ex( p_sys->sftp_session, ".", 1,
 362                                           psz_remote_home, i_size - 1,
 363                                           LIBSSH2_SFTP_REALPATH );
 364         if( i_read <= 0 )
 365         {
 366             msg_Err( p_access, "Impossible to get the Home directory" );
 367             goto error;
 368         }
 369         psz_remote_home[i_read] = '\0';
 370         psz_path = psz_remote_home;
 371
 372         /* store base url for directory read */
 373         char *base = vlc_path2uri( psz_path, "sftp" );
 374         if( !base )
 375             goto error;
 376         if( -1 == asprintf( &p_sys->psz_base_url, "sftp://%s%s", p_access->psz_location, base + 7 ) )
 377         {
 378             free( base );
 379             goto error;
 380         }
 381         free( base );
 382     }
 383     else
 384         psz_path = url.psz_path;
 385
 386     /* Get some information */
 387     LIBSSH2_SFTP_ATTRIBUTES attributes;
 388     if( libssh2_sftp_stat( p_sys->sftp_session, psz_path, &attributes ) )
 389     {
 390         msg_Err( p_access, "Impossible to get information about the remote path %s", psz_path );
 391         goto error;
 392     }
 393
 394     if( !LIBSSH2_SFTP_S_ISDIR( attributes.permissions ))
 395     {
 396         /* Open the given file */
 397         p_sys->file = libssh2_sftp_open( p_sys->sftp_session, psz_path, LIBSSH2_FXF_READ, 0 );
 398         p_sys->filesize = attributes.filesize;
 399
 400         ACCESS_SET_CALLBACKS( Read, NULL, Control, Seek );
 401     }
 402     else
 403     {
 404         /* Open the given directory */
 405         p_sys->file = libssh2_sftp_opendir( p_sys->sftp_session, psz_path );
 406
 407         p_access->pf_readdir = DirRead;
 408         p_access->pf_control = access_vaDirectoryControlHelper;
 409
 410         if( !p_sys->psz_base_url )
 411         {
 412             if( asprintf( &p_sys->psz_base_url, "sftp://%s", p_access->psz_location ) == -1 )
 413                 goto error;
 414
 415             /* trim trailing '/' */
 416             size_t len = strlen( p_sys->psz_base_url );
 417             if( len > 0 && p_sys->psz_base_url[ len - 1 ] == '/' )
 418                 p_sys->psz_base_url[ len - 1 ] = 0;
 419         }
 420     }
 421
 422     if( !p_sys->file )
 423     {
 424         msg_Err( p_access, "Unable to open the remote path %s", psz_path );
 425         goto error;
 426     }
 427
 428     i_result = VLC_SUCCESS;
 429
 430 error:
 431     free( psz_home );
 432     free( psz_remote_home );
 433     vlc_UrlClean( &url );
 434     vlc_credential_clean( &credential );
 435     vlc_UrlClean( &credential_url );
 436     if( i_result != VLC_SUCCESS ) {
 437         Close( p_this );
 438     }
 439     return i_result;
 440 }
 441
 442
 443 /* Close: quit the module */
 444 static void Close( vlc_object_t* p_this )
 445 {
 446     stream_t*   p_access = (stream_t*)p_this;
 447     access_sys_t* p_sys = p_access->p_sys;
 448
 449     if( p_sys->file )
 450         libssh2_sftp_close_handle( p_sys->file );
 451     if( p_sys->sftp_session )
 452         libssh2_sftp_shutdown( p_sys->sftp_session );
 453     if( p_sys->ssh_session )
 454         libssh2_session_free( p_sys->ssh_session );
 455     if( p_sys->i_socket >= 0 )
 456         net_Close( p_sys->i_socket );
 457
 458     free( p_sys->psz_base_url );
 459 }
 460
 461
 462 static ssize_t Read( stream_t *p_access, void *buf, size_t len )
 463 {
 464     access_sys_t *p_sys = p_access->p_sys;
 465
 466     ssize_t val = libssh2_sftp_read(  p_sys->file, buf, len );
 467     if( val < 0 )
 468     {
 469         msg_Err( p_access, "read failed" );
 470         return 0;
 471     }
 472
 473     return val;
 474 }
 475
 476
 477 static int Seek( stream_t* p_access, uint64_t i_pos )
 478 {
 479     access_sys_t *sys = p_access->p_sys;
 480
 481     libssh2_sftp_seek( sys->file, i_pos );
 482     return VLC_SUCCESS;
 483 }
 484
 485
 486 static int Control( stream_t* p_access, int i_query, va_list args )
 487 {
 488     access_sys_t *sys = p_access->p_sys;
 489     bool*       pb_bool;
 490     int64_t*    pi_64;
 491
 492     switch( i_query )
 493     {
 494     case STREAM_CAN_SEEK:
 495         pb_bool = va_arg( args, bool * );
 496         *pb_bool = true;
 497         break;
 498
 499     case STREAM_CAN_FASTSEEK:
 500         pb_bool = va_arg( args, bool * );
 501         *pb_bool = false;
 502         break;
 503
 504     case STREAM_CAN_PAUSE:
 505     case STREAM_CAN_CONTROL_PACE:
 506         pb_bool = va_arg( args, bool * );
 507         *pb_bool = true;
 508         break;
 509
 510     case STREAM_GET_SIZE:
 511         if( p_access->pf_readdir != NULL )
 512             return VLC_EGENERIC;
 513         *va_arg( args, uint64_t * ) = sys->filesize;
 514         break;
 515
 516     case STREAM_GET_PTS_DELAY:
 517         pi_64 = va_arg( args, int64_t * );
 518         *pi_64 = INT64_C(1000)
 519                * var_InheritInteger( p_access, "network-caching" );
 520         break;
 521
 522     case STREAM_SET_PAUSE_STATE:
 523         break;
 524
 525     default:
 526         return VLC_EGENERIC;
 527     }
 528
 529     return VLC_SUCCESS;
 530 }
 531
 532
 533 /*****************************************************************************
 534  * Directory access
 535  *****************************************************************************/
 536
 537 static int DirRead (stream_t *p_access, input_item_node_t *p_current_node)
 538 {
 539     access_sys_t *p_sys = p_access->p_sys;
 540     LIBSSH2_SFTP_ATTRIBUTES attrs;
 541     int i_ret = VLC_SUCCESS;
 542     int err;
 543     /* Allocate 1024 bytes for file name. Longer names are skipped.
 544      * libssh2 does not support seeking in directory streams.
 545      * Retrying with larger buffer is possible, but would require
 546      * re-opening the directory stream.
 547      */
 548     size_t i_size = 1024;
 549     char *psz_file = malloc( i_size );
 550
 551     if( !psz_file )
 552         return VLC_ENOMEM;
 553
 554     struct vlc_readdir_helper rdh;
 555     vlc_readdir_helper_init( &rdh, p_access, p_current_node );
 556
 557     while( i_ret == VLC_SUCCESS
 558         && 0 != ( err = libssh2_sftp_readdir( p_sys->file, psz_file, i_size, &attrs ) ) )
 559     {
 560         if( err < 0 )
 561         {
 562             if( err == LIBSSH2_ERROR_BUFFER_TOO_SMALL )
 563             {
 564                 /* seeking back is not possible ... */
 565                 msg_Dbg( p_access, "skipped too long file name" );
 566                 continue;
 567             }
 568             if( err == LIBSSH2_ERROR_EAGAIN )
 569             {
 570                 continue;
 571             }
 572             msg_Err( p_access, "directory read failed" );
 573             break;
 574         }
 575
 576         /* Create an input item for the current entry */
 577
 578         char *psz_full_uri, *psz_uri;
 579
 580         psz_uri = vlc_uri_encode( psz_file );
 581         if( psz_uri == NULL )
 582         {
 583             i_ret = VLC_ENOMEM;
 584             break;
 585         }
 586
 587         if( asprintf( &psz_full_uri, "%s/%s", p_sys->psz_base_url, psz_uri ) == -1 )
 588         {
 589             free( psz_uri );
 590             i_ret = VLC_ENOMEM;
 591             break;
 592         }
 593         free( psz_uri );
 594
 595         int i_type = LIBSSH2_SFTP_S_ISDIR( attrs.permissions ) ? ITEM_TYPE_DIRECTORY : ITEM_TYPE_FILE;
 596         i_ret = vlc_readdir_helper_additem( &rdh, psz_full_uri, NULL, psz_file,
 597                                             i_type, ITEM_NET );
 598         free( psz_full_uri );
 599     }
 600
 601     vlc_readdir_helper_finish( &rdh, i_ret == VLC_SUCCESS );
 602     free( psz_file );
 603     return i_ret;
 604 }