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 directory;
  65 struct directory
  66 {
  67     directory   *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 *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 *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 *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", p_dir->path, psz_entry) == -1)
 190         return ENTRY_EACCESS;
 191
 192     *handle = vlc_opendir (path);
 193
 194     free(path);
 195
 196     if (*handle == NULL) {
 197         return ENTRY_ENOTDIR;
 198     }
 199 #endif
 200
 201     return ENTRY_DIR;
 202 }
 203
 204 static bool directory_push (access_sys_t *p_sys, DIR *handle, char *psz_uri)
 205 {
 206     directory *p_dir = malloc (sizeof (*p_dir));
 207
 208     psz_uri = strdup (psz_uri);
 209     if (unlikely (p_dir == NULL || psz_uri == NULL))
 210         goto error;
 211
 212     p_dir->parent = p_sys->current;
 213     p_dir->handle = handle;
 214     p_dir->uri = psz_uri;
 215     p_dir->filec = vlc_loaddir (handle, &p_dir->filev, visible, p_sys->compar);
 216     if (p_dir->filec < 0)
 217         p_dir->filev = NULL;
 218     p_dir->i = 0;
 219
 220 #ifdef HAVE_OPENAT
 221     struct stat st;
 222     if (fstat (dirfd (handle), &st))
 223         goto error_filev;
 224     p_dir->device = st.st_dev;
 225     p_dir->inode = st.st_ino;
 226 #else
 227     p_dir->path = make_path (psz_uri);
 228     if (p_dir->path == NULL)
 229         goto error_filev;
 230 #endif
 231
 232     p_sys->current = p_dir;
 233     return true;
 234
 235 error_filev:
 236     for (int i = 0; i < p_dir->filec; i++)
 237         free (p_dir->filev[i]);
 238     free (p_dir->filev);
 239
 240 error:
 241     closedir (handle);
 242     free (p_dir);
 243     free (psz_uri);
 244     return false;
 245 }
 246
 247 static bool directory_pop (access_sys_t *p_sys)
 248 {
 249     directory *p_old = p_sys->current;
 250
 251     if (p_old == NULL)
 252         return false;
 253
 254     p_sys->current = p_old->parent;
 255     closedir (p_old->handle);
 256     free (p_old->uri);
 257     for (int i = 0; i < p_old->filec; i++)
 258         free (p_old->filev[i]);
 259     free (p_old->filev);
 260 #ifndef HAVE_OPENAT
 261     free (p_old->path);
 262 #endif
 263     free (p_old);
 264
 265     return p_sys->current != NULL;
 266 }
 267
 268
 269 /*****************************************************************************
 270  * Open: open the directory
 271  *****************************************************************************/
 272 int DirOpen (vlc_object_t *p_this)
 273 {
 274     access_t *p_access = (access_t*)p_this;
 275
 276     if (!p_access->psz_filepath)
 277         return VLC_EGENERIC;
 278
 279     DIR *handle = vlc_opendir (p_access->psz_filepath);
 280     if (handle == NULL)
 281         return VLC_EGENERIC;
 282
 283     return DirInit (p_access, handle);
 284 }
 285
 286 int DirInit (access_t *p_access, DIR *handle)
 287 {
 288     access_sys_t *p_sys = malloc (sizeof (*p_sys));
 289     if (unlikely (p_sys == NULL))
 290         goto error;
 291
 292     char *psz_sort = var_InheritString (p_access, "directory-sort");
 293     if (!psz_sort)
 294         p_sys->compar = collate;
 295     else if (!strcasecmp ( psz_sort, "version"))
 296         p_sys->compar = version;
 297     else if (!strcasecmp (psz_sort, "none"))
 298         p_sys->compar = NULL;
 299     else
 300         p_sys->compar = collate;
 301     free(psz_sort);
 302
 303     char *uri;
 304     if (!strcmp (p_access->psz_access, "fd"))
 305     {
 306         if (asprintf (&uri, "fd://%s", p_access->psz_location) == -1)
 307             uri = NULL;
 308     }
 309     else
 310         uri = vlc_path2uri (p_access->psz_filepath, "file");
 311     if (unlikely (uri == NULL))
 312     {
 313         closedir (handle);
 314         goto error;
 315     }
 316
 317     /* "Open" the base directory */
 318     p_sys->current = NULL;
 319     if (!directory_push (p_sys, handle, uri))
 320     {
 321         free (uri);
 322         goto error;
 323     }
 324     free (uri);
 325
 326     p_access->p_sys = p_sys;
 327     p_sys->ignored_exts = var_InheritString (p_access, "ignore-filetypes");
 328
 329     p_access->pf_readdir = DirRead;
 330     p_access->pf_control = DirControl;
 331
 332     return VLC_SUCCESS;
 333
 334 error:
 335     free (p_sys);
 336     return VLC_EGENERIC;
 337 }
 338
 339 /*****************************************************************************
 340  * Close: close the target
 341  *****************************************************************************/
 342 void DirClose( 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     while (directory_pop (p_sys))
 348         ;
 349
 350     free (p_sys->ignored_exts);
 351     free (p_sys);
 352 }
 353
 354 /* This function is a little bit too complex for what it seems to do, but the
 355  * point is to de-recursify directory recusion to avoid overruning the stack
 356  * in case there's a high directory depth */
 357 int DirRead (access_t *p_access, input_item_node_t *p_current_node)
 358 {
 359     access_sys_t *p_sys = p_access->p_sys;
 360
 361     while (p_sys->current != NULL
 362            && p_sys->current->i <= p_sys->current->filec)
 363     {
 364         directory *p_current = p_sys->current;
 365
 366         /* End of the current folder, let's pop directory and node */
 367         if (p_current->i == p_current->filec)
 368         {
 369             directory_pop (p_sys);
 370             p_current_node = p_current_node->p_parent;
 371             continue;
 372         }
 373
 374         char *psz_entry = p_current->filev[p_current->i++];
 375         char *psz_full_uri, *psz_uri;
 376         DIR *handle;
 377         input_item_t *p_new = NULL;
 378         int i_res;
 379
 380         /* Check if it is a directory or even readable */
 381         i_res = directory_open (p_current, psz_entry, &handle);
 382
 383         if (i_res == ENTRY_EACCESS
 384             || (i_res == ENTRY_ENOTDIR && has_ext (p_sys->ignored_exts, psz_entry)))
 385             continue;
 386
 387
 388         /* Create an input item for the current entry */
 389         psz_uri = encode_URI_component (psz_entry);
 390         if (psz_uri == NULL
 391          || asprintf (&psz_full_uri, "%s/%s", p_current->uri, psz_uri) == -1)
 392             psz_full_uri = NULL;
 393
 394         free (psz_uri);
 395         if (psz_full_uri == NULL)
 396         {
 397             closedir (handle);
 398             continue;
 399         }
 400
 401         int i_type = i_res == ENTRY_DIR ? ITEM_TYPE_DIRECTORY : ITEM_TYPE_FILE;
 402         p_new = input_item_NewWithType (psz_full_uri, psz_entry,
 403                                         0, NULL, 0, 0, i_type);
 404         if (p_new == NULL)
 405         {
 406             free (psz_full_uri);
 407             closedir (handle);
 408             continue;
 409         }
 410
 411         input_item_CopyOptions (p_current_node->p_item, p_new);
 412         input_item_node_AppendItem (p_current_node, p_new);
 413
 414         free (psz_full_uri);
 415         input_item_Release (p_new);
 416     }
 417
 418     return VLC_SUCCESS;
 419 }
 420
 421 /*****************************************************************************
 422  * Control:
 423  *****************************************************************************/
 424 int DirControl (access_t *p_access, int i_query, va_list args)
 425 {
 426     VLC_UNUSED (p_access);
 427
 428     switch (i_query)
 429     {
 430         case ACCESS_CAN_SEEK:
 431         case ACCESS_CAN_FASTSEEK:
 432             *va_arg (args, bool*) = false;
 433             break;
 434
 435         case ACCESS_CAN_PAUSE:
 436         case ACCESS_CAN_CONTROL_PACE:
 437             *va_arg (args, bool*) = true;
 438             break;
 439
 440         case ACCESS_GET_PTS_DELAY:
 441             *va_arg (args, int64_t *) = DEFAULT_PTS_DELAY * 1000;
 442             break;
 443
 444         default:
 445             return VLC_EGENERIC;
 446      }
 447      return VLC_SUCCESS;
 448  }