fd.c

   1 /*
   2  * Copyright (C) 2006-2007 Andre Noll <maan@systemlinux.org>
   3  *
   4  * Licensed under the GPL v2. For licencing details see COPYING.
   5  */
   6
   7 /** \file fd.c helper functions for file descriptor handling */
   8
   9 #include <sys/types.h>
  10 #include <dirent.h>
  11 #include <sys/mman.h>
  12 #include <fcntl.h>
  13 #include <sys/select.h>
  14
  15 #include "para.h"
  16 #include "error.h"
  17 /**
  18  * check whether a file exists
  19  *
  20  * \param fn the file name
  21  *
  22  * \return Non-zero iff file exists.
  23  */
  24 int file_exists(const char *fn)
  25 {
  26         struct stat statbuf;
  27
  28         return !stat(fn, &statbuf);
  29 }
  30
  31 /**
  32  * Paraslash's wrapper for select(2).
  33  *
  34  * It calls select(2) (with no exceptfds) and starts over if select() was
  35  * interrupted by a signal.
  36  *
  37  * \param n The highest-numbered descriptor in any of the two sets, plus 1.
  38  * \param readfds fds that should be checked for readability.
  39  * \param writefds fds that should be checked for writablility.
  40  * \param timeout_tv upper bound on the amount of time elapsed before select()
  41  * returns.
  42  *
  43  * \return The return value of the underlying select() call on success, the
  44  * negative system error code on errors.
  45  *
  46  * All arguments are passed verbatim to select(2).
  47  * \sa select(2) select_tut(2).
  48  */
  49 int para_select(int n, fd_set *readfds, fd_set *writefds,
  50                 struct timeval *timeout_tv)
  51 {
  52         int ret, err;
  53         do {
  54                 ret = select(n, readfds, writefds, NULL, timeout_tv);
  55                 err = errno;
  56         } while (ret < 0 && err == EINTR);
  57         if (ret < 0)
  58                 return -ERRNO_TO_PARA_ERROR(errno);
  59         return ret;
  60 }
  61
  62 /**
  63  * Set a file descriptor to non-blocking mode.
  64  *
  65  * \param fd The file descriptor.
  66  *
  67  * \return Standard.
  68  */
  69 int mark_fd_nonblock(int fd)
  70 {
  71         int flags = fcntl(fd, F_GETFL);
  72         if (flags < 0)
  73                 return -ERRNO_TO_PARA_ERROR(errno);
  74         flags = fcntl(fd, F_SETFL, ((long)flags) | O_NONBLOCK);
  75         if (flags < 0)
  76                 return -ERRNO_TO_PARA_ERROR(errno);
  77         return 1;
  78 }
  79
  80 /**
  81  * set a file descriptor in a fd_set
  82  *
  83  * \param fd the file descriptor to be set
  84  * \param fds the file descriptor set
  85  * \param max_fileno highest-numbered file descriptor
  86  *
  87  * This wrapper for FD_SET() passes its first two arguments to \p FD_SET. Upon
  88  * return, \a max_fileno contains the maximum of the old_value and \a fd.
  89  *
  90  * \sa para_select
  91 */
  92 void para_fd_set(int fd, fd_set *fds, int *max_fileno)
  93 {
  94
  95         if (fd < 0 || fd >= FD_SETSIZE) {
  96                 PARA_EMERG_LOG("fatal: tried to add invalid fd %d\n", fd);
  97                 exit(EXIT_FAILURE);
  98         }
  99 #if 0
 100         {
 101                 int flags = fcntl(fd, F_GETFL);
 102                 if (!(flags & O_NONBLOCK)) {
 103                         PARA_EMERG_LOG("fd %d is a blocking file descriptor\n", fd);
 104                         exit(EXIT_FAILURE);
 105                 }
 106         }
 107 #endif
 108         FD_SET(fd, fds);
 109         *max_fileno = PARA_MAX(*max_fileno, fd);
 110 }
 111
 112 /**
 113 * paraslash's wrapper for fgets(3)
 114 * \param line pointer to the buffer to store the line
 115 * \param size the size of the buffer given by \a line
 116 * \param f the stream to read from
 117 *
 118 * \return Unlike the standard fgets() function, an integer value
 119 * is returned. On success, this function returns 1. On errors, -E_FGETS
 120 * is returned. A zero return value indicates an end of file condition.
 121 */
 122 __must_check int para_fgets(char *line, int size, FILE *f)
 123 {
 124 again:
 125         if (fgets(line, size, f))
 126                 return 1;
 127         if (feof(f))
 128                 return 0;
 129         if (!ferror(f))
 130                 return -E_FGETS;
 131         if (errno != EINTR) {
 132                 PARA_ERROR_LOG("%s\n", strerror(errno));
 133                 return -E_FGETS;
 134         }
 135         clearerr(f);
 136         goto again;
 137 }
 138
 139 /**
 140  * Paraslash's wrapper for mmap.
 141  *
 142  * \param length number of bytes to mmap
 143  * \param prot either PROT_NONE or the bitwise OR of one or more of
 144  * PROT_EXEC PROT_READ PROT_WRITE
 145  * \param flags exactly one of MAP_SHARED and MAP_PRIVATE
 146  * \param fd the file to mmap from
 147  * \param offset mmap start
 148  *
 149  * \return This function either returns a valid pointer to the mapped area
 150  * or calls exit() on errors.
 151  */
 152 void *para_mmap(size_t length, int prot, int flags, int fd, off_t offset)
 153 {
 154         void *ret = mmap(NULL, length, prot, flags, fd, offset);
 155         if (ret != MAP_FAILED)
 156                 return ret;
 157         PARA_EMERG_LOG("mmap failed: %s\n", strerror(errno));
 158         PARA_EMERG_LOG("length: %zu, flags: %d, fd: %d, offset: %zu\n",
 159                 length, flags, fd, (size_t)offset);
 160         exit(EXIT_FAILURE);
 161 }
 162
 163 /**
 164  * Wrapper for the open(2) system call.
 165  *
 166  * \param path The filename.
 167  * \param flags The usual open(2) flags.
 168  * \param mode Specifies the permissions to use.
 169  *
 170  * The mode parameter must be specified when O_CREAT is in the flags, and is ignored
 171  * otherwise.
 172  *
 173  * \return The file descriptor on success, negative on errors.
 174  *
 175  * \sa open(2).
 176  */
 177 int para_open(const char *path, int flags, mode_t mode)
 178 {
 179         int ret = open(path, flags, mode);
 180
 181         if (ret >= 0)
 182                 return ret;
 183         return -ERRNO_TO_PARA_ERROR(errno);
 184 }
 185
 186 /**
 187  * Wrapper for chdir(2).
 188  *
 189  * \param path the specified directory.
 190  *
 191  * \return Positive on success, negative on errors.
 192  */
 193 int para_chdir(const char *path)
 194 {
 195         int ret = chdir(path);
 196
 197         if (ret >= 0)
 198                 return 1;
 199         return -ERRNO_TO_PARA_ERROR(errno);
 200 }
 201
 202 /**
 203  * Save the cwd and open a given directory.
 204  *
 205  * \param dirname Path to the directory to open.
 206  * \param dir Result pointer.
 207  * \param cwd File descriptor of the current working directory.
 208  *
 209  * \return Standard.
 210  *
 211  * Opening the current directory (".") and calling fchdir() to return is
 212  * usually faster and more reliable than saving cwd in some buffer and calling
 213  * chdir() afterwards.
 214  *
 215  * If \a cwd is not \p NULL "." is opened and the resulting file descriptor is
 216  * stored in \a cwd. If the function returns success, and \a cwd is not \p
 217  * NULL, the caller must close this file descriptor (probably after calling
 218  * fchdir(*cwd)).
 219  *
 220  * On errors, the function undos everything, so the caller needs neither close
 221  * any files, nor change back to the original working directory.
 222  *
 223  * \sa getcwd(3).
 224  *
 225  */
 226 int para_opendir(const char *dirname, DIR **dir, int *cwd)
 227 {
 228         int ret;
 229
 230         if (cwd) {
 231                 ret = para_open(".", O_RDONLY, 0);
 232                 if (ret < 0)
 233                         return ret;
 234                 *cwd = ret;
 235         }
 236         ret = para_chdir(dirname);
 237         if (ret < 0)
 238                 goto close_cwd;
 239         *dir = opendir(".");
 240         if (*dir)
 241                 return 1;
 242         ret = -ERRNO_TO_PARA_ERROR(errno);
 243 /* Ignore return value of fchdir() and close(). We're busted anyway. */
 244 change_to_orig_dir:
 245         if (cwd)
 246                 fchdir(*cwd);
 247 close_cwd:
 248         if (cwd)
 249                 close(*cwd);
 250         return ret;
 251 }
 252
 253 /**
 254  * A wrapper for fchdir().
 255  *
 256  * \param fd An open file descriptor
 257  *
 258  * \return Standard.
 259  */
 260 int para_fchdir(int fd)
 261 {
 262         if (fchdir(fd) < 0)
 263                 return -ERRNO_TO_PARA_ERROR(errno);
 264         return 1;
 265 }
 266
 267 /**
 268  * A wrapper for mkdir(2).
 269  *
 270  * \param path Name of the directory to create.
 271  * \param mode The permissions to use.
 272  *
 273  * \return Standard.
 274  */
 275 int para_mkdir(const char *path, mode_t mode)
 276 {
 277         if (!mkdir(path, mode))
 278                 return 1;
 279         return -ERRNO_TO_PARA_ERROR(errno);
 280 }