X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=fd.c;h=8f506ff83044dd23ec098961d9607908bc7ce402;hp=81ba5cffb7e6919ec7eca5d4fdfd9d0aecc92f61;hb=3e3b0dce3c7b301392f0a4fcbf8ac72bbc76b141;hpb=83632cf4e091d02defa4646eaeb38e5decab52f1;ds=sidebyside diff --git a/fd.c b/fd.c index 81ba5cff..8f506ff8 100644 --- a/fd.c +++ b/fd.c @@ -1,29 +1,24 @@ /* - * Copyright (C) 2006 Andre Noll + * Copyright (C) 2006-2007 Andre Noll * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. + * Licensed under the GPL v2. For licencing details see COPYING. */ -/** \file fd.c helper functions for file descriptor handling */ +/** \file fd.c Helper functions for file descriptor handling. */ + +#include +#include +#include +#include +#include #include "para.h" #include "error.h" + /** - * check whether a file exists + * Check whether a file exists. * - * \param fn the file name + * \param fn The file name. * * \return Non-zero iff file exists. */ @@ -35,49 +30,372 @@ int file_exists(const char *fn) } /** - * paraslash's wrapper for select(2) + * Paraslash's wrapper for select(2). * * It calls select(2) (with no exceptfds) and starts over if select() was * interrupted by a signal. * - * \param n the highest-numbered descriptor in any of the two sets, plus 1 - * \param readfds fds that should be checked for readability - * \param writefds fds that should be checked for writablility - * \param timeout upper bound on the amount of time elapsed before select() - * returns + * \param n The highest-numbered descriptor in any of the two sets, plus 1. + * \param readfds fds that should be checked for readability. + * \param writefds fds that should be checked for writablility. + * \param timeout_tv upper bound on the amount of time elapsed before select() + * returns. * - * \return The return value of the underlying select() call. + * \return The return value of the underlying select() call on success, the + * negative system error code on errors. * * All arguments are passed verbatim to select(2). - * \sa select(2) select_tut(2) + * \sa select(2) select_tut(2). */ int para_select(int n, fd_set *readfds, fd_set *writefds, - struct timeval *timeout) + struct timeval *timeout_tv) { int ret, err; do { - ret = select(n, readfds, writefds, NULL, timeout); + ret = select(n, readfds, writefds, NULL, timeout_tv); err = errno; } while (ret < 0 && err == EINTR); if (ret < 0) - PARA_CRIT_LOG("select error (%s)\n", strerror(err)); + return -ERRNO_TO_PARA_ERROR(errno); return ret; } /** - * set a file descriptor to non-blocking mode + * Set a file descriptor to blocking mode. + * + * \param fd The file descriptor. + * + * \return Standard. + */ +int mark_fd_blocking(int fd) +{ + int flags = fcntl(fd, F_GETFL); + if (flags < 0) + return -ERRNO_TO_PARA_ERROR(errno); + flags = fcntl(fd, F_SETFL, ((long)flags) & ~O_NONBLOCK); + if (flags < 0) + return -ERRNO_TO_PARA_ERROR(errno); + return 1; +} + +/** + * Set a file descriptor to non-blocking mode. * - * \param fd The file descriptor + * \param fd The file descriptor. * - * \returns 1 on success, -E_F_GETFL, -E_F_SETFL, on errors. + * \return Standard. */ -int mark_fd_nonblock(int fd) +int mark_fd_nonblocking(int fd) { int flags = fcntl(fd, F_GETFL); if (flags < 0) - return -E_F_GETFL; - if (fcntl(fd, F_SETFL, ((long)flags) | O_NONBLOCK) < 0) - return -E_F_SETFL; + return -ERRNO_TO_PARA_ERROR(errno); + flags = fcntl(fd, F_SETFL, ((long)flags) | O_NONBLOCK); + if (flags < 0) + return -ERRNO_TO_PARA_ERROR(errno); + return 1; +} + +/** + * Set a file descriptor in a fd_set. + * + * \param fd The file descriptor to be set. + * \param fds The file descriptor set. + * \param max_fileno Highest-numbered file descriptor. + * + * This wrapper for FD_SET() passes its first two arguments to \p FD_SET. Upon + * return, \a max_fileno contains the maximum of the old_value and \a fd. + * + * \sa para_select. +*/ +void para_fd_set(int fd, fd_set *fds, int *max_fileno) +{ + + if (fd < 0 || fd >= FD_SETSIZE) { + PARA_EMERG_LOG("fatal: tried to add invalid fd %d\n", fd); + exit(EXIT_FAILURE); + } +#if 0 + { + int flags = fcntl(fd, F_GETFL); + if (!(flags & O_NONBLOCK)) { + PARA_EMERG_LOG("fd %d is a blocking file descriptor\n", fd); + exit(EXIT_FAILURE); + } + } +#endif + FD_SET(fd, fds); + *max_fileno = PARA_MAX(*max_fileno, fd); +} + +/** +* Paraslash's wrapper for fgets(3). + +* \param line Pointer to the buffer to store the line. +* \param size The size of the buffer given by \a line. +* \param f The stream to read from. +* +* \return Unlike the standard fgets() function, an integer value +* is returned. On success, this function returns 1. On errors, -E_FGETS +* is returned. A zero return value indicates an end of file condition. +*/ +__must_check int para_fgets(char *line, int size, FILE *f) +{ +again: + if (fgets(line, size, f)) + return 1; + if (feof(f)) + return 0; + if (!ferror(f)) + return -E_FGETS; + if (errno != EINTR) { + PARA_ERROR_LOG("%s\n", strerror(errno)); + return -E_FGETS; + } + clearerr(f); + goto again; +} + +/** + * Paraslash's wrapper for mmap. + * + * \param length Number of bytes to mmap. + * \param prot Either PROT_NONE or the bitwise OR of one or more of + * PROT_EXEC PROT_READ PROT_WRITE. + * \param flags Exactly one of MAP_SHARED and MAP_PRIVATE. + * \param fd The file to mmap from. + * \param offset Mmap start. + * + * \return This function either returns a valid pointer to the mapped area + * or calls exit() on errors. + */ +void *para_mmap(size_t length, int prot, int flags, int fd, off_t offset) +{ + void *ret = mmap(NULL, length, prot, flags, fd, offset); + if (ret != MAP_FAILED) + return ret; + PARA_EMERG_LOG("mmap failed: %s\n", strerror(errno)); + PARA_EMERG_LOG("length: %zu, flags: %d, fd: %d, offset: %zu\n", + length, flags, fd, (size_t)offset); + exit(EXIT_FAILURE); +} + +/** + * Wrapper for the open(2) system call. + * + * \param path The filename. + * \param flags The usual open(2) flags. + * \param mode Specifies the permissions to use. + * + * The mode parameter must be specified when O_CREAT is in the flags, and is + * ignored otherwise. + * + * \return The file descriptor on success, negative on errors. + * + * \sa open(2). + */ +int para_open(const char *path, int flags, mode_t mode) +{ + int ret = open(path, flags, mode); + + if (ret >= 0) + return ret; + return -ERRNO_TO_PARA_ERROR(errno); +} + +/** + * Wrapper for chdir(2). + * + * \param path The specified directory. + * + * \return Standard. + */ +int para_chdir(const char *path) +{ + int ret = chdir(path); + + if (ret >= 0) + return 1; + return -ERRNO_TO_PARA_ERROR(errno); +} + +/** + * Save the cwd and open a given directory. + * + * \param dirname Path to the directory to open. + * \param dir Result pointer. + * \param cwd File descriptor of the current working directory. + * + * \return Standard. + * + * Opening the current directory (".") and calling fchdir() to return is + * usually faster and more reliable than saving cwd in some buffer and calling + * chdir() afterwards. + * + * If \a cwd is not \p NULL "." is opened and the resulting file descriptor is + * stored in \a cwd. If the function returns success, and \a cwd is not \p + * NULL, the caller must close this file descriptor (probably after calling + * fchdir(*cwd)). + * + * On errors, the function undos everything, so the caller needs neither close + * any files, nor change back to the original working directory. + * + * \sa getcwd(3). + * + */ +int para_opendir(const char *dirname, DIR **dir, int *cwd) +{ + int ret; + + if (cwd) { + ret = para_open(".", O_RDONLY, 0); + if (ret < 0) + return ret; + *cwd = ret; + } + ret = para_chdir(dirname); + if (ret < 0) + goto close_cwd; + *dir = opendir("."); + if (*dir) + return 1; + ret = -ERRNO_TO_PARA_ERROR(errno); +/* Ignore return value of fchdir() and close(). We're busted anyway. */ + if (cwd) + fchdir(*cwd); +close_cwd: + if (cwd) + close(*cwd); + return ret; +} + +/** + * A wrapper for fchdir(). + * + * \param fd An open file descriptor. + * + * \return Standard. + */ +int para_fchdir(int fd) +{ + if (fchdir(fd) < 0) + return -ERRNO_TO_PARA_ERROR(errno); return 1; } +/** + * A wrapper for mkdir(2). + * + * \param path Name of the directory to create. + * \param mode The permissions to use. + * + * \return Standard. + */ +int para_mkdir(const char *path, mode_t mode) +{ + if (!mkdir(path, mode)) + return 1; + return -ERRNO_TO_PARA_ERROR(errno); +} + +/** + * Open a file and map it into memory. + * + * \param path Name of the regular file to map. + * \param open_mode Either \p O_RDONLY or \p O_RDWR. + * \param map On success, the mapping is returned here. + * \param size size of the mapping. + * \param fd_ptr The file descriptor of the mapping. + * + * If \a fd_ptr is \p NULL, the file descriptor resulting from the underlying + * open call is closed after mmap(). Otherwise the file is kept open and the + * file descriptor is returned in \a fd_ptr. + * + * \return Standard. + * + * \sa para_open(), mmap(2). + */ +int mmap_full_file(const char *path, int open_mode, void **map, + size_t *size, int *fd_ptr) +{ + int fd, ret, mmap_prot, mmap_flags; + struct stat file_status; + + if (open_mode == O_RDONLY) { + mmap_prot = PROT_READ; + mmap_flags = MAP_PRIVATE; + } else { + mmap_prot = PROT_READ | PROT_WRITE; + mmap_flags = MAP_SHARED; + } + ret = para_open(path, open_mode, 0); + if (ret < 0) + return ret; + fd = ret; + if (fstat(fd, &file_status) < 0) { + ret = -ERRNO_TO_PARA_ERROR(errno); + goto out; + } + *size = file_status.st_size; + ret = -E_EMPTY; + PARA_DEBUG_LOG("%s: size %zu\n", path, *size); + if (!*size) + goto out; + *map = mmap(NULL, *size, mmap_prot, mmap_flags, fd, 0); + if (*map == MAP_FAILED) { + *map = NULL; + ret = -E_MMAP; + goto out; + } + ret = 1; +out: + if (ret < 0 || !fd_ptr) + close(fd); + else + *fd_ptr = fd; + return ret; +} + +/** + * A wrapper for munmap(2). + * + * \param start The start address of the memory mapping. + * \param length The size of the mapping. + * + * \return Positive on success, \p -E_MUNMAP on errors. + * + * \sa munmap(2), mmap_full_file(). + */ +int para_munmap(void *start, size_t length) +{ + if (munmap(start, length) >= 0) + return 1; + PARA_ERROR_LOG("munmap (%p/%zu) failed: %s\n", start, length, + strerror(errno)); + return -E_MUNMAP; +} + +/** + * check a file descriptor for writability + * + * \param fd the file descriptor + * + * \return positive if fd is ready for writing, zero if it isn't, negative if + * an error occurred. + */ + +int write_ok(int fd) +{ + struct timeval tv = {0, 0}; + fd_set wfds; + int ret; +again: + FD_ZERO(&wfds); + FD_SET(fd, &wfds); + tv.tv_sec = 0; + tv.tv_usec = 0; + ret = select(fd + 1, NULL, &wfds, NULL, &tv); + if (ret < 0 && errno == EINTR) + goto again; + return ret; +}