url: remove vlc_UrlParse() option parameter
[vlc.git] / 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_dialog.h>
39 #include <vlc_input_item.h>
40 #include <vlc_network.h>
41 #include <vlc_url.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 MTU_TEXT N_("Read size")
56 #define MTU_LONGTEXT N_("Size of the request for reading access")
57 #define USER_TEXT N_("Username")
58 #define USER_LONGTEXT N_("Username that will be used for the connection, " \
59         "if no username is set in the URL.")
60 #define PASS_TEXT N_("Password")
61 #define PASS_LONGTEXT N_("Password that will be used for the connection, " \
62         "if no username or password are set in URL.")
63
64 vlc_module_begin ()
65     set_shortname( "SFTP" )
66     set_description( N_("SFTP input") )
67     set_capability( "access", 0 )
68     set_category( CAT_INPUT )
69     set_subcategory( SUBCAT_INPUT_ACCESS )
70     add_integer( "sftp-readsize", 8192, MTU_TEXT, MTU_LONGTEXT, true )
71     add_integer( "sftp-port", 22, PORT_TEXT, PORT_LONGTEXT, true )
72     add_string( "sftp-user", NULL, USER_TEXT, USER_LONGTEXT, false )
73     add_password( "sftp-pwd", NULL, PASS_TEXT, PASS_LONGTEXT, false )
74     add_shortcut( "sftp" )
75     set_callbacks( Open, Close )
76 vlc_module_end ()
77
78
79 /*****************************************************************************
80  * Local prototypes
81  *****************************************************************************/
82 static block_t* Block( access_t * );
83 static int      Seek( access_t *, uint64_t );
84 static int      Control( access_t *, int, va_list );
85
86 static input_item_t* DirRead( access_t *p_access );
87
88 struct access_sys_t
89 {
90     int i_socket;
91     LIBSSH2_SESSION* ssh_session;
92     LIBSSH2_SFTP* sftp_session;
93     LIBSSH2_SFTP_HANDLE* file;
94     uint64_t filesize;
95     size_t i_read_size;
96
97     /* browser */
98     char* psz_username_opt;
99     char* psz_password_opt;
100 };
101
102
103
104 /**
105  * Connect to the sftp server and ask for a file
106  * @param p_this: the vlc_object
107  * @return VLC_SUCCESS if everything was fine
108  */
109 static int Open( vlc_object_t* p_this )
110 {
111     access_t*   p_access = (access_t*)p_this;
112     access_sys_t* p_sys;
113     const char* psz_path;
114     char* psz_username = NULL;
115     char* psz_password = NULL;
116     char* psz_remote_home = NULL;
117     int i_port;
118     int i_ret;
119     vlc_url_t url;
120     size_t i_len;
121     int i_type;
122
123     if( !p_access->psz_location )
124         return VLC_EGENERIC;
125
126     access_InitFields( p_access );
127     p_sys = p_access->p_sys = (access_sys_t*)calloc( 1, sizeof( access_sys_t ) );
128     if( !p_sys ) return VLC_ENOMEM;
129
130     p_sys->i_socket = -1;
131
132     /* Parse the URL */
133     vlc_UrlParse( &url, p_access->psz_location );
134
135     /* Check for some parameters */
136     if( EMPTY_STR( url.psz_host ) )
137     {
138         msg_Err( p_access, "You might give a non empty host" );
139         goto error;
140     }
141
142     /* get user/password from url or options */
143     if( !EMPTY_STR( url.psz_username ) )
144         psz_username = strdup( url.psz_username );
145     else
146         psz_username = var_InheritString( p_access, "sftp-user" );
147
148     if( url.psz_password )
149         psz_password = strdup( url.psz_password );
150     else
151         psz_password = var_InheritString( p_access, "sftp-pwd" );
152
153     /* If the user name or password is empty, ask the user */
154     if( EMPTY_STR( psz_username ) || !psz_password )
155     {
156         dialog_Login( p_access, &psz_username, &psz_password,
157                       _("SFTP authentication"),
158                       _("Please enter a valid login and password for the sftp "
159                         "connexion to %s"), url.psz_host );
160         if( EMPTY_STR(psz_username) || !psz_password )
161             goto error;
162     }
163
164     if( url.i_port <= 0 )
165         i_port = var_InheritInteger( p_access, "sftp-port" );
166     else
167         i_port = url.i_port;
168
169
170     /* Connect to the server using a regular socket */
171     p_sys->i_socket = net_Connect( p_access, url.psz_host, i_port, SOCK_STREAM, 0 );
172     if( p_sys->i_socket < 0 )
173     {
174         msg_Err( p_access, "Impossible to open the connection to %s:%i", url.psz_host, i_port );
175         goto error;
176     }
177
178     /* Create the ssh connexion and wait until the server answer */
179     if( ( p_sys->ssh_session = libssh2_session_init() ) == NULL )
180         goto error;
181
182     while( ( i_ret = libssh2_session_startup( p_sys->ssh_session,
183                                               p_sys->i_socket ) )
184            == LIBSSH2_ERROR_EAGAIN );
185
186     if( i_ret != 0 )
187     {
188         msg_Err( p_access, "Impossible to open the connection to %s:%i", url.psz_host, i_port );
189         goto error;
190     }
191
192     /* Set the socket in non-blocking mode */
193     libssh2_session_set_blocking( p_sys->ssh_session, 1 );
194
195     /* List the know hosts */
196     LIBSSH2_KNOWNHOSTS *ssh_knownhosts = libssh2_knownhost_init( p_sys->ssh_session );
197     if( !ssh_knownhosts )
198         goto error;
199
200     char *psz_home = config_GetUserDir( VLC_HOME_DIR );
201     char *psz_knownhosts_file;
202     if( asprintf( &psz_knownhosts_file, "%s/.ssh/known_hosts", psz_home ) != -1 )
203     {
204         libssh2_knownhost_readfile( ssh_knownhosts, psz_knownhosts_file,
205                 LIBSSH2_KNOWNHOST_FILE_OPENSSH );
206         free( psz_knownhosts_file );
207     }
208     free( psz_home );
209
210     const char *fingerprint = libssh2_session_hostkey( p_sys->ssh_session, &i_len, &i_type );
211     struct libssh2_knownhost *host;
212     int check = libssh2_knownhost_check( ssh_knownhosts, url.psz_host,
213                                          fingerprint, i_len,
214                                          LIBSSH2_KNOWNHOST_TYPE_PLAIN |
215                                          LIBSSH2_KNOWNHOST_KEYENC_RAW,
216                                          &host );
217
218     libssh2_knownhost_free( ssh_knownhosts );
219
220     /* Check that it does match or at least that the host is unknown */
221     switch(check)
222     {
223     case LIBSSH2_KNOWNHOST_CHECK_FAILURE:
224     case LIBSSH2_KNOWNHOST_CHECK_NOTFOUND:
225         msg_Dbg( p_access, "Unable to check the remote host" );
226         break;
227     case LIBSSH2_KNOWNHOST_CHECK_MATCH:
228         msg_Dbg( p_access, "Succesfuly matched the host" );
229         break;
230     case LIBSSH2_KNOWNHOST_CHECK_MISMATCH:
231         msg_Err( p_access, "The host does not match !! The remote key changed !!" );
232         goto error;
233     }
234
235     //TODO: ask for the available auth methods
236
237     /* send the login/password */
238     if( libssh2_userauth_password( p_sys->ssh_session, psz_username, psz_password ) )
239     {
240         msg_Err( p_access, "Authentication by password failed" );
241         goto error;
242     }
243
244     /* Create the sftp session */
245     p_sys->sftp_session = libssh2_sftp_init( p_sys->ssh_session );
246
247     if( !p_sys->sftp_session )
248     {
249         msg_Err( p_access, "Unable to initialize the SFTP session" );
250         goto error;
251     }
252
253     /* No path, default to user Home */
254     if( !url.psz_path )
255     {
256         const size_t i_size = 1024;
257         int i_ret;
258
259         psz_remote_home = malloc( i_size );
260         if( !psz_remote_home )
261             goto error;
262
263         i_ret = libssh2_sftp_symlink_ex( p_sys->sftp_session, ".", 1,
264                                          psz_remote_home, i_size - 1,
265                                          LIBSSH2_SFTP_REALPATH );
266         if( i_ret <= 0 )
267         {
268             msg_Err( p_access, "Impossible to get the Home directory" );
269             goto error;
270         }
271         psz_remote_home[i_ret] = '\0';
272         psz_path = psz_remote_home;
273     }
274     else
275         psz_path = url.psz_path;
276
277     /* Get some information */
278     LIBSSH2_SFTP_ATTRIBUTES attributes;
279     if( libssh2_sftp_stat( p_sys->sftp_session, psz_path, &attributes ) )
280     {
281         msg_Err( p_access, "Impossible to get information about the remote path %s", psz_path );
282         goto error;
283     }
284
285     if( !LIBSSH2_SFTP_S_ISDIR( attributes.permissions ))
286     {
287         /* Open the given file */
288         p_sys->file = libssh2_sftp_open( p_sys->sftp_session, psz_path, LIBSSH2_FXF_READ, 0 );
289         p_sys->filesize = attributes.filesize;
290
291         ACCESS_SET_CALLBACKS( NULL, Block, Control, Seek );
292     }
293     else
294     {
295         /* Open the given directory */
296         p_sys->file = libssh2_sftp_opendir( p_sys->sftp_session, psz_path );
297
298         p_access->pf_readdir = DirRead;
299         p_access->pf_control = access_vaDirectoryControlHelper;
300         p_access->info.b_dir_can_loop = true;
301
302         if( p_sys->file )
303         {
304             if( -1 == asprintf( &p_sys->psz_username_opt, "sftp-user=%s", psz_username ) )
305                 p_sys->psz_username_opt = NULL;
306             if( -1 == asprintf( &p_sys->psz_password_opt, "sftp-pwd=%s", psz_password ) )
307                 p_sys->psz_password_opt = NULL;
308         }
309     }
310
311     if( !p_sys->file )
312     {
313         msg_Err( p_access, "Unable to open the remote path %s", psz_path );
314         goto error;
315     }
316
317     p_sys->i_read_size = var_InheritInteger( p_access, "sftp-readsize" );
318
319     free( psz_password );
320     free( psz_username );
321     free( psz_remote_home );
322     vlc_UrlClean( &url );
323     return VLC_SUCCESS;
324
325 error:
326     if( p_sys->file )
327         libssh2_sftp_close_handle( p_sys->file );
328     if( p_sys->ssh_session )
329         libssh2_session_free( p_sys->ssh_session );
330     free( psz_password );
331     free( psz_username );
332     free( psz_remote_home );
333     vlc_UrlClean( &url );
334     if( p_sys->i_socket >= 0 )
335         net_Close( p_sys->i_socket );
336     free( p_sys );
337     return VLC_EGENERIC;
338 }
339
340
341 /* Close: quit the module */
342 static void Close( vlc_object_t* p_this )
343 {
344     access_t*   p_access = (access_t*)p_this;
345     access_sys_t* p_sys = p_access->p_sys;
346
347     libssh2_sftp_close_handle( p_sys->file );
348     libssh2_sftp_shutdown( p_sys->sftp_session );
349
350     libssh2_session_free( p_sys->ssh_session );
351     net_Close( p_sys->i_socket );
352
353     free( p_sys->psz_password_opt );
354     free( p_sys->psz_username_opt );
355
356     free( p_sys );
357 }
358
359
360 static block_t* Block( access_t* p_access )
361 {
362     access_sys_t *p_sys = p_access->p_sys;
363
364     if( p_access->info.b_eof )
365         return NULL;
366
367     /* Allocate the buffer we need */
368     size_t i_len = __MIN( p_sys->i_read_size,
369                           p_sys->filesize - p_access->info.i_pos );
370     block_t* p_block = block_Alloc( i_len );
371     if( !p_block )
372         return NULL;
373
374     /* Read the specified size */
375     ssize_t i_ret = libssh2_sftp_read( p_access->p_sys->file, (char*)p_block->p_buffer, i_len );
376
377     if( i_ret < 0 )
378     {
379         block_Release( p_block );
380         msg_Err( p_access, "read failed" );
381         return NULL;
382     }
383     else if( i_ret == 0 )
384     {
385         p_access->info.b_eof = true;
386         block_Release( p_block );
387         return NULL;
388     }
389     else
390     {
391         p_block->i_buffer = i_ret;
392         p_access->info.i_pos += i_ret;
393         return p_block;
394     }
395 }
396
397
398 static int Seek( access_t* p_access, uint64_t i_pos )
399 {
400     p_access->info.i_pos = i_pos;
401     p_access->info.b_eof = false;
402
403     libssh2_sftp_seek( p_access->p_sys->file, i_pos );
404     return VLC_SUCCESS;
405 }
406
407
408 static int Control( access_t* p_access, int i_query, va_list args )
409 {
410     bool*       pb_bool;
411     int64_t*    pi_64;
412
413     switch( i_query )
414     {
415     case ACCESS_CAN_SEEK:
416         pb_bool = (bool*)va_arg( args, bool* );
417         *pb_bool = true;
418         break;
419
420     case ACCESS_CAN_FASTSEEK:
421         pb_bool = (bool*)va_arg( args, bool* );
422         *pb_bool = false;
423         break;
424
425     case ACCESS_CAN_PAUSE:
426     case ACCESS_CAN_CONTROL_PACE:
427         pb_bool = (bool*)va_arg( args, bool* );
428         *pb_bool = true;
429         break;
430
431     case ACCESS_GET_SIZE:
432         *va_arg( args, uint64_t * ) = p_access->p_sys->filesize;
433         break;
434
435     case ACCESS_GET_PTS_DELAY:
436         pi_64 = (int64_t*)va_arg( args, int64_t* );
437         *pi_64 = INT64_C(1000)
438                * var_InheritInteger( p_access, "network-caching" );
439         break;
440
441     case ACCESS_SET_PAUSE_STATE:
442         break;
443
444     default:
445         return VLC_EGENERIC;
446     }
447
448     return VLC_SUCCESS;
449 }
450
451
452 /*****************************************************************************
453  * Directory access
454  *****************************************************************************/
455
456 static input_item_t* DirRead( access_t *p_access )
457 {
458     access_sys_t *p_sys = p_access->p_sys;
459     LIBSSH2_SFTP_ATTRIBUTES attrs;
460     input_item_t *p_item = NULL;
461     int err;
462     /* Allocate 1024 bytes for file name. Longer names are skipped.
463      * libssh2 does not support seeking in directory streams.
464      * Retrying with larger buffer is possible, but would require
465      * re-opening the directory stream.
466      */
467     size_t i_size = 1024;
468     char *psz_file = malloc( i_size );
469
470     if( !psz_file )
471         return NULL;
472
473     while( !p_item && 0 != ( err = libssh2_sftp_readdir( p_sys->file, psz_file, i_size, &attrs ) ) )
474     {
475         if( err < 0 )
476         {
477             if( err == LIBSSH2_ERROR_BUFFER_TOO_SMALL )
478             {
479                 /* seeking back is not possible ... */
480                 msg_Dbg( p_access, "skipped too long file name" );
481                 continue;
482             }
483             if( err == LIBSSH2_ERROR_EAGAIN )
484             {
485                 continue;
486             }
487             msg_Err( p_access, "directory read failed" );
488             break;
489         }
490
491         if( psz_file[0] == '.' )
492         {
493             continue;
494         }
495
496         /* Create an input item for the current entry */
497
498         char *psz_full_uri, *psz_uri;
499
500         psz_uri = encode_URI_component( psz_file );
501         if( psz_uri == NULL )
502             continue;
503
504         if( asprintf( &psz_full_uri, "sftp://%s/%s", p_access->psz_location, psz_uri ) == -1 )
505         {
506             free( psz_uri );
507             continue;
508         }
509         free( psz_uri );
510
511         int i_type = LIBSSH2_SFTP_S_ISDIR( attrs.permissions ) ? ITEM_TYPE_DIRECTORY : ITEM_TYPE_FILE;
512         p_item = input_item_NewWithTypeExt( psz_full_uri, psz_file,
513                                             0, NULL, 0, 0, i_type, 1 );
514
515         if( p_item == NULL )
516         {
517             free( psz_full_uri );
518             break;
519         }
520
521         /* Here we save on the node the credentials that allowed us to login.
522          * That way the user isn't prompted more than once for credentials */
523         if( p_sys->psz_password_opt )
524             input_item_AddOption( p_item, p_sys->psz_password_opt, VLC_INPUT_OPTION_TRUSTED );
525         if( p_sys->psz_username_opt )
526             input_item_AddOption( p_item, p_sys->psz_username_opt, VLC_INPUT_OPTION_TRUSTED );
527
528         free( psz_full_uri );
529     }
530
531     free( psz_file );
532     return p_item;
533 }