X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=fd.c;h=08a06589bc4294fd6c1c8f9f0ca54fdf407a96e8;hp=d53a3b4521fdbec1e16aa3263ba07f699feac40c;hb=ce5417393696b1e5b9964418e0f6938b1dc09e9b;hpb=bba06e19f5b28bcc459e7579e7ac711739873c07 diff --git a/fd.c b/fd.c index d53a3b45..08a06589 100644 --- a/fd.c +++ b/fd.c @@ -1,28 +1,18 @@ /* - * 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 */ -#include "para.h" - +#include +#include +#include #include #include +#include "para.h" #include "error.h" /** * check whether a file exists @@ -39,21 +29,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,25 +55,25 @@ 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 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 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; } @@ -119,29 +110,7 @@ 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 - * - * \return negative on errors, zero on end of file, and the number of bytes - * (not elements) read on success. - * - * \sa fread(3) - */ -__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) +* 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 @@ -166,3 +135,147 @@ again: 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 Positive on success, negative on errors. + */ +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 Positive on success, negative on errors. + * + * 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; + ret = -E_OPENDIR; + *dir = opendir("."); + if (!*dir) + goto change_to_orig_dir; + return 1; +/* Ignore return value of fchdir() and close(). We're busted anyway. */ +change_to_orig_dir: + if (cwd) + fchdir(*cwd); +close_cwd: + if (cwd) + close(*cwd); + return ret; +} + +/** + * A wrapper for fchdir(). + * + * \param fd An open file descriptor + * + * \return Positive on success, negative on errors. + */ +int para_fchdir(int fd) +{ + if (fchdir(fd) < 0) + return -E_FCHDIR; + 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); +}