diff --git a/fd.c b/fd.c
index ea16bdd..33891d2 100644 (file)
--- a/fd.c
+++ b/fd.c
@@ -1,8 +1,4 @@
-/*
- * Copyright (C) 2006-2011 Andre Noll <maan@systemlinux.org>
- *
- * Licensed under the GPL v2. For licencing details see COPYING.
- */
+/* Copyright (C) 2006 Andre Noll <maan@tuebingen.mpg.de>, see file COPYING. */

/** \file fd.c Helper functions for file descriptor handling. */

@@ -10,8 +6,6 @@
#include <sys/types.h>
#include <dirent.h>
#include <sys/mman.h>
-#include <fcntl.h>
-#include <sys/uio.h>

#include "para.h"
#include "error.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. In any case, the number of bytes that have been written is
- * stored in \a len.
+ * \return Standard.
+ *
+ * \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 to a file descriptor.
*
* \param fd The file descriptor.
- * \param buf the buffer to write.
- * \param len the number of bytes of \a buf.
+ * \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.
+ *
+ * \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.
*
- * 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 positive
+ * return value less than the sum of the buffer sizes indicates that some bytes
+ * have been written but the next write would block.
*
- * \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)
+int xwritev(int fd, struct iovec *iov, int iovcnt)
{
size_t written = 0;
-       int ret = 0;
-
-       while (written < len) {
-               size_t num = len - written;
-
-               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;
}

+/**
+ * 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 all data to a file descriptor.
+ *
+ * \param fd The file descriptor.
+ * \param buf The buffer to be sent.
+ * \param len The length of \a buf.
+ *
+ * This is like \ref xwrite() but returns \p -E_SHORT_WRITE if not
+ * all data could be written.
+ *
+ * \return Number of bytes written on success, negative error code else.
+ */
+int write_all(int fd, const char *buf, size_t len)
+{
+       int ret = xwrite(fd, buf, len);
+
+       if (ret < 0)
+               return ret;
+       if (ret != len)
+               return -E_SHORT_WRITE;
+       return ret;
+}
+
+/**
+ * Write a buffer given by a format string.
+ *
+ * \param fd The file descriptor.
+ * \param fmt A format string.
+ *
+ * \return The return value of the underlying call to \ref write_all().
+ */
+__printf_2_3 int write_va_buffer(int fd, const char *fmt, ...)
+{
+       char *msg;
+       int ret;
+       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.
*
@@ -84,15 +179,15 @@ int write_nonblock(int fd, const char *buf, size_t len)
* \param rfds An optional fd set pointer.
* \param num_bytes Result pointer. Contains the number of bytes read from \a fd.
*
- * If \a rfds is not \p NULL and the (non-blocking) file descriptor \a fd is
- * not set in \a rfds, this function returns early without doing anything.
- * Otherwise The function tries to read up to \a sz bytes from \a fd. As for
- * write_nonblock(), EAGAIN is not considered an error condition. However, EOF
- * is.
+ * 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.
*
* \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 \p EAGAIN, a negative return value is returned.
+ * 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
@@ -100,7 +195,7 @@ int write_nonblock(int fd, const char *buf, size_t len)
* have been read before the error occurred. In this case \a num_bytes is
* positive.
*
*/
int readv_nonblock(int fd, struct iovec *iov, int iovcnt, fd_set *rfds,
size_t *num_bytes)
@@ -131,7 +226,7 @@ int readv_nonblock(int fd, struct iovec *iov, int iovcnt, fd_set *rfds,
if (ret == 0)
return -E_EOF;
if (ret < 0) {
-                       if (errno == EAGAIN)
+                       if (errno == EAGAIN || errno == EINTR)
return 0;
return -ERRNO_TO_PARA_ERROR(errno);
}
@@ -221,9 +316,9 @@ out:
*
* \param fn The file name.
*
- * \return Non-zero iff file exists.
+ * \return True iff file exists.
*/
-int file_exists(const char *fn)
+bool file_exists(const char *fn)
{
struct stat statbuf;

@@ -306,7 +401,7 @@ __must_check int mark_fd_nonblocking(int fd)
* 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 \ref para_select.
*/
void para_fd_set(int fd, fd_set *fds, int *max_fileno)
{
@@ -324,34 +419,6 @@ void para_fd_set(int fd, fd_set *fds, int *max_fileno)
*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.
*
@@ -360,22 +427,20 @@ again:
* \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:
@@ -450,6 +515,7 @@ 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)
@@ -473,20 +539,6 @@ close_cwd:
return ret;
}

-/**
- * A wrapper for fchdir().
- *
- * \param fd An open file descriptor.
- *
- * \return Standard.
- */
-static int para_fchdir(int fd)
-{
-       if (fchdir(fd) < 0)
-               return -ERRNO_TO_PARA_ERROR(errno);
-       return 1;
-}
-
/**
* A wrapper for mkdir(2).
*
@@ -541,7 +593,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);
@@ -558,7 +626,7 @@ out:
*
* \return Standard.
*
- * \sa munmap(2), mmap_full_file().
+ * \sa munmap(2), \ref mmap_full_file().
*/
int para_munmap(void *start, size_t length)
{
@@ -600,8 +668,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)
{
@@ -635,7 +701,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;
@@ -671,9 +737,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;
}
{"ft_lang_label":"__label__en","ft_lang_prob":0.57118064,"math_prob":0.8153058,"size":11087,"snap":"2020-10-2020-16","text_gpt3_token_len":3311,"char_repetition_ratio":0.13967337,"word_repetition_ratio":0.123696685,"special_character_ratio":0.35068098,"punctuation_ratio":0.18,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.95577765,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2020-02-22T17:08:24Z\",\"WARC-Record-ID\":\"<urn:uuid:3b3f8130-2eb8-4372-bfe3-0df0ab68fb82>\",\"Content-Length\":\"59817\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:1cd824df-a1b3-4097-8a0d-862db910d2a3>\",\"WARC-Concurrent-To\":\"<urn:uuid:94d79681-d72a-45ed-8f4e-2a95bd25a40a>\",\"WARC-IP-Address\":\"192.124.27.42\",\"WARC-Target-URI\":\"http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff;f=fd.c;h=33891d2e6c9f1c3568428b1df93b4b92e295ef61;hp=ea16bdda993aff814fa41684af53506e46242a4f;hb=9d232e636d79a2321e280fe3eee6839c8f45c36f;hpb=e01b2ffa28b6770cd8771860e1e05b9c75beabd9\",\"WARC-Payload-Digest\":\"sha1:U2S22ZE4I3KVHJCKKM5WE32LBGAPBDS7\",\"WARC-Block-Digest\":\"sha1:BJRIGVYC5TQQUUDWPU7LW76SLMBNLIZE\",\"WARC-Identified-Payload-Type\":\"application/xhtml+xml\",\"warc_filename\":\"/cc_download/warc_2020/CC-MAIN-2020-10/CC-MAIN-2020-10_segments_1581875145708.59_warc_CC-MAIN-20200222150029-20200222180029-00119.warc.gz\"}"}