X-Git-Url: http://git.tuebingen.mpg.de/?a=blobdiff_plain;f=fd.c;h=cc38f1afba150e0de41fff093c0c5b7ccb24e377;hb=15f6e433432a6ba8e021c74b0f28ecd545721d42;hp=0347fd83b7f4340019811b853e7eab5e9dccce36;hpb=3998a8c581623224b7b56bce593646b2c8516a0f;p=paraslash.git diff --git a/fd.c b/fd.c index 0347fd83..cc38f1af 100644 --- a/fd.c +++ b/fd.c @@ -37,26 +37,27 @@ int xrename(const char *oldpath, const char *newpath) } /** - * Write an array of buffers to a file descriptor. + * Write an array of buffers, handling non-fatal errors. * - * \param fd The file descriptor. + * \param fd The file descriptor to write to. * \param iov Pointer to one or more buffers. * \param iovcnt The number of buffers. * - * EAGAIN/EWOULDBLOCK is not considered a fatal error condition. For example - * DCCP 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. + * 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. * * For blocking file descriptors, this function returns either the sum of all - * buffer sizes, or the error code of the fatal error that caused the last - * write call to fail. + * buffer sizes or a negative error code which indicates the fatal error that + * caused a write call to fail. * - * For nonblocking file descriptors there is a third possibility: Any positive - * return value less than the sum of the buffer sizes indicates that some bytes - * have been written but the next write would block. + * 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. * * \sa writev(2), \ref xwrite(). */ @@ -126,14 +127,15 @@ int xwrite(int fd, const char *buf, size_t len) } /** - * Write all data to a file descriptor. + * Write to a file descriptor, fail on short writes. * * \param fd The file descriptor. - * \param buf The buffer to be sent. - * \param len The length of \a buf. + * \param buf The buffer to be written. + * \param len The length of the buffer. * - * This is like \ref xwrite() but returns \p -E_SHORT_WRITE if not - * all data could be written. + * 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. */ @@ -149,12 +151,20 @@ int write_all(int fd, const char *buf, size_t len) } /** - * Write a buffer given by a format string. + * A fprintf-like function for raw file descriptors. + * + * This function creates a string buffer according to the given format and + * writes this buffer to a file descriptor. * * \param fd The file descriptor. * \param fmt A format string. * + * 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. + * * \return The return value of the underlying call to \ref write_all(). + * + * \sa fprintf(3), \ref xvasprintf(). */ __printf_2_3 int write_va_buffer(int fd, const char *fmt, ...) { @@ -176,14 +186,11 @@ __printf_2_3 int write_va_buffer(int fd, const char *fmt, ...) * \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 rfds An optional fd set pointer. * \param num_bytes Result pointer. Contains the number of bytes read from \a fd. * - * If rfds is not NULL and the (non-blocking) file descriptor fd is not set in - * rfds, this function returns early without doing anything. Otherwise it 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. + * 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 @@ -197,24 +204,12 @@ __printf_2_3 int write_va_buffer(int fd, const char *fmt, ...) * * \sa \ref xwrite(), read(2), readv(2). */ -int readv_nonblock(int fd, struct iovec *iov, int iovcnt, fd_set *rfds, - size_t *num_bytes) +int readv_nonblock(int fd, struct iovec *iov, int iovcnt, size_t *num_bytes) { int ret, i, j; *num_bytes = 0; - /* - * Avoid a shortcoming of select(): Reads from a non-blocking fd might - * return EAGAIN even if FD_ISSET() returns true. However, FD_ISSET() - * returning false definitely means that no data can currently be read. - * This is the common case, so it is worth to avoid the overhead of the - * read() system call in this case. - */ - if (rfds && !FD_ISSET(fd, rfds)) - return 0; - for (i = 0, j = 0; i < iovcnt;) { - /* fix up the first iov */ assert(j < iov[i].iov_len); iov[i].iov_base += j; @@ -251,7 +246,6 @@ int readv_nonblock(int fd, struct iovec *iov, int iovcnt, fd_set *rfds, * \param fd The file descriptor to read from. * \param buf The buffer to read data to. * \param sz The size of \a buf. - * \param rfds \see \ref readv_nonblock(). * \param num_bytes \see \ref readv_nonblock(). * * This is a simple wrapper for readv_nonblock() which uses an iovec with a single @@ -259,10 +253,10 @@ int readv_nonblock(int fd, struct iovec *iov, int iovcnt, fd_set *rfds, * * \return The return value of the underlying call to readv_nonblock(). */ -int read_nonblock(int fd, void *buf, size_t sz, fd_set *rfds, size_t *num_bytes) +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, rfds, num_bytes); + return readv_nonblock(fd, &iov, 1, num_bytes); } /** @@ -271,7 +265,6 @@ int read_nonblock(int fd, void *buf, size_t sz, fd_set *rfds, size_t *num_bytes) * \param fd The file descriptor to receive from. * \param pattern The expected pattern. * \param bufsize The size of the internal buffer. - * \param rfds Passed to read_nonblock(). * * 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 @@ -283,11 +276,11 @@ int read_nonblock(int fd, void *buf, size_t sz, fd_set *rfds, size_t *num_bytes) * * \sa \ref read_nonblock(), \sa strncasecmp(3). */ -int read_pattern(int fd, const char *pattern, size_t bufsize, fd_set *rfds) +int read_pattern(int fd, const char *pattern, size_t bufsize) { size_t n, len; - char *buf = para_malloc(bufsize + 1); - int ret = read_nonblock(fd, buf, bufsize, rfds, &n); + char *buf = alloc(bufsize + 1); + int ret = read_nonblock(fd, buf, bufsize, &n); buf[n] = '\0'; if (ret < 0) @@ -311,50 +304,6 @@ out: return ret; } -/** - * Check whether a file exists. - * - * \param fn The file name. - * - * \return True iff file exists. - */ -bool file_exists(const char *fn) -{ - struct stat statbuf; - - return !stat(fn, &statbuf); -} - -/** - * 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_tv upper bound on the amount of time elapsed before select() - * returns. - * - * \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). - */ -int para_select(int n, fd_set *readfds, fd_set *writefds, - struct timeval *timeout_tv) -{ - int ret; - do - ret = select(n, readfds, writefds, NULL, timeout_tv); - while (ret < 0 && errno == EINTR); - if (ret < 0) - return -ERRNO_TO_PARA_ERROR(errno); - return ret; -} - /** * Set a file descriptor to blocking mode. * @@ -391,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 \ref 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. * @@ -499,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. * @@ -550,9 +427,10 @@ static int para_opendir(const char *dirname, DIR **dir, int *cwd) 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; @@ -670,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. * @@ -677,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; } /**