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

   1 /*****************************************************************************
   2  * filesystem.c: POSIX file system helpers
   3  *****************************************************************************
   4  * Copyright (C) 2005-2006 VLC authors and VideoLAN
   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 it
  10  * under the terms of the GNU Lesser General Public License as published by
  11  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this program; if not, write to the Free Software Foundation,
  21  * 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 <assert.h>
  29
  30 #include <stdio.h>
  31 #include <limits.h> /* NAME_MAX */
  32 #include <errno.h>
  33
  34 #include <sys/types.h>
  35 #include <unistd.h>
  36 #include <fcntl.h>
  37 #include <sys/stat.h>
  38 #ifndef HAVE_LSTAT
  39 # define lstat(a, b) stat(a, b)
  40 #endif
  41 #include <dirent.h>
  42 #include <sys/socket.h>
  43
  44 #include <vlc_common.h>
  45 #include <vlc_fs.h>
  46 #include "libvlc.h" /* vlc_mkdir */
  47
  48 /**
  49  * Opens a system file handle.
  50  *
  51  * @param filename file path to open (with UTF-8 encoding)
  52  * @param flags open() flags, see the C library open() documentation
  53  * @return a file handle on success, -1 on error (see errno).
  54  * @note Contrary to standard open(), this function returns file handles
  55  * with the close-on-exec flag enabled.
  56  */
  57 int vlc_open (const char *filename, int flags, ...)
  58 {
  59     unsigned int mode = 0;
  60     va_list ap;
  61
  62     va_start (ap, flags);
  63     if (flags & O_CREAT)
  64         mode = va_arg (ap, unsigned int);
  65     va_end (ap);
  66
  67 #ifdef O_CLOEXEC
  68     flags |= O_CLOEXEC;
  69 #endif
  70
  71     int fd = open (filename, flags, mode);
  72     if (fd != -1)
  73         fcntl (fd, F_SETFD, FD_CLOEXEC);
  74     return fd;
  75 }
  76
  77 /**
  78  * Opens a system file handle relative to an existing directory handle.
  79  *
  80  * @param dir directory file descriptor
  81  * @param filename file path to open (with UTF-8 encoding)
  82  * @param flags open() flags, see the C library open() documentation
  83  * @return a file handle on success, -1 on error (see errno).
  84  * @note Contrary to standard open(), this function returns file handles
  85  * with the close-on-exec flag enabled.
  86  */
  87 int vlc_openat (int dir, const char *filename, int flags, ...)
  88 {
  89     unsigned int mode = 0;
  90     va_list ap;
  91
  92     va_start (ap, flags);
  93     if (flags & O_CREAT)
  94         mode = va_arg (ap, unsigned int);
  95     va_end (ap);
  96
  97 #ifdef O_CLOEXEC
  98     flags |= O_CLOEXEC;
  99 #endif
 100
 101 #ifdef HAVE_OPENAT
 102     int fd = openat (dir, filename, flags, mode);
 103     if (fd != -1)
 104         fcntl (fd, F_SETFD, FD_CLOEXEC);
 105 #else
 106         VLC_UNUSED (dir);
 107         VLC_UNUSED (filename);
 108         VLC_UNUSED (mode);
 109
 110     int fd = -1;
 111     errno = ENOSYS;
 112 #endif
 113     return fd;
 114 }
 115
 116
 117 /**
 118  * Creates a directory using UTF-8 paths.
 119  *
 120  * @param dirname a UTF-8 string with the name of the directory that you
 121  *        want to create.
 122  * @param mode directory permissions
 123  * @return 0 on success, -1 on error (see errno).
 124  */
 125 int vlc_mkdir (const char *dirname, mode_t mode)
 126 {
 127     return mkdir (dirname, mode);
 128 }
 129
 130 /**
 131  * Opens a DIR pointer.
 132  *
 133  * @param dirname UTF-8 representation of the directory name
 134  * @return a pointer to the DIR struct, or NULL in case of error.
 135  * Release with standard closedir().
 136  */
 137 DIR *vlc_opendir (const char *dirname)
 138 {
 139     return opendir (dirname);
 140 }
 141
 142 /**
 143  * Reads the next file name from an open directory.
 144  *
 145  * @param dir directory handle as returned by vlc_opendir()
 146  *            (must not be used by another thread concurrently)
 147  *
 148  * @return a UTF-8 string of the directory entry. The string is valid until
 149  * the next call to vlc_readdir() or closedir() on the handle.
 150  * If there are no more entries in the directory, NULL is returned.
 151  * If an error occurs, errno is set and NULL is returned.
 152  */
 153 char *vlc_readdir( DIR *dir )
 154 {
 155     struct dirent *ent = readdir (dir);
 156     return (ent != NULL) ? ent->d_name : NULL;
 157 }
 158
 159 /**
 160  * Finds file/inode information, as stat().
 161  * Consider using fstat() instead, if possible.
 162  *
 163  * @param filename UTF-8 file path
 164  */
 165 int vlc_stat (const char *filename, struct stat *buf)
 166 {
 167     return stat (filename, buf);
 168 }
 169
 170 /**
 171  * Finds file/inode information, as lstat().
 172  * Consider using fstat() instead, if possible.
 173  *
 174  * @param filename UTF-8 file path
 175  */
 176 int vlc_lstat (const char *filename, struct stat *buf)
 177 {
 178     return lstat (filename, buf);
 179 }
 180
 181 /**
 182  * Removes a file.
 183  *
 184  * @param filename a UTF-8 string with the name of the file you want to delete.
 185  * @return A 0 return value indicates success. A -1 return value indicates an
 186  *        error, and an error code is stored in errno
 187  */
 188 int vlc_unlink (const char *filename)
 189 {
 190     return unlink (filename);
 191 }
 192
 193 /**
 194  * Moves a file atomically. This only works within a single file system.
 195  *
 196  * @param oldpath path to the file before the move
 197  * @param newpath intended path to the file after the move
 198  * @return A 0 return value indicates success. A -1 return value indicates an
 199  *        error, and an error code is stored in errno
 200  */
 201 int vlc_rename (const char *oldpath, const char *newpath)
 202 {
 203     return rename (oldpath, newpath);
 204 }
 205
 206 /**
 207  * Determines the current working directory.
 208  *
 209  * @return the current working directory (must be free()'d)
 210  *         or NULL on error
 211  */
 212 char *vlc_getcwd (void)
 213 {
 214     long path_max = pathconf (".", _PC_PATH_MAX);
 215     size_t size = (path_max == -1 || path_max > 4096) ? 4096 : path_max;
 216
 217     for (;; size *= 2)
 218     {
 219         char *buf = malloc (size);
 220         if (unlikely(buf == NULL))
 221             break;
 222
 223         if (getcwd (buf, size) != NULL)
 224             return buf;
 225         free (buf);
 226
 227         if (errno != ERANGE)
 228             break;
 229     }
 230     return NULL;
 231 }
 232
 233 /**
 234  * Duplicates a file descriptor. The new file descriptor has the close-on-exec
 235  * descriptor flag set.
 236  * @return a new file descriptor or -1
 237  */
 238 int vlc_dup (int oldfd)
 239 {
 240     int newfd;
 241
 242 #ifdef F_DUPFD_CLOEXEC
 243     newfd = fcntl (oldfd, F_DUPFD_CLOEXEC, 0);
 244     if (unlikely(newfd == -1 && errno == EINVAL))
 245 #endif
 246     {
 247         newfd = dup (oldfd);
 248         if (likely(newfd != -1))
 249             fcntl (newfd, F_SETFD, FD_CLOEXEC);
 250     }
 251     return newfd;
 252 }
 253
 254 /**
 255  * Creates a pipe (see "man pipe" for further reference).
 256  */
 257 int vlc_pipe (int fds[2])
 258 {
 259 #ifdef HAVE_PIPE2
 260     if (pipe2 (fds, O_CLOEXEC) == 0)
 261         return 0;
 262     if (errno != ENOSYS)
 263         return -1;
 264 #endif
 265
 266     if (pipe (fds))
 267         return -1;
 268
 269     fcntl (fds[0], F_SETFD, FD_CLOEXEC);
 270     fcntl (fds[1], F_SETFD, FD_CLOEXEC);
 271     return 0;
 272 }
 273
 274 #include <vlc_network.h>
 275
 276 /**
 277  * Creates a socket file descriptor. The new file descriptor has the
 278  * close-on-exec flag set.
 279  * @param pf protocol family
 280  * @param type socket type
 281  * @param proto network protocol
 282  * @param nonblock true to create a non-blocking socket
 283  * @return a new file descriptor or -1
 284  */
 285 int vlc_socket (int pf, int type, int proto, bool nonblock)
 286 {
 287     int fd;
 288
 289 #ifdef SOCK_CLOEXEC
 290     type |= SOCK_CLOEXEC;
 291     if (nonblock)
 292         type |= SOCK_NONBLOCK;
 293     fd = socket (pf, type, proto);
 294     if (fd != -1 || errno != EINVAL)
 295         return fd;
 296
 297     type &= ~(SOCK_CLOEXEC|SOCK_NONBLOCK);
 298 #endif
 299
 300     fd = socket (pf, type, proto);
 301     if (fd == -1)
 302         return -1;
 303
 304     fcntl (fd, F_SETFD, FD_CLOEXEC);
 305     if (nonblock)
 306         fcntl (fd, F_SETFL, fcntl (fd, F_GETFL, 0) | O_NONBLOCK);
 307     return fd;
 308 }
 309
 310 /**
 311  * Accepts an inbound connection request on a listening socket.
 312  * The new file descriptor has the close-on-exec flag set.
 313  * @param lfd listening socket file descriptor
 314  * @param addr pointer to the peer address or NULL [OUT]
 315  * @param alen pointer to the length of the peer address or NULL [OUT]
 316  * @param nonblock whether to put the new socket in non-blocking mode
 317  * @return a new file descriptor, or -1 on error.
 318  */
 319 int vlc_accept (int lfd, struct sockaddr *addr, socklen_t *alen, bool nonblock)
 320 {
 321 #ifdef HAVE_ACCEPT4
 322     int flags = SOCK_CLOEXEC;
 323     if (nonblock)
 324         flags |= SOCK_NONBLOCK;
 325
 326     do
 327     {
 328         int fd = accept4 (lfd, addr, alen, flags);
 329         if (fd != -1)
 330             return fd;
 331     }
 332     while (errno == EINTR);
 333
 334     if (errno != ENOSYS)
 335         return -1;
 336 #endif
 337
 338     do
 339     {
 340         int fd = accept (lfd, addr, alen);
 341         if (fd != -1)
 342         {
 343             fcntl (fd, F_SETFD, FD_CLOEXEC);
 344             if (nonblock)
 345                 fcntl (fd, F_SETFL, fcntl (fd, F_GETFL, 0) | O_NONBLOCK);
 346             return fd;
 347         }
 348     }
 349     while (errno == EINTR);
 350
 351     return -1;
 352 }