git.sesse.net Git - vlc/blob - modules/access/directory.c

   1 /*****************************************************************************
   2  * directory.c: expands a directory (directory: access plug-in)
   3  *****************************************************************************
   4  * Copyright (C) 2002-2007 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Derk-Jan Hartman <hartman at videolan dot org>
   8  *          Rémi Denis-Courmont
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 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 General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28
  29 #include <vlc/vlc.h>
  30 #include <vlc_playlist.h>
  31 #include <vlc_input.h>
  32 #include <vlc_access.h>
  33 #include <vlc_demux.h>
  34
  35 #ifdef HAVE_SYS_TYPES_H
  36 #   include <sys/types.h>
  37 #endif
  38 #ifdef HAVE_SYS_STAT_H
  39 #   include <sys/stat.h>
  40 #endif
  41 #ifdef HAVE_ERRNO_H
  42 #   include <errno.h>
  43 #endif
  44 #ifdef HAVE_FCNTL_H
  45 #   include <fcntl.h>
  46 #endif
  47
  48 #ifdef HAVE_UNISTD_H
  49 #   include <unistd.h>
  50 #elif defined( WIN32 ) && !defined( UNDER_CE )
  51 #   include <io.h>
  52 #elif defined( UNDER_CE )
  53 #   define strcoll strcmp
  54 #endif
  55
  56 #ifdef HAVE_DIRENT_H
  57 #   include <dirent.h>
  58 #endif
  59
  60 #include <vlc_charset.h>
  61
  62 /*****************************************************************************
  63  * Module descriptor
  64  *****************************************************************************/
  65 static int  Open ( vlc_object_t * );
  66 static void Close( vlc_object_t * );
  67
  68 static int  DemuxOpen ( vlc_object_t * );
  69
  70 #define RECURSIVE_TEXT N_("Subdirectory behavior")
  71 #define RECURSIVE_LONGTEXT N_( \
  72         "Select whether subdirectories must be expanded.\n" \
  73         "none: subdirectories do not appear in the playlist.\n" \
  74         "collapse: subdirectories appear but are expanded on first play.\n" \
  75         "expand: all subdirectories are expanded.\n" )
  76
  77 static const char *psz_recursive_list[] = { "none", "collapse", "expand" };
  78 static const char *psz_recursive_list_text[] = { N_("none"), N_("collapse"),
  79                                                  N_("expand") };
  80
  81 #define IGNORE_TEXT N_("Ignored extensions")
  82 #define IGNORE_LONGTEXT N_( \
  83         "Files with these extensions will not be added to playlist when " \
  84         "opening a directory.\n" \
  85         "This is useful if you add directories that contain playlist files " \
  86         "for instance. Use a comma-separated list of extensions." )
  87
  88 vlc_module_begin();
  89     set_category( CAT_INPUT );
  90     set_shortname( _("Directory" ) );
  91     set_subcategory( SUBCAT_INPUT_ACCESS );
  92     set_description( _("Standard filesystem directory input") );
  93     set_capability( "access2", 55 );
  94     add_shortcut( "directory" );
  95     add_shortcut( "dir" );
  96     add_shortcut( "file" );
  97
  98     add_string( "recursive", "expand" , NULL, RECURSIVE_TEXT,
  99                 RECURSIVE_LONGTEXT, VLC_FALSE );
 100         change_string_list( psz_recursive_list, psz_recursive_list_text, 0 );
 101         change_safe();
 102
 103     add_string( "ignore-filetypes", "m3u,db,nfo,jpg,gif,sfv,txt,sub,idx,srt,cue",
 104                 NULL, IGNORE_TEXT, IGNORE_LONGTEXT, VLC_FALSE );
 105         change_safe();
 106
 107     set_callbacks( Open, Close );
 108
 109     add_submodule();
 110         set_description( "Directory EOF");
 111         set_capability( "demux2", 0 );
 112         set_callbacks( DemuxOpen, NULL );
 113 vlc_module_end();
 114
 115
 116 /*****************************************************************************
 117  * Local prototypes, constants, structures
 118  *****************************************************************************/
 119
 120 enum
 121 {
 122     MODE_EXPAND,
 123     MODE_COLLAPSE,
 124     MODE_NONE
 125 };
 126
 127 typedef struct stat_list_t stat_list_t;
 128
 129 static ssize_t Read( access_t *, uint8_t *, size_t );
 130 static ssize_t ReadNull( access_t *, uint8_t *, size_t );
 131 static int Control( access_t *, int, va_list );
 132
 133 static int Demux( demux_t *p_demux );
 134 static int DemuxControl( demux_t *p_demux, int i_query, va_list args );
 135
 136
 137 static int ReadDir( playlist_t *, const char *psz_name, int i_mode,
 138                     playlist_item_t *, playlist_item_t *, input_item_t *,
 139                     DIR *handle, stat_list_t *stats );
 140
 141 static DIR *OpenDir (vlc_object_t *obj, const char *psz_name);
 142
 143 /*****************************************************************************
 144  * Open: open the directory
 145  *****************************************************************************/
 146 static int Open( vlc_object_t *p_this )
 147 {
 148     access_t *p_access = (access_t*)p_this;
 149
 150     DIR *handle = OpenDir (p_this, p_access->psz_path);
 151     if (handle == NULL)
 152         return VLC_EGENERIC;
 153
 154     p_access->p_sys = (access_sys_t *)handle;
 155
 156     p_access->pf_read  = Read;
 157     p_access->pf_block = NULL;
 158     p_access->pf_seek  = NULL;
 159     p_access->pf_control= Control;
 160
 161     /* Force a demux */
 162     p_access->psz_demux = strdup( "directory" );
 163
 164     return VLC_SUCCESS;
 165 }
 166
 167 /*****************************************************************************
 168  * Close: close the target
 169  *****************************************************************************/
 170 static void Close( vlc_object_t * p_this )
 171 {
 172     access_t *p_access = (access_t*)p_this;
 173     DIR *handle = (DIR *)p_access->p_sys;
 174     closedir (handle);
 175 }
 176
 177 /*****************************************************************************
 178  * ReadNull: read the directory
 179  *****************************************************************************/
 180 static ssize_t ReadNull( access_t *p_access, uint8_t *p_buffer, size_t i_len)
 181 {
 182     /* Return fake data */
 183     memset( p_buffer, 0, i_len );
 184     return i_len;
 185 }
 186
 187 /*****************************************************************************
 188  * Read: read the directory
 189  *****************************************************************************/
 190 static ssize_t Read( access_t *p_access, uint8_t *p_buffer, size_t i_len)
 191 {
 192     char               *psz;
 193     int                 i_mode, i_activity;
 194     char               *psz_name = strdup (p_access->psz_path);
 195
 196     if( psz_name == NULL )
 197         return VLC_ENOMEM;
 198
 199     playlist_t         *p_playlist = pl_Yield( p_access );
 200     input_thread_t     *p_input = (input_thread_t*)vlc_object_find( p_access, VLC_OBJECT_INPUT, FIND_PARENT );
 201
 202     playlist_item_t    *p_item_in_category;
 203     input_item_t       *p_current_input;
 204     playlist_item_t    *p_current;
 205
 206     if( !p_input )
 207     {
 208         msg_Err( p_access, "unable to find input (internal error)" );
 209         vlc_object_release( p_playlist );
 210         return VLC_ENOOBJ;
 211     }
 212
 213     p_current_input = input_GetItem( p_input );
 214     p_current = playlist_ItemGetByInput( p_playlist, p_current_input, VLC_FALSE );
 215
 216     if( !p_current )
 217     {
 218         msg_Err( p_access, "unable to find item in playlist" );
 219         vlc_object_release( p_input );
 220         vlc_object_release( p_playlist );
 221         return VLC_ENOOBJ;
 222     }
 223
 224     /* Remove the ending '/' char */
 225     if( psz_name[0] )
 226     {
 227         char *ptr = psz_name + strlen (psz_name);
 228         switch (*--ptr)
 229         {
 230             case '/':
 231             case '\\':
 232                 *ptr = '\0';
 233         }
 234     }
 235
 236     /* Handle mode */
 237     psz = var_CreateGetString( p_access, "recursive" );
 238     if( *psz == '\0' || !strncmp( psz, "none" , 4 )  )
 239         i_mode = MODE_NONE;
 240     else if( !strncmp( psz, "collapse", 8 )  )
 241         i_mode = MODE_COLLAPSE;
 242     else
 243         i_mode = MODE_EXPAND;
 244     free( psz );
 245
 246     p_current->p_input->i_type = ITEM_TYPE_DIRECTORY;
 247     p_item_in_category = playlist_ItemToNode( p_playlist, p_current,
 248                                               VLC_FALSE );
 249
 250     i_activity = var_GetInteger( p_playlist, "activity" );
 251     var_SetInteger( p_playlist, "activity", i_activity +
 252                     DIRECTORY_ACTIVITY );
 253
 254     ReadDir( p_playlist, psz_name, i_mode, p_current, p_item_in_category,
 255              p_current_input, (DIR *)p_access->p_sys, NULL );
 256
 257     i_activity = var_GetInteger( p_playlist, "activity" );
 258     var_SetInteger( p_playlist, "activity", i_activity -
 259                     DIRECTORY_ACTIVITY );
 260
 261     playlist_Signal( p_playlist );
 262
 263     if( psz_name ) free( psz_name );
 264     vlc_object_release( p_input );
 265     vlc_object_release( p_playlist );
 266
 267     /* Return fake data forever */
 268     p_access->pf_read = ReadNull;
 269     return -1;
 270 }
 271
 272 /*****************************************************************************
 273  * Control:
 274  *****************************************************************************/
 275 static int Control( access_t *p_access, int i_query, va_list args )
 276 {
 277     vlc_bool_t   *pb_bool;
 278     int          *pi_int;
 279     int64_t      *pi_64;
 280
 281     switch( i_query )
 282     {
 283         /* */
 284         case ACCESS_CAN_SEEK:
 285         case ACCESS_CAN_FASTSEEK:
 286         case ACCESS_CAN_PAUSE:
 287         case ACCESS_CAN_CONTROL_PACE:
 288             pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
 289             *pb_bool = VLC_FALSE;    /* FIXME */
 290             break;
 291
 292         /* */
 293         case ACCESS_GET_MTU:
 294             pi_int = (int*)va_arg( args, int * );
 295             *pi_int = 0;
 296             break;
 297
 298         case ACCESS_GET_PTS_DELAY:
 299             pi_64 = (int64_t*)va_arg( args, int64_t * );
 300             *pi_64 = DEFAULT_PTS_DELAY * 1000;
 301             break;
 302
 303         /* */
 304         case ACCESS_SET_PAUSE_STATE:
 305         case ACCESS_GET_TITLE_INFO:
 306         case ACCESS_SET_TITLE:
 307         case ACCESS_SET_SEEKPOINT:
 308         case ACCESS_SET_PRIVATE_ID_STATE:
 309         case ACCESS_GET_CONTENT_TYPE:
 310             return VLC_EGENERIC;
 311
 312         default:
 313             msg_Warn( p_access, "unimplemented query in control" );
 314             return VLC_EGENERIC;
 315     }
 316     return VLC_SUCCESS;
 317 }
 318
 319 /*****************************************************************************
 320  * DemuxOpen:
 321  *****************************************************************************/
 322 static int DemuxOpen ( vlc_object_t *p_this )
 323 {
 324     demux_t *p_demux = (demux_t*)p_this;
 325
 326     if( strcmp( p_demux->psz_demux, "directory" ) )
 327         return VLC_EGENERIC;
 328
 329     p_demux->pf_demux   = Demux;
 330     p_demux->pf_control = DemuxControl;
 331     return VLC_SUCCESS;
 332 }
 333
 334 /*****************************************************************************
 335  * Demux: EOF
 336  *****************************************************************************/
 337 static int Demux( demux_t *p_demux )
 338 {
 339     return 0;
 340 }
 341
 342 /*****************************************************************************
 343  * DemuxControl:
 344  *****************************************************************************/
 345 static int DemuxControl( demux_t *p_demux, int i_query, va_list args )
 346 {
 347     return demux2_vaControlHelper( p_demux->s, 0, 0, 0, 1, i_query, args );
 348 }
 349
 350
 351 static int Sort (const char **a, const char **b)
 352 {
 353     return strcoll (*a, *b);
 354 }
 355
 356 struct stat_list_t
 357 {
 358     stat_list_t *parent;
 359     struct stat st;
 360 };
 361
 362
 363 /*****************************************************************************
 364  * ReadDir: read a directory and add its content to the list
 365  *****************************************************************************/
 366 static int ReadDir( playlist_t *p_playlist, const char *psz_name,
 367                     int i_mode, playlist_item_t *p_parent,
 368                     playlist_item_t *p_parent_category,
 369                     input_item_t *p_current_input,
 370                     DIR *handle, stat_list_t *stparent )
 371 {
 372     char **pp_dir_content = NULL;
 373     int             i_dir_content, i, i_return = VLC_SUCCESS;
 374     playlist_item_t *p_node;
 375
 376     char **ppsz_extensions = NULL;
 377     int i_extensions = 0;
 378     char *psz_ignore;
 379
 380     struct stat_list_t stself;
 381 #ifndef WIN32
 382     int fd = dirfd (handle);
 383
 384     if ((fd == -1) || fstat (fd, &stself.st))
 385     {
 386         msg_Err (p_playlist, "cannot stat `%s': %m", psz_name);
 387         return VLC_EGENERIC;
 388     }
 389
 390     for (stat_list_t *stats = stparent; stats != NULL; stats = stats->parent)
 391     {
 392         if ((stself.st.st_ino == stats->st.st_ino)
 393          && (stself.st.st_dev == stats->st.st_dev))
 394         {
 395             msg_Warn (p_playlist,
 396                       "ignoring infinitely recursive directory `%s'",
 397                       psz_name);
 398             return VLC_SUCCESS;
 399         }
 400     }
 401 #else
 402         /* Windows has st_dev (driver letter - 'A'), but it zeroes st_ino,
 403          * so that the test above will always incorrectly succeed.
 404          * Besides, Windows does not have dirfd(). */
 405 #endif
 406
 407     stself.parent = stparent;
 408
 409     /* Get the first directory entry */
 410     i_dir_content = utf8_loaddir (handle, &pp_dir_content, NULL, Sort);
 411     if( i_dir_content == -1 )
 412     {
 413         msg_Err (p_playlist, "cannot read `%s': %m", psz_name);
 414         return VLC_EGENERIC;
 415     }
 416     else if( i_dir_content <= 0 )
 417     {
 418         /* directory is empty */
 419         msg_Dbg( p_playlist, "%s directory is empty", psz_name );
 420         free( pp_dir_content );
 421         return VLC_SUCCESS;
 422     }
 423
 424     /* Build array with ignores */
 425     psz_ignore = var_CreateGetString( p_playlist, "ignore-filetypes" );
 426     if( psz_ignore && *psz_ignore )
 427     {
 428         char *psz_parser = psz_ignore;
 429         int a;
 430
 431         for( a = 0; psz_parser[a] != '\0'; a++ )
 432         {
 433             if( psz_parser[a] == ',' ) i_extensions++;
 434         }
 435
 436         ppsz_extensions = (char **)calloc (i_extensions, sizeof (char *));
 437
 438         for( a = 0; a < i_extensions; a++ )
 439         {
 440             char *tmp, *ptr;
 441
 442             while( psz_parser[0] != '\0' && psz_parser[0] == ' ' ) psz_parser++;
 443             ptr = strchr( psz_parser, ',');
 444             tmp = ( ptr == NULL )
 445                  ? strdup( psz_parser )
 446                  : strndup( psz_parser, ptr - psz_parser );
 447
 448             ppsz_extensions[a] = tmp;
 449             psz_parser = ptr + 1;
 450         }
 451     }
 452     if( psz_ignore ) free( psz_ignore );
 453
 454     /* While we still have entries in the directory */
 455     for( i = 0; i < i_dir_content; i++ )
 456     {
 457         const char *entry = pp_dir_content[i];
 458         int i_size_entry = strlen( psz_name ) +
 459                            strlen( entry ) + 2 + 7 /* strlen("file://") */;
 460         char psz_uri[i_size_entry];
 461
 462         sprintf( psz_uri, "%s/%s", psz_name, entry);
 463
 464         /* if it starts with '.' then forget it */
 465         if (entry[0] != '.')
 466         {
 467             DIR *subdir = (i_mode != MODE_COLLAPSE)
 468                     ? OpenDir (VLC_OBJECT (p_playlist), psz_uri) : NULL;
 469
 470             if (subdir != NULL) /* Recurse into subdirectory */
 471             {
 472                 if( i_mode == MODE_NONE )
 473                 {
 474                     msg_Dbg( p_playlist, "skipping subdirectory `%s'",
 475                              psz_uri );
 476                     closedir (subdir);
 477                     continue;
 478                 }
 479
 480                 msg_Dbg (p_playlist, "creating subdirectory %s", psz_uri);
 481
 482                 p_node = playlist_NodeCreate( p_playlist, entry,
 483                                               p_parent_category,
 484                                               PLAYLIST_NO_REBUILD, NULL );
 485
 486                 /* If we had the parent in category, the it is now node.
 487                  * Else, we still don't have  */
 488                 i_return = ReadDir( p_playlist, psz_uri , MODE_EXPAND,
 489                                     p_node, p_parent_category ? p_node : NULL,
 490                                     p_current_input, subdir, &stself );
 491                 closedir (subdir);
 492                 if (i_return)
 493                     break; // error :-(
 494             }
 495             else
 496             {
 497                 input_item_t *p_input;
 498
 499                 if( i_extensions > 0 )
 500                 {
 501                     const char *psz_dot = strrchr (entry, '.' );
 502                     if( psz_dot++ && *psz_dot )
 503                     {
 504                         int a;
 505                         for( a = 0; a < i_extensions; a++ )
 506                         {
 507                             if( !strcmp( psz_dot, ppsz_extensions[a] ) )
 508                                 break;
 509                         }
 510                         if( a < i_extensions )
 511                         {
 512                             msg_Dbg( p_playlist, "ignoring file %s", psz_uri );
 513                             continue;
 514                         }
 515                     }
 516                 }
 517
 518                 memmove (psz_uri + 7, psz_uri, sizeof (psz_uri) - 7);
 519                 memcpy (psz_uri, "file://", 7);
 520                 p_input = input_ItemNewWithType( VLC_OBJECT(p_playlist),
 521                                                  psz_uri, entry, 0, NULL,
 522                                                  -1, ITEM_TYPE_FILE );
 523                 if (p_input != NULL)
 524                 {
 525                     if( p_current_input )
 526                         input_ItemCopyOptions( p_current_input, p_input );
 527                     playlist_BothAddInput( p_playlist, p_input,
 528                                            p_parent_category,
 529                                            PLAYLIST_APPEND|PLAYLIST_PREPARSE|
 530                                            PLAYLIST_NO_REBUILD,
 531                                            PLAYLIST_END, NULL, NULL,
 532                                            VLC_FALSE );
 533                     vlc_gc_decref( p_input );
 534                 }
 535             }
 536         }
 537     }
 538
 539     for( i = 0; i < i_extensions; i++ )
 540         if( ppsz_extensions[i] ) free( ppsz_extensions[i] );
 541     if( ppsz_extensions ) free( ppsz_extensions );
 542
 543     for( i = 0; i < i_dir_content; i++ )
 544         if( pp_dir_content[i] ) free( pp_dir_content[i] );
 545     if( pp_dir_content ) free( pp_dir_content );
 546
 547     return i_return;
 548 }
 549
 550
 551 static DIR *OpenDir (vlc_object_t *obj, const char *path)
 552 {
 553     msg_Dbg (obj, "opening directory `%s'", path);
 554     DIR *handle = utf8_opendir (path);
 555     if (handle == NULL)
 556     {
 557         int err = errno;
 558         if (err != ENOTDIR)
 559             msg_Err (obj, "%s: %m", path);
 560         else
 561             msg_Dbg (obj, "skipping non-directory `%s'", path);
 562         errno = err;
 563
 564         return NULL;
 565     }
 566     return handle;
 567 }