git.sesse.net Git - vlc/blob - src/posix/filesystem.c

   1 /*****************************************************************************
   2  * filesystem.c: POSIX file system helpers
   3  *****************************************************************************
   4  * Copyright (C) 2005-2006 the VideoLAN team
   5  * Copyright © 2005-2008 Rémi Denis-Courmont
   6  *
   7  * Authors: Rémi Denis-Courmont <rem # videolan.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 #ifdef HAVE_CONFIG_H
  25 # include "config.h"
  26 #endif
  27
  28 #include <vlc_common.h>
  29 #include <vlc_charset.h>
  30 #include <vlc_fs.h>
  31 #include "libvlc.h" /* vlc_mkdir */
  32
  33 #include <assert.h>
  34
  35 #include <stdio.h>
  36 #include <limits.h> /* NAME_MAX */
  37 #include <errno.h>
  38 #include <sys/types.h>
  39 #include <unistd.h>
  40 #include <fcntl.h>
  41 #include <sys/stat.h>
  42 #include <dirent.h>
  43 #include <sys/socket.h>
  44
  45 #ifndef HAVE_LSTAT
  46 # define lstat( a, b ) stat(a, b)
  47 #endif
  48
  49 /**
  50  * Opens a system file handle.
  51  *
  52  * @param filename file path to open (with UTF-8 encoding)
  53  * @param flags open() flags, see the C library open() documentation
  54  * @return a file handle on success, -1 on error (see errno).
  55  * @note Contrary to standard open(), this function returns file handles
  56  * with the close-on-exec flag enabled.
  57  */
  58 int vlc_open (const char *filename, int flags, ...)
  59 {
  60     unsigned int mode = 0;
  61     va_list ap;
  62
  63     va_start (ap, flags);
  64     if (flags & O_CREAT)
  65         mode = va_arg (ap, unsigned int);
  66     va_end (ap);
  67
  68 #ifdef O_CLOEXEC
  69     flags |= O_CLOEXEC;
  70 #endif
  71
  72     const char *local_name = ToLocale (filename);
  73
  74     if (local_name == NULL)
  75     {
  76         errno = ENOENT;
  77         return -1;
  78     }
  79
  80     int fd = open (local_name, flags, mode);
  81     if (fd != -1)
  82         fcntl (fd, F_SETFD, FD_CLOEXEC);
  83
  84     LocaleFree (local_name);
  85     return fd;
  86 }
  87
  88 /**
  89  * Opens a system file handle relative to an existing directory handle.
  90  *
  91  * @param dir directory file descriptor
  92  * @param filename file path to open (with UTF-8 encoding)
  93  * @param flags open() flags, see the C library open() documentation
  94  * @return a file handle on success, -1 on error (see errno).
  95  * @note Contrary to standard open(), this function returns file handles
  96  * with the close-on-exec flag enabled.
  97  */
  98 int vlc_openat (int dir, const char *filename, int flags, ...)
  99 {
 100     unsigned int mode = 0;
 101     va_list ap;
 102
 103     va_start (ap, flags);
 104     if (flags & O_CREAT)
 105         mode = va_arg (ap, unsigned int);
 106     va_end (ap);
 107
 108 #ifdef O_CLOEXEC
 109     flags |= O_CLOEXEC;
 110 #endif
 111
 112     const char *local_name = ToLocale (filename);
 113     if (local_name == NULL)
 114     {
 115         errno = ENOENT;
 116         return -1;
 117     }
 118
 119 #ifdef HAVE_OPENAT
 120     int fd = openat (dir, local_name, flags, mode);
 121     if (fd != -1)
 122         fcntl (fd, F_SETFD, FD_CLOEXEC);
 123 #else
 124     int fd = -1;
 125     errno = ENOSYS;
 126 #endif
 127
 128     LocaleFree (local_name);
 129     return fd;
 130 }
 131
 132
 133 /**
 134  * Creates a directory using UTF-8 paths.
 135  *
 136  * @param dirname a UTF-8 string with the name of the directory that you
 137  *        want to create.
 138  * @param mode directory permissions
 139  * @return 0 on success, -1 on error (see errno).
 140  */
 141 int vlc_mkdir (const char *dirname, mode_t mode)
 142 {
 143     char *locname = ToLocale (dirname);
 144     if (unlikely(locname == NULL))
 145     {
 146         errno = ENOENT;
 147         return -1;
 148     }
 149
 150     int res = mkdir (locname, mode);
 151     LocaleFree (locname);
 152     return res;
 153 }
 154
 155 /**
 156  * Opens a DIR pointer.
 157  *
 158  * @param dirname UTF-8 representation of the directory name
 159  * @return a pointer to the DIR struct, or NULL in case of error.
 160  * Release with standard closedir().
 161  */
 162 DIR *vlc_opendir (const char *dirname)
 163 {
 164     const char *local_name = ToLocale (dirname);
 165     if (unlikely(local_name == NULL))
 166     {
 167         errno = ENOENT;
 168         return NULL;
 169     }
 170
 171     DIR *dir = opendir (local_name);
 172     LocaleFree (local_name);
 173     return dir;
 174 }
 175
 176 /**
 177  * Reads the next file name from an open directory.
 178  *
 179  * @param dir The directory that is being read
 180  *
 181  * @return a UTF-8 string of the directory entry. Use free() to release it.
 182  * If there are no more entries in the directory, NULL is returned.
 183  * If an error occurs, errno is set and NULL is returned.
 184  */
 185 char *vlc_readdir( DIR *dir )
 186 {
 187     /* Beware that readdir_r() assumes <buf> is large enough to hold the result
 188      * dirent including the file name. A buffer overflow could occur otherwise.
 189      * In particular, pathconf() and _POSIX_NAME_MAX cannot be used here. */
 190     struct dirent *ent;
 191     char *path = NULL;
 192
 193     long len = fpathconf (dirfd (dir), _PC_NAME_MAX);
 194     if (len == -1)
 195     {
 196 #ifdef NAME_MAX
 197         len = NAME_MAX;
 198 #else
 199         errno = ENOMEM;
 200         return NULL; // OS is broken. There is no sane way to fix this.
 201 #endif
 202     }
 203     len += offsetof (struct dirent, d_name) + 1;
 204
 205     struct dirent *buf = malloc (len);
 206     if (unlikely(buf == NULL))
 207         return NULL;
 208
 209     int val = readdir_r (dir, buf, &ent);
 210     if (val != 0)
 211         errno = val;
 212     else if (ent != NULL)
 213 #ifndef __APPLE__
 214         path = strdup (ent->d_name);
 215 #else
 216         path = FromCharset ("UTF-8-MAC", ent->d_name, strlen (ent->d_name));
 217 #endif
 218     free (buf);
 219     return path;
 220 }
 221
 222 static int vlc_statEx (const char *filename, struct stat *buf, bool deref)
 223 {
 224     const char *local_name = ToLocale (filename);
 225     if (unlikely(local_name == NULL))
 226     {
 227         errno = ENOENT;
 228         return -1;
 229     }
 230
 231     int res = deref ? stat (local_name, buf)
 232                     : lstat (local_name, buf);
 233     LocaleFree (local_name);
 234     return res;
 235 }
 236
 237 /**
 238  * Finds file/inode information, as stat().
 239  * Consider using fstat() instead, if possible.
 240  *
 241  * @param filename UTF-8 file path
 242  */
 243 int vlc_stat (const char *filename, struct stat *buf)
 244 {
 245     return vlc_statEx (filename, buf, true);
 246 }
 247
 248 /**
 249  * Finds file/inode information, as lstat().
 250  * Consider using fstat() instead, if possible.
 251  *
 252  * @param filename UTF-8 file path
 253  */
 254 int vlc_lstat (const char *filename, struct stat *buf)
 255 {
 256     return vlc_statEx (filename, buf, false);
 257 }
 258
 259 /**
 260  * Removes a file.
 261  *
 262  * @param filename a UTF-8 string with the name of the file you want to delete.
 263  * @return A 0 return value indicates success. A -1 return value indicates an
 264  *        error, and an error code is stored in errno
 265  */
 266 int vlc_unlink (const char *filename)
 267 {
 268     const char *local_name = ToLocale (filename);
 269     if (unlikely(local_name == NULL))
 270     {
 271         errno = ENOENT;
 272         return -1;
 273     }
 274
 275     int ret = unlink (local_name);
 276     LocaleFree (local_name);
 277     return ret;
 278 }
 279
 280 /**
 281  * Moves a file atomically. This only works within a single file system.
 282  *
 283  * @param oldpath path to the file before the move
 284  * @param newpath intended path to the file after the move
 285  * @return A 0 return value indicates success. A -1 return value indicates an
 286  *        error, and an error code is stored in errno
 287  */
 288 int vlc_rename (const char *oldpath, const char *newpath)
 289 {
 290     const char *lo = ToLocale (oldpath);
 291     if (lo == NULL)
 292         goto error;
 293
 294     const char *ln = ToLocale (newpath);
 295     if (ln == NULL)
 296     {
 297         LocaleFree (lo);
 298 error:
 299         errno = ENOENT;
 300         return -1;
 301     }
 302
 303     int ret = rename (lo, ln);
 304     LocaleFree (lo);
 305     LocaleFree (ln);
 306     return ret;
 307 }
 308
 309 /**
 310  * Duplicates a file descriptor. The new file descriptor has the close-on-exec
 311  * descriptor flag set.
 312  * @return a new file descriptor or -1
 313  */
 314 int vlc_dup (int oldfd)
 315 {
 316     int newfd;
 317
 318 #ifdef HAVE_DUP3
 319     /* Unfortunately, dup3() works like dup2(), not like plain dup(). So we
 320      * need such contortion to find the new file descriptor while preserving
 321      * thread safety of the file descriptor table. */
 322     newfd = vlc_open ("/dev/null", O_RDONLY);
 323     if (likely(newfd != -1))
 324     {
 325         if (likely(dup3 (oldfd, newfd, O_CLOEXEC) == newfd))
 326             return newfd;
 327         close (newfd);
 328     }
 329 #endif
 330
 331     newfd = dup (oldfd);
 332     if (likely(newfd != -1))
 333         fcntl (newfd, F_SETFD, FD_CLOEXEC);
 334     return newfd;
 335 }
 336
 337 /**
 338  * Creates a pipe (see "man pipe" for further reference).
 339  */
 340 int vlc_pipe (int fds[2])
 341 {
 342 #ifdef HAVE_PIPE2
 343     if (pipe2 (fds, O_CLOEXEC) == 0)
 344         return 0;
 345     if (errno != ENOSYS)
 346         return -1;
 347 #endif
 348
 349     if (pipe (fds))
 350         return -1;
 351
 352     fcntl (fds[0], F_SETFD, FD_CLOEXEC);
 353     fcntl (fds[1], F_SETFD, FD_CLOEXEC);
 354     return 0;
 355 }
 356
 357 #include <vlc_network.h>
 358
 359 /**
 360  * Creates a socket file descriptor. The new file descriptor has the
 361  * close-on-exec flag set.
 362  * @param pf protocol family
 363  * @param type socket type
 364  * @param proto network protocol
 365  * @param nonblock true to create a non-blocking socket
 366  * @return a new file descriptor or -1
 367  */
 368 int vlc_socket (int pf, int type, int proto, bool nonblock)
 369 {
 370     int fd;
 371
 372 #ifdef SOCK_CLOEXEC
 373     type |= SOCK_CLOEXEC;
 374     if (nonblock)
 375         type |= SOCK_NONBLOCK;
 376     fd = socket (pf, type, proto);
 377     if (fd != -1 || errno != EINVAL)
 378         return fd;
 379
 380     type &= ~(SOCK_CLOEXEC|SOCK_NONBLOCK);
 381 #endif
 382
 383     fd = socket (pf, type, proto);
 384     if (fd == -1)
 385         return -1;
 386
 387     fcntl (fd, F_SETFD, FD_CLOEXEC);
 388     if (nonblock)
 389         fcntl (fd, F_SETFL, fcntl (fd, F_GETFL, 0) | O_NONBLOCK);
 390     return fd;
 391 }
 392
 393 /**
 394  * Accepts an inbound connection request on a listening socket.
 395  * The new file descriptor has the close-on-exec flag set.
 396  * @param lfd listening socket file descriptor
 397  * @param addr pointer to the peer address or NULL [OUT]
 398  * @param alen pointer to the length of the peer address or NULL [OUT]
 399  * @param nonblock whether to put the new socket in non-blocking mode
 400  * @return a new file descriptor, or -1 on error.
 401  */
 402 int vlc_accept (int lfd, struct sockaddr *addr, socklen_t *alen, bool nonblock)
 403 {
 404 #ifdef HAVE_ACCEPT4
 405     int flags = SOCK_CLOEXEC;
 406     if (nonblock)
 407         flags |= SOCK_NONBLOCK;
 408
 409     do
 410     {
 411         int fd = accept4 (lfd, addr, alen, flags);
 412         if (fd != -1)
 413             return fd;
 414     }
 415     while (errno == EINTR);
 416
 417     if (errno != ENOSYS)
 418         return -1;
 419 #endif
 420
 421     do
 422     {
 423         int fd = accept (lfd, addr, alen);
 424         if (fd != -1)
 425         {
 426             fcntl (fd, F_SETFD, FD_CLOEXEC);
 427             if (nonblock)
 428                 fcntl (fd, F_SETFL, fcntl (fd, F_GETFL, 0) | O_NONBLOCK);
 429             return fd;
 430         }
 431     }
 432     while (errno == EINTR);
 433
 434     return -1;
 435 }