+ * Change the name or location of a file.
+ *
+ * \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.
+ *
+ * \sa rename(2).
+ */
+int xrename(const char *oldpath, const char *newpath)
+{
+ int ret = rename(oldpath, newpath);
+
+ 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 an array of buffers to a file descriptor.
+ *
+ * \param fd The file descriptor.
+ * \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.
+ *
+ * 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.
+ *
+ * \sa writev(2), \ref xwrite().
+ */
+int xwritev(int fd, struct iovec *iov, int iovcnt)
+{
+ size_t written = 0;
+ 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;
+ /* 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.