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

   1 /*****************************************************************************
   2  * directory.c: expands a directory (directory: access_browser plug-in)
   3  *****************************************************************************
   4  * Copyright (C) 2002-2008 VLC authors and VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Derk-Jan Hartman <hartman at videolan dot org>
   8  *          Rémi Denis-Courmont
   9  *          Julien 'Lta' BALLET <contact # lta.io>
  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
  30 #ifdef HAVE_CONFIG_H
  31 # include "config.h"
  32 #endif
  33
  34 #include <vlc_common.h>
  35 #include "fs.h"
  36 #include <vlc_access.h>
  37 #include <vlc_input_item.h>
  38
  39 #include <sys/types.h>
  40 #include <sys/stat.h>
  41 #include <errno.h>
  42 #include <unistd.h>
  43 #include <fcntl.h>
  44
  45 #include <vlc_fs.h>
  46 #include <vlc_url.h>
  47 #include <vlc_strings.h>
  48 #include <vlc_charset.h>
  49
  50 enum
  51 {
  52     ENTRY_DIR       = 0,
  53     ENTRY_ENOTDIR   = -1,
  54     ENTRY_EACCESS   = -2,
  55 };
  56
  57 enum
  58 {
  59     MODE_NONE,
  60     MODE_COLLAPSE,
  61     MODE_EXPAND,
  62 };
  63
  64 typedef struct directory_t directory_t;
  65 struct directory_t
  66 {
  67     directory_t *parent;
  68     DIR         *handle;
  69     char        *uri;
  70     char       **filev;
  71     int          filec, i;
  72 #ifdef HAVE_OPENAT
  73     dev_t        device;
  74     ino_t        inode;
  75 #else
  76     char         *path;
  77 #endif
  78 };
  79
  80 struct access_sys_t
  81 {
  82     directory_t *current;
  83     char *ignored_exts;
  84     char mode;
  85     int (*compar) (const char **a, const char **b);
  86 };
  87
  88 /* Select non-hidden files only */
  89 static int visible (const char *name)
  90 {
  91     return name[0] != '.';
  92 }
  93
  94 static int collate (const char **a, const char **b)
  95 {
  96 #ifdef HAVE_STRCOLL
  97     return strcoll (*a, *b);
  98 #else
  99     return strcmp  (*a, *b);
 100 #endif
 101 }
 102
 103 static int version (const char **a, const char **b)
 104 {
 105     return strverscmp (*a, *b);
 106 }
 107
 108 /**
 109  * Does the provided URI/path/stuff has one of the extension provided ?
 110  *
 111  * \param psz_exts A comma separated list of extension without dot, or only
 112  * one ext (ex: "avi,mkv,webm")
 113  * \param psz_uri The uri/path to check (ex: "file:///home/foo/bar.avi"). If
 114  * providing an URI, it must not contain a query string.
 115  *
 116  * \return true if the uri/path has one of the provided extension
 117  * false otherwise.
 118  */
 119 static bool has_ext (const char *psz_exts, const char *psz_uri)
 120 {
 121     if (psz_exts == NULL)
 122         return false;
 123
 124     const char *ext = strrchr (psz_uri, '.');
 125     if (ext == NULL)
 126         return false;
 127
 128     size_t extlen = strlen (++ext);
 129
 130     for (const char *type = psz_exts, *end; type[0]; type = end + 1)
 131     {
 132         end = strchr (type, ',');
 133         if (end == NULL)
 134             end = type + strlen (type);
 135
 136         if (type + extlen == end && !strncasecmp (ext, type, extlen))
 137             return true;
 138
 139         if (*end == '\0')
 140             break;
 141     }
 142
 143     return false;
 144 }
 145
 146
 147 #ifdef HAVE_OPENAT
 148 /* Detect directories that recurse into themselves. */
 149 static bool has_inode_loop (const directory_t *dir, dev_t dev, ino_t inode)
 150 {
 151     while (dir != NULL)
 152     {
 153         if ((dir->device == dev) && (dir->inode == inode))
 154             return true;
 155         dir = dir->parent;
 156     }
 157     return false;
 158 }
 159 #endif
 160
 161 /* success -> returns ENTRY_DIR and the handle parameter is set to the handle,
 162  * error -> return ENTRY_ENOTDIR or ENTRY_EACCESS */
 163 static int directory_open (directory_t *p_dir, char *psz_entry, DIR **handle)
 164 {
 165     *handle = NULL;
 166
 167 #ifdef HAVE_OPENAT
 168     int fd = vlc_openat (dirfd (p_dir->handle), psz_entry,
 169                          O_RDONLY | O_DIRECTORY);
 170
 171     if (fd == -1)
 172     {
 173         if (errno == ENOTDIR)
 174             return ENTRY_ENOTDIR;
 175         else
 176             return ENTRY_EACCESS;
 177     }
 178
 179     struct stat st;
 180     if (fstat (fd, &st)
 181         || has_inode_loop (p_dir, st.st_dev, st.st_ino)
 182         || (*handle = fdopendir (fd)) == NULL)
 183     {
 184         close (fd);
 185         return ENTRY_EACCESS;
 186     }
 187 #else
 188     char *path;
 189     if (asprintf (&path, "%s/%s", current->path, entry) == -1)
 190         goto ENTRY_EACCESS;
 191     if ((*handle = vlc_opendir (path)) == NULL)
 192         goto ENTRY_ENOTDIR;
 193 #endif
 194
 195     return ENTRY_DIR;
 196 }
 197
 198 static bool directory_push (access_sys_t *p_sys, DIR *handle, char *psz_uri)
 199 {
 200     directory_t *p_dir;
 201
 202     p_dir = malloc (sizeof (*p_dir));
 203     if (unlikely (p_dir == NULL))
 204         return NULL;
 205
 206     psz_uri = strdup (psz_uri);
 207     if (unlikely (psz_uri == NULL))
 208         goto error;
 209
 210     p_dir->parent = p_sys->current;
 211     p_dir->handle = handle;
 212     p_dir->uri = psz_uri;
 213     p_dir->filec = vlc_loaddir (handle, &p_dir->filev, visible, p_sys->compar);
 214     if (p_dir->filec < 0)
 215         p_dir->filev = NULL;
 216     p_dir->i = 0;
 217
 218 #ifdef HAVE_OPENAT
 219     struct stat st;
 220     if (fstat (dirfd (handle), &st))
 221         goto error;
 222     p_dir->device = st.st_dev;
 223     p_dir->inode = st.st_ino;
 224 #else
 225     p_dir->path = make_path (psz_uri);
 226     if (p_dir->path == NULL)
 227         goto error;
 228 #endif
 229
 230     p_sys->current = p_dir;
 231     return true;
 232
 233     error:
 234     closedir (handle);
 235     free (p_dir);
 236     free (psz_uri);
 237
 238     return false;
 239 }
 240
 241 static bool directory_pop (access_sys_t *p_sys)
 242 {
 243     directory_t *p_old = p_sys->current;
 244
 245     if (p_old == NULL)
 246         return false;
 247
 248     p_sys->current = p_old->parent;
 249     closedir (p_old->handle);
 250     free (p_old->uri);
 251     free (p_old->filev);
 252 #ifndef HAVE_OPENAT
 253     free (p_old->path);
 254 #endif
 255     free (p_old);
 256
 257     return p_sys->current != NULL;
 258 }
 259
 260
 261 /*****************************************************************************
 262  * Open: open the directory
 263  *****************************************************************************/
 264 int DirOpen (vlc_object_t *p_this)
 265 {
 266     access_t *p_access = (access_t*)p_this;
 267
 268     if (!p_access->psz_filepath)
 269         return VLC_EGENERIC;
 270
 271     DIR *handle = vlc_opendir (p_access->psz_filepath);
 272     if (handle == NULL)
 273         return VLC_EGENERIC;
 274
 275     return DirInit (p_access, handle);
 276 }
 277
 278 int DirInit (access_t *p_access, DIR *handle)
 279 {
 280     access_sys_t *p_sys = malloc (sizeof (*p_sys));
 281     if (unlikely (p_sys == NULL))
 282         goto error;
 283
 284     char *psz_sort = var_InheritString (p_access, "directory-sort");
 285     if (!psz_sort)
 286         p_sys->compar = collate;
 287     else if (!strcasecmp ( psz_sort, "version"))
 288         p_sys->compar = version;
 289     else if (!strcasecmp (psz_sort, "none"))
 290         p_sys->compar = NULL;
 291     else
 292         p_sys->compar = collate;
 293     free(psz_sort);
 294
 295     char *uri;
 296     if (!strcmp (p_access->psz_access, "fd"))
 297     {
 298         if (asprintf (&uri, "fd://%s", p_access->psz_location) == -1)
 299             uri = NULL;
 300     }
 301     else
 302         uri = vlc_path2uri (p_access->psz_filepath, "file");
 303     if (unlikely (uri == NULL))
 304         goto error;
 305
 306     /* "Open" the base directory */
 307     p_sys->current = NULL;
 308     if (!directory_push (p_sys, handle, uri))
 309     {
 310         free (uri);
 311         goto error;
 312     }
 313     free (uri);
 314
 315     p_access->p_sys = p_sys;
 316     p_sys->ignored_exts = var_InheritString (p_access, "ignore-filetypes");
 317
 318
 319     /* Handle mode */
 320     char *psz_rec = var_InheritString (p_access, "recursive");
 321     if (psz_rec == NULL || !strcasecmp (psz_rec, "none"))
 322         p_sys->mode = MODE_NONE;
 323     else if (!strcasecmp (psz_rec, "collapse"))
 324         p_sys->mode = MODE_COLLAPSE;
 325     else
 326         p_sys->mode = MODE_EXPAND;
 327     free (psz_rec);
 328
 329     p_access->pf_readdir = DirRead;
 330     p_access->pf_control = DirControl;
 331
 332     return VLC_SUCCESS;
 333
 334 error:
 335     closedir (handle);
 336     free (p_sys);
 337     return VLC_EGENERIC;
 338 }
 339
 340 /*****************************************************************************
 341  * Close: close the target
 342  *****************************************************************************/
 343 void DirClose( vlc_object_t * p_this )
 344 {
 345     access_t *p_access = (access_t*)p_this;
 346     access_sys_t *p_sys = p_access->p_sys;
 347
 348     while (directory_pop (p_sys))
 349         ;
 350
 351     free (p_sys->ignored_exts);
 352     free (p_sys);
 353 }
 354
 355 /* This function is a little bit too complex for what it seems to do, but the
 356  * point is to de-recursify directory recusion to avoid overruning the stack
 357  * in case there's a high directory depth */
 358 int DirRead (access_t *p_access, input_item_node_t *p_current_node)
 359 {
 360     access_sys_t *p_sys = p_access->p_sys;
 361
 362     while (p_sys->current != NULL
 363            && p_sys->current->i <= p_sys->current->filec)
 364     {
 365         directory_t *p_current = p_sys->current;
 366
 367         /* End of the current folder, let's pop directory and node */
 368         if (p_current->i == p_current->filec)
 369         {
 370             directory_pop (p_sys);
 371             p_current_node = p_current_node->p_parent;
 372             continue;
 373         }
 374
 375         char *psz_entry = p_current->filev[p_current->i++];
 376         char *psz_full_uri, *psz_uri;
 377         DIR *handle;
 378         input_item_t *p_new = NULL;
 379         int i_res;
 380
 381         /* Check if it is a directory or even readable */
 382         i_res = directory_open (p_current, psz_entry, &handle);
 383
 384         if (i_res == ENTRY_EACCESS
 385             || (i_res == ENTRY_DIR && p_sys->mode == MODE_NONE)
 386             || (i_res == ENTRY_ENOTDIR && has_ext (p_sys->ignored_exts, psz_entry)))
 387             continue;
 388
 389
 390         /* Create an input item for the current entry */
 391         psz_uri = encode_URI_component (psz_entry);
 392         if (psz_uri == NULL
 393             || asprintf (&psz_full_uri, "%s/%s", p_current->uri, psz_uri) == -1)
 394         {
 395             closedir (handle);
 396             continue;
 397         }
 398         free (psz_uri);
 399
 400         int i_type = i_res == ENTRY_DIR ? ITEM_TYPE_DIRECTORY : ITEM_TYPE_FILE;
 401         p_new = input_item_NewWithType (psz_full_uri, psz_entry,
 402                                         0, NULL, 0, 0, i_type);
 403         if (p_new == NULL)
 404         {
 405             free (psz_full_uri);
 406             closedir (handle);
 407             continue;
 408         }
 409
 410         input_item_CopyOptions (p_current_node->p_item, p_new);
 411         input_item_node_t *p_new_node = input_item_node_AppendItem (p_current_node, p_new);
 412
 413         /* Handle directory flags and recursion if in EXPAND mode  */
 414         if (i_res == ENTRY_DIR)
 415         {
 416             if (p_sys->mode == MODE_EXPAND
 417                 && directory_push (p_sys, handle, psz_full_uri))
 418             {
 419                 p_current_node = p_new_node;
 420             }
 421         }
 422
 423         free (psz_full_uri);
 424         input_item_Release (p_new);
 425     }
 426
 427     return VLC_SUCCESS;
 428 }
 429
 430 /*****************************************************************************
 431  * Control:
 432  *****************************************************************************/
 433 int DirControl (access_t *p_access, int i_query, va_list args)
 434 {
 435     VLC_UNUSED (p_access);
 436
 437     switch (i_query)
 438     {
 439         case ACCESS_CAN_SEEK:
 440         case ACCESS_CAN_FASTSEEK:
 441             *va_arg (args, bool*) = false;
 442             break;
 443
 444         case ACCESS_CAN_PAUSE:
 445         case ACCESS_CAN_CONTROL_PACE:
 446             *va_arg (args, bool*) = true;
 447             break;
 448
 449         case ACCESS_GET_PTS_DELAY:
 450             *va_arg (args, int64_t *) = DEFAULT_PTS_DELAY * 1000;
 451             break;
 452
 453         default:
 454             return VLC_EGENERIC;
 455      }
 456      return VLC_SUCCESS;
 457  }