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  * Determines the current working directory.
 311  *
 312  * @return the current working directory (must be free()'d)
 313  *         or NULL on error
 314  */
 315 char *vlc_getcwd (void)
 316 {
 317     /* Try $PWD */
 318     const char *pwd = getenv ("PWD");
 319     if (pwd != NULL)
 320     {
 321         struct stat s1, s2;
 322         /* Make sure $PWD is correct */
 323         if (stat (pwd, &s1) == 0 && stat (".", &s2) == 0
 324          && s1.st_dev == s2.st_dev && s1.st_ino == s2.st_ino)
 325             return ToLocaleDup (pwd);
 326     }
 327
 328     /* Otherwise iterate getcwd() until the buffer is big enough */
 329     long path_max = pathconf (".", _PC_PATH_MAX);
 330     size_t size = (path_max == -1 || path_max > 4096) ? 4096 : path_max;
 331
 332     for (;; size *= 2)
 333     {
 334         char *buf = malloc (size);
 335         if (unlikely(buf == NULL))
 336             break;
 337
 338         if (getcwd (buf, size) != NULL)
 339 #ifdef ASSUME_UTF8
 340             return buf;
 341 #else
 342         {
 343             char *ret = ToLocaleDup (buf);
 344             free (buf);
 345             return ret; /* success */
 346         }
 347 #endif
 348         free (buf);
 349
 350         if (errno != ERANGE)
 351             break;
 352     }
 353     return NULL;
 354 }
 355
 356 /**
 357  * Duplicates a file descriptor. The new file descriptor has the close-on-exec
 358  * descriptor flag set.
 359  * @return a new file descriptor or -1
 360  */
 361 int vlc_dup (int oldfd)
 362 {
 363     int newfd;
 364
 365 #ifdef F_DUPFD_CLOEXEC
 366     newfd = fcntl (oldfd, F_DUPFD_CLOEXEC);
 367     if (unlikely(newfd == -1 && errno == EINVAL))
 368 #endif
 369     {
 370         newfd = dup (oldfd);
 371         if (likely(newfd != -1))
 372             fcntl (newfd, F_SETFD, FD_CLOEXEC);
 373     }
 374     return newfd;
 375 }
 376
 377 #ifdef __ANDROID__ /* && we support android < 2.3 */
 378 /* pipe2() is declared and available since android-9 NDK,
 379  * although it is available in libc.a since android-3
 380  * We redefine the function here in order to be able to run
 381  * on versions of Android older than 2.3
 382  */
 383 #include <sys/syscall.h>
 384 //#include <sys/linux-syscalls.h> // fucking brokeness
 385 int pipe2(int fds[2], int flags)
 386 {
 387     return syscall(/*__NR_pipe2 */ 359, fds, flags);
 388 }
 389 #endif /* __ANDROID__ */
 390
 391 /**
 392  * Creates a pipe (see "man pipe" for further reference).
 393  */
 394 int vlc_pipe (int fds[2])
 395 {
 396 #ifdef HAVE_PIPE2
 397     if (pipe2 (fds, O_CLOEXEC) == 0)
 398         return 0;
 399     if (errno != ENOSYS)
 400         return -1;
 401 #endif
 402
 403     if (pipe (fds))
 404         return -1;
 405
 406     fcntl (fds[0], F_SETFD, FD_CLOEXEC);
 407     fcntl (fds[1], F_SETFD, FD_CLOEXEC);
 408     return 0;
 409 }
 410
 411 #include <vlc_network.h>
 412
 413 /**
 414  * Creates a socket file descriptor. The new file descriptor has the
 415  * close-on-exec flag set.
 416  * @param pf protocol family
 417  * @param type socket type
 418  * @param proto network protocol
 419  * @param nonblock true to create a non-blocking socket
 420  * @return a new file descriptor or -1
 421  */
 422 int vlc_socket (int pf, int type, int proto, bool nonblock)
 423 {
 424     int fd;
 425
 426 #ifdef SOCK_CLOEXEC
 427     type |= SOCK_CLOEXEC;
 428     if (nonblock)
 429         type |= SOCK_NONBLOCK;
 430     fd = socket (pf, type, proto);
 431     if (fd != -1 || errno != EINVAL)
 432         return fd;
 433
 434     type &= ~(SOCK_CLOEXEC|SOCK_NONBLOCK);
 435 #endif
 436
 437     fd = socket (pf, type, proto);
 438     if (fd == -1)
 439         return -1;
 440
 441     fcntl (fd, F_SETFD, FD_CLOEXEC);
 442     if (nonblock)
 443         fcntl (fd, F_SETFL, fcntl (fd, F_GETFL, 0) | O_NONBLOCK);
 444     return fd;
 445 }
 446
 447 /**
 448  * Accepts an inbound connection request on a listening socket.
 449  * The new file descriptor has the close-on-exec flag set.
 450  * @param lfd listening socket file descriptor
 451  * @param addr pointer to the peer address or NULL [OUT]
 452  * @param alen pointer to the length of the peer address or NULL [OUT]
 453  * @param nonblock whether to put the new socket in non-blocking mode
 454  * @return a new file descriptor, or -1 on error.
 455  */
 456 int vlc_accept (int lfd, struct sockaddr *addr, socklen_t *alen, bool nonblock)
 457 {
 458 #ifdef HAVE_ACCEPT4
 459     int flags = SOCK_CLOEXEC;
 460     if (nonblock)
 461         flags |= SOCK_NONBLOCK;
 462
 463     do
 464     {
 465         int fd = accept4 (lfd, addr, alen, flags);
 466         if (fd != -1)
 467             return fd;
 468     }
 469     while (errno == EINTR);
 470
 471     if (errno != ENOSYS)
 472         return -1;
 473 #endif
 474
 475     do
 476     {
 477         int fd = accept (lfd, addr, alen);
 478         if (fd != -1)
 479         {
 480             fcntl (fd, F_SETFD, FD_CLOEXEC);
 481             if (nonblock)
 482                 fcntl (fd, F_SETFL, fcntl (fd, F_GETFL, 0) | O_NONBLOCK);
 483             return fd;
 484         }
 485     }
 486     while (errno == EINTR);
 487
 488     return -1;
 489 }