X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=fd.c;h=58851723978fb3c9856f87aa35d65a7141c162d7;hp=30623d1b321b8dfed84b07c33034fc20e05dd351;hb=128e2e3112f2260e35ee48f1db415c577a058edd;hpb=25e6054e929908d9e21a2dd39996117e93124da5 diff --git a/fd.c b/fd.c index 30623d1b..58851723 100644 --- a/fd.c +++ b/fd.c @@ -1,33 +1,49 @@ /* - * Copyright (C) 2006-2007 Andre Noll + * Copyright (C) 2006-2008 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 "para.h" +#include +#include #include #include #include +#include "para.h" #include "error.h" + +/** + * Write a buffer to a file descriptor, re-write on short writes. + * + * \param fd The file descriptor. + * \param buf The buffer to be sent. + * \param len The length of \a buf. + * + * \return Standard. In any case, the number of bytes that have been written is + * stored in \a len. + */ +int write_all(int fd, const char *buf, size_t *len) +{ + size_t total = *len; + + assert(total); + *len = 0; + while (*len < total) { + int ret = write(fd, buf + *len, total - *len); + if (ret == -1) + return -ERRNO_TO_PARA_ERROR(errno); + *len += ret; + } + return 1; +} + /** - * 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. */ @@ -39,21 +55,22 @@ 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 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 + * 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_tv) @@ -64,39 +81,57 @@ int para_select(int n, fd_set *readfds, fd_set *writefds, err = errno; } while (ret < 0 && err == EINTR); if (ret < 0) - PARA_CRIT_LOG("select error: %s, max_fileno: %d\n", - strerror(err), n); + 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 + * \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) +__must_check int mark_fd_blocking(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 + * Set a file descriptor to non-blocking mode. * - * \param fd the file descriptor to be set - * \param fds the file descriptor set - * \param max_fileno highest-numbered file descriptor + * \param fd The file descriptor. + * + * \return Standard. + */ +__must_check int mark_fd_nonblocking(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 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 + * \sa para_select. */ void para_fd_set(int fd, fd_set *fds, int *max_fileno) { @@ -119,37 +154,16 @@ void para_fd_set(int fd, fd_set *fds, int *max_fileno) } /** - * paraslash's wrapper for fread(3) - * - * \param dest destination pointer - * \param nbytes size of one element - * \param nmemb number of elements to write - * \param stream the input stream + * Paraslash's wrapper for fgets(3). * - * \return negative on errors, zero on end of file, and the number of bytes - * (not elements) read on success. + * \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. * - * \sa fread(3) + * \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_fread(void *dest, size_t nbytes, size_t nmemb, FILE *stream) -{ - size_t res = fread(dest, nbytes, nmemb, stream); - if (res == nmemb) - return nbytes * nmemb; - if (feof(stream)) - return 0; - return -E_FREAD; -} -/** -* 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: @@ -168,41 +182,247 @@ again: } /** - * paralash's wrapper for fseek(3) + * 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 stream stream to seek - * \param offset added to the position specified by whence - * \param whence \p SEEK_SET, \p SEEK_CUR, or \p SEEK_END + * \param path The filename. + * \param flags The usual open(2) flags. + * \param mode Specifies the permissions to use. * - * \return positive on success, -E_FSEEK on errors. + * The mode parameter must be specified when O_CREAT is in the flags, and is + * ignored otherwise. * - * \sa fseek(3) + * \return The file descriptor on success, negative on errors. + * + * \sa open(2). */ -int para_fseek(FILE *stream, long offset, int whence) +int para_open(const char *path, int flags, mode_t mode) { - int ret = fseek(stream, offset, whence); - return ret < 0? -E_FSEEK : 1; + int ret = open(path, flags, mode); + + if (ret >= 0) + return ret; + return -ERRNO_TO_PARA_ERROR(errno); } /** - * *paraslash's wrapper for mmap + * Wrapper for chdir(2). * - * \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 + * \param path The specified directory. * - * \return This function either returns a valid pointer to the mapped area - * or calls exit() on errors. + * \return Standard. */ -void *para_mmap(size_t length, int prot, int flags, int fd, off_t offset) +int para_chdir(const char *path) { - void *ret = mmap(NULL, length, prot, flags, fd, offset); - if (ret != MAP_FAILED) + 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; - PARA_EMERG_LOG("mmap failed: %s", strerror(errno)); - exit(EXIT_FAILURE); + 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) +{ + int err; + if (munmap(start, length) >= 0) + return 1; + err = errno; + PARA_ERROR_LOG("munmap (%p/%zu) failed: %s\n", start, length, + strerror(err)); + return -ERRNO_TO_PARA_ERROR(err); +} + +/** + * 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; +}