X-Git-Url: http://git.tuebingen.mpg.de/?a=blobdiff_plain;f=fd.c;h=cc38f1afba150e0de41fff093c0c5b7ccb24e377;hb=15f6e433432a6ba8e021c74b0f28ecd545721d42;hp=3dc490cde1056db92e94108cb7ad3c97131d32d5;hpb=b9c2428555a2a6edb038234a33e5072dc8c5ba7a;p=paraslash.git diff --git a/fd.c b/fd.c index 3dc490cd..cc38f1af 100644 --- a/fd.c +++ b/fd.c @@ -1,8 +1,4 @@ -/* - * Copyright (C) 2006-2009 Andre Noll - * - * Licensed under the GPL v2. For licencing details see COPYING. - */ +/* Copyright (C) 2006 Andre Noll , see file COPYING. */ /** \file fd.c Helper functions for file descriptor handling. */ @@ -10,118 +6,301 @@ #include #include #include -#include -#include #include "para.h" #include "error.h" #include "string.h" +#include "fd.h" /** - * Write a buffer to a file descriptor, re-write on short writes. + * Change the name or location of a file. * - * \param fd The file descriptor. - * \param buf The buffer to be sent. - * \param len The length of \a buf. + * \param oldpath File to be moved. + * \param newpath Destination. + * + * This is just a simple wrapper for the rename(2) system call which returns a + * paraslash error code and prints an error message on failure. + * + * \return Standard. * - * \return Standard. In any case, the number of bytes that have been written is - * stored in \a len. + * \sa rename(2). */ -int write_all(int fd, const char *buf, size_t *len) +int xrename(const char *oldpath, const char *newpath) { - size_t total = *len; + int ret = rename(oldpath, newpath); - 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; + if (ret >= 0) + return 1; + ret = -ERRNO_TO_PARA_ERROR(errno); + PARA_ERROR_LOG("failed to rename %s -> %s\n", oldpath, newpath); + return ret; } /** - * Write a buffer to a non-blocking file descriptor. + * Write an array of buffers, handling non-fatal errors. * - * \param fd The file descriptor. - * \param buf the buffer to write. - * \param len the number of bytes of \a buf. - * \param max_bytes_per_write Do not write more than that many bytes at once. + * \param fd The file descriptor to write to. + * \param iov Pointer to one or more buffers. + * \param iovcnt The number of buffers. + * + * EAGAIN, EWOULDBLOCK and EINTR are not considered error conditions. If a + * write operation fails with EAGAIN or EWOULDBLOCK, the number of bytes that + * have been written so far is returned. In the EINTR case the operation is + * retried. Short writes are handled by issuing a subsequent write operation + * for the remaining part. + * + * \return Negative on fatal errors, number of bytes written else. * - * If \a max_bytes_per_write is non-zero, do not send more than that many bytes - * per write(). + * For blocking file descriptors, this function returns either the sum of all + * buffer sizes or a negative error code which indicates the fatal error that + * caused a write call to fail. * - * EAGAIN is not considered an error condition. For example CCID3 has a - * sending wait queue which fills up and is emptied asynchronously. The EAGAIN - * case means that there is currently no space in the wait queue, but this can - * change at any moment. + * For nonblocking file descriptors there is a third possibility: Any + * non-negative return value less than the sum of the buffer sizes indicates + * that a write operation returned EAGAIN/EWOULDBLOCK. * - * \return Negative on errors, number of bytes written else. + * \sa writev(2), \ref xwrite(). */ -int write_nonblock(int fd, const char *buf, size_t len, - size_t max_bytes_per_write) +int xwritev(int fd, struct iovec *iov, int iovcnt) { size_t written = 0; - int ret = 0; - - while (written < len) { - size_t num = len - written; - - if (max_bytes_per_write && max_bytes_per_write < num) - num = max_bytes_per_write; - ret = write(fd, buf + written, num); - if (ret < 0 && errno == EAGAIN) + int i; + struct iovec saved_iov, *curiov; + + i = 0; + curiov = iov; + saved_iov = *curiov; + while (i < iovcnt && curiov->iov_len > 0) { + ssize_t ret = writev(fd, curiov, iovcnt - i); + if (ret >= 0) { + written += ret; + while (ret > 0) { + if (ret < curiov->iov_len) { + curiov->iov_base += ret; + curiov->iov_len -= ret; + break; + } + ret -= curiov->iov_len; + *curiov = saved_iov; + i++; + if (i >= iovcnt) + return written; + curiov++; + saved_iov = *curiov; + } + continue; + } + if (errno == EINTR) + /* + * The write() call was interrupted by a signal before + * any data was written. Try again. + */ + continue; + if (errno == EAGAIN || errno == EWOULDBLOCK) + /* + * We don't consider this an error. Note that POSIX + * allows either error to be returned, and does not + * require these constants to have the same value. + */ return written; - if (ret < 0) - return -ERRNO_TO_PARA_ERROR(errno); - written += ret; + /* fatal error */ + return -ERRNO_TO_PARA_ERROR(errno); } return written; } /** - * Check whether a file exists. + * Write a buffer to a file descriptor, re-writing on short writes. + * + * \param fd The file descriptor. + * \param buf The buffer to write. + * \param len The number of bytes to write. + * + * This is a simple wrapper for \ref xwritev(). + * + * \return The return value of the underlying call to \ref xwritev(). + */ +int xwrite(int fd, const char *buf, size_t len) +{ + struct iovec iov = {.iov_base = (void *)buf, .iov_len = len}; + return xwritev(fd, &iov, 1); +} + +/** + * Write to a file descriptor, fail on short writes. * - * \param fn The file name. + * \param fd The file descriptor. + * \param buf The buffer to be written. + * \param len The length of the buffer. * - * \return Non-zero iff file exists. + * For blocking file descriptors this function behaves identical to \ref + * xwrite(). For non-blocking file descriptors it returns -E_SHORT_WRITE + * (rather than a value less than len) if not all data could be written. + * + * \return Number of bytes written on success, negative error code else. */ -int file_exists(const char *fn) +int write_all(int fd, const char *buf, size_t len) { - struct stat statbuf; + int ret = xwrite(fd, buf, len); - return !stat(fn, &statbuf); + if (ret < 0) + return ret; + if (ret != len) + return -E_SHORT_WRITE; + return ret; } /** - * Paraslash's wrapper for select(2). + * A fprintf-like function for raw file descriptors. * - * It calls select(2) (with no exceptfds) and starts over if select() was - * interrupted by a signal. + * This function creates a string buffer according to the given format and + * writes this buffer to a file descriptor. * - * \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. + * \param fd The file descriptor. + * \param fmt A format string. * - * \return The return value of the underlying select() call on success, the - * negative system error code on errors. + * The difference to fprintf(3) is that the first argument is a file + * descriptor, not a FILE pointer. This function does not rely on stdio. * - * All arguments are passed verbatim to select(2). - * \sa select(2) select_tut(2). + * \return The return value of the underlying call to \ref write_all(). + * + * \sa fprintf(3), \ref xvasprintf(). */ -int para_select(int n, fd_set *readfds, fd_set *writefds, - struct timeval *timeout_tv) +__printf_2_3 int write_va_buffer(int fd, const char *fmt, ...) { + char *msg; int ret; - do - ret = select(n, readfds, writefds, NULL, timeout_tv); - while (ret < 0 && errno == EINTR); + va_list ap; + + va_start(ap, fmt); + ret = xvasprintf(&msg, fmt, ap); + va_end(ap); + ret = write_all(fd, msg, ret); + free(msg); + return ret; +} + +/** + * Read from a non-blocking file descriptor into multiple buffers. + * + * \param fd The file descriptor to read from. + * \param iov Scatter/gather array used in readv(). + * \param iovcnt Number of elements in \a iov. + * \param num_bytes Result pointer. Contains the number of bytes read from \a fd. + * + * This function tries to read up to sz bytes from fd, where sz is the sum of + * the lengths of all vectors in iov. Like \ref xwrite(), EAGAIN and EINTR are + * not considered error conditions. However, EOF is. + * + * \return Zero or a negative error code. If the underlying call to readv(2) + * returned zero (indicating an end of file condition) or failed for some + * reason other than EAGAIN or EINTR, a negative error code is returned. + * + * In any case, \a num_bytes contains the number of bytes that have been + * successfully read from \a fd (zero if the first readv() call failed with + * EAGAIN). Note that even if the function returns negative, some data might + * have been read before the error occurred. In this case \a num_bytes is + * positive. + * + * \sa \ref xwrite(), read(2), readv(2). + */ +int readv_nonblock(int fd, struct iovec *iov, int iovcnt, size_t *num_bytes) +{ + int ret, i, j; + + *num_bytes = 0; + for (i = 0, j = 0; i < iovcnt;) { + /* fix up the first iov */ + assert(j < iov[i].iov_len); + iov[i].iov_base += j; + iov[i].iov_len -= j; + ret = readv(fd, iov + i, iovcnt - i); + iov[i].iov_base -= j; + iov[i].iov_len += j; + + if (ret == 0) + return -E_EOF; + if (ret < 0) { + if (errno == EAGAIN || errno == EINTR) + return 0; + return -ERRNO_TO_PARA_ERROR(errno); + } + *num_bytes += ret; + while (ret > 0) { + if (ret < iov[i].iov_len - j) { + j += ret; + break; + } + ret -= iov[i].iov_len - j; + j = 0; + if (++i >= iovcnt) + break; + } + } + return 0; +} + +/** + * Read from a non-blocking file descriptor into a single buffer. + * + * \param fd The file descriptor to read from. + * \param buf The buffer to read data to. + * \param sz The size of \a buf. + * \param num_bytes \see \ref readv_nonblock(). + * + * This is a simple wrapper for readv_nonblock() which uses an iovec with a single + * buffer. + * + * \return The return value of the underlying call to readv_nonblock(). + */ +int read_nonblock(int fd, void *buf, size_t sz, size_t *num_bytes) +{ + struct iovec iov = {.iov_base = buf, .iov_len = sz}; + return readv_nonblock(fd, &iov, 1, num_bytes); +} + +/** + * Read a buffer and check its content for a pattern. + * + * \param fd The file descriptor to receive from. + * \param pattern The expected pattern. + * \param bufsize The size of the internal buffer. + * + * This function tries to read at most \a bufsize bytes from the non-blocking + * file descriptor \a fd. If at least \p strlen(\a pattern) bytes have been + * received, the beginning of the received buffer is compared with \a pattern, + * ignoring case. + * + * \return Positive if \a pattern was received, negative on errors, zero if no data + * was available to read. + * + * \sa \ref read_nonblock(), \sa strncasecmp(3). + */ +int read_pattern(int fd, const char *pattern, size_t bufsize) +{ + size_t n, len; + char *buf = alloc(bufsize + 1); + int ret = read_nonblock(fd, buf, bufsize, &n); + + buf[n] = '\0'; if (ret < 0) - return -ERRNO_TO_PARA_ERROR(errno); + goto out; + ret = 0; + if (n == 0) + goto out; + ret = -E_READ_PATTERN; + len = strlen(pattern); + if (n < len) + goto out; + if (strncasecmp(buf, pattern, len) != 0) + goto out; + ret = 1; +out: + if (ret < 0) { + PARA_NOTICE_LOG("%s\n", para_strerror(-ret)); + PARA_NOTICE_LOG("recvd %zu bytes: %s\n", n, buf); + } + free(buf); return ret; } @@ -161,62 +340,6 @@ __must_check int mark_fd_nonblocking(int fd) 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) -{ - assert(fd >= 0 && fd < FD_SETSIZE); -#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. * @@ -225,22 +348,20 @@ again: * 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 map Result pointer. * * \return Standard. * * \sa mmap(2). */ -int para_mmap(size_t length, int prot, int flags, int fd, off_t offset, - void *map) +int para_mmap(size_t length, int prot, int flags, int fd, void *map) { void **m = map; errno = EINVAL; if (!length) goto err; - *m = mmap(NULL, length, prot, flags, fd, offset); + *m = mmap(NULL, length, prot, flags, fd, (off_t)0); if (*m != MAP_FAILED) return 1; err: @@ -271,22 +392,6 @@ int para_open(const char *path, int flags, mode_t mode) 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. * @@ -311,19 +416,21 @@ int para_chdir(const char *path) * \sa getcwd(3). * */ -int para_opendir(const char *dirname, DIR **dir, int *cwd) +static int para_opendir(const char *dirname, DIR **dir, int *cwd) { int ret; + *dir = NULL; if (cwd) { ret = para_open(".", O_RDONLY, 0); if (ret < 0) return ret; *cwd = ret; } - ret = para_chdir(dirname); - if (ret < 0) + if (chdir(dirname) != 0) { + ret = -ERRNO_TO_PARA_ERROR(errno); goto close_cwd; + } *dir = opendir("."); if (*dir) return 1; @@ -338,20 +445,6 @@ 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). * @@ -406,7 +499,23 @@ int mmap_full_file(const char *path, int open_mode, void **map, goto out; } *size = file_status.st_size; - ret = para_mmap(*size, mmap_prot, mmap_flags, fd, 0, map); + /* + * If the file is empty, *size is zero and mmap() would return EINVAL + * (Invalid argument). This error is common enough to spend an extra + * error code which explicitly states the problem. + */ + ret = -E_EMPTY; + if (*size == 0) + goto out; + /* + * If fd refers to a directory, mmap() returns ENODEV (No such device), + * at least on Linux. "Is a directory" seems to be more to the point. + */ + ret = -ERRNO_TO_PARA_ERROR(EISDIR); + if (S_ISDIR(file_status.st_mode)) + goto out; + + ret = para_mmap(*size, mmap_prot, mmap_flags, fd, map); out: if (ret < 0 || !fd_ptr) close(fd); @@ -421,13 +530,16 @@ out: * \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. + * \return Standard. * - * \sa munmap(2), mmap_full_file(). + * \sa munmap(2), \ref mmap_full_file(). */ int para_munmap(void *start, size_t length) { int err; + + if (!start) + return 0; if (munmap(start, length) >= 0) return 1; err = errno; @@ -436,6 +548,47 @@ int para_munmap(void *start, size_t length) return -ERRNO_TO_PARA_ERROR(err); } +/** + * Simple wrapper for poll(2). + * + * It calls poll(2) and starts over if the call was interrupted by a signal. + * + * \param fds See poll(2). + * \param nfds See poll(2). + * \param timeout See poll(2). + * + * \return The return value of the underlying poll() call on success, the + * negative paraslash error code on errors. + * + * All arguments are passed verbatim to poll(2). + */ +int xpoll(struct pollfd *fds, nfds_t nfds, int timeout) +{ + int ret; + + do + ret = poll(fds, nfds, timeout); + while (ret < 0 && errno == EINTR); + return ret < 0? -ERRNO_TO_PARA_ERROR(errno) : ret; +} + +/** + * Check a file descriptor for readability. + * + * \param fd The file descriptor. + * + * \return positive if fd is ready for reading, zero if it isn't, negative if + * an error occurred. + * + * \sa \ref write_ok(). + */ +int read_ok(int fd) +{ + struct pollfd pfd = {.fd = fd, .events = POLLIN}; + int ret = xpoll(&pfd, 1, 0); + return ret < 0? ret : pfd.revents & POLLIN; +} + /** * Check a file descriptor for writability. * @@ -443,18 +596,14 @@ int para_munmap(void *start, size_t length) * * \return positive if fd is ready for writing, zero if it isn't, negative if * an error occurred. + * + * \sa \ref read_ok(). */ - int write_ok(int fd) { - struct timeval tv; - fd_set wfds; - - FD_ZERO(&wfds); - FD_SET(fd, &wfds); - tv.tv_sec = 0; - tv.tv_usec = 0; - return para_select(fd + 1, NULL, &wfds, &tv); + struct pollfd pfd = {.fd = fd, .events = POLLOUT}; + int ret = xpoll(&pfd, 1, 0); + return ret < 0? ret : pfd.revents & POLLOUT; } /** @@ -462,8 +611,6 @@ int write_ok(int fd) * * Common approach that opens /dev/null until it gets a file descriptor greater * than two. - * - * \sa okir's Black Hats Manual. */ void valid_fd_012(void) { @@ -497,7 +644,7 @@ int for_each_file_in_dir(const char *dirname, { DIR *dir; struct dirent *entry; - int cwd_fd, ret2, ret = para_opendir(dirname, &dir, &cwd_fd); + int cwd_fd, ret = para_opendir(dirname, &dir, &cwd_fd); if (ret < 0) return ret == -ERRNO_TO_PARA_ERROR(EACCES)? 1 : ret; @@ -533,9 +680,8 @@ int for_each_file_in_dir(const char *dirname, ret = 1; out: closedir(dir); - ret2 = para_fchdir(cwd_fd); - if (ret2 < 0 && ret >= 0) - ret = ret2; + if (fchdir(cwd_fd) < 0 && ret >= 0) + ret = -ERRNO_TO_PARA_ERROR(errno); close(cwd_fd); return ret; }