X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Ffile_io.c;h=8fbd01f9669040b9b1dcf6f5abe2ad9e81478208;hp=7a3673235226e20b9974283ac78097121cd33de5;hb=b27e5a1c6b1662eda54ce751b8586fd7d5fb5133;hpb=e8c3ca2d1d0cac3d64985b45a9f654d2029a7518 diff --git a/src/file_io.c b/src/file_io.c index 7a367323..8fbd01f9 100644 --- a/src/file_io.c +++ b/src/file_io.c @@ -5,164 +5,208 @@ /* * Copyright (C) 2013 Eric Biggers * - * This file is part of wimlib, a library for working with WIM files. + * This file is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 3 of the License, or (at your option) any + * later version. * - * wimlib 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 3 of the License, or (at your option) - * any later version. - * - * wimlib 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 + * This file 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 Lesser General Public License for more * details. * - * You should have received a copy of the GNU General Public License - * along with wimlib; if not, see http://www.gnu.org/licenses/. + * You should have received a copy of the GNU Lesser General Public License + * along with this file; if not, see http://www.gnu.org/licenses/. */ #ifdef HAVE_CONFIG_H # include "config.h" #endif -#include "wimlib/file_io.h" -#ifdef __WIN32__ -# include "wimlib/win32.h" /* For pread(), pwrite() replacements */ -#else -# include /* for writev() and `struct iovec' */ -#endif - #include #include +#include "wimlib/error.h" +#include "wimlib/file_io.h" +#include "wimlib/util.h" -/* Like read(), but keep trying until everything has been written or we know for - * sure that there was an error (or end-of-file). */ -size_t -full_read(int fd, void *buf, size_t count) +#ifdef __WIN32__ +# include "wimlib/win32.h" +# define read win32_read +# define write win32_write +# define pread win32_pread +# define pwrite win32_pwrite +#endif + +/* + * Wrapper around read() that checks for errors and keeps retrying until all + * requested bytes have been read or until end-of file has occurred. + * + * Return values: + * WIMLIB_ERR_SUCCESS (0) + * WIMLIB_ERR_READ (errno set) + * WIMLIB_ERR_UNEXPECTED_END_OF_FILE (errno set to EINVAL) + */ +int +full_read(struct filedes *fd, void *buf, size_t count) { - ssize_t bytes_read; - size_t bytes_remaining; - - for (bytes_remaining = count; - bytes_remaining != 0; - bytes_remaining -= bytes_read, buf += bytes_read) - { - bytes_read = read(fd, buf, bytes_remaining); - if (bytes_read <= 0) { - if (bytes_read == 0) - errno = EIO; - else if (errno == EINTR) + while (count) { + ssize_t ret = read(fd->fd, buf, count); + if (unlikely(ret <= 0)) { + if (ret == 0) { + errno = EINVAL; + return WIMLIB_ERR_UNEXPECTED_END_OF_FILE; + } + if (errno == EINTR) continue; - break; + return WIMLIB_ERR_READ; } + buf += ret; + count -= ret; + fd->offset += ret; } - return count - bytes_remaining; + return 0; } -/* Like write(), but keep trying until everything has been written or we know - * for sure that there was an error. */ -size_t -full_write(int fd, const void *buf, size_t count) +static int +pipe_read(struct filedes *fd, void *buf, size_t count, off_t offset) { - ssize_t bytes_written; - size_t bytes_remaining; - - for (bytes_remaining = count; - bytes_remaining != 0; - bytes_remaining -= bytes_written, buf += bytes_written) - { - bytes_written = write(fd, buf, bytes_remaining); - if (bytes_written < 0) { - if (errno == EINTR) - continue; - break; - } + int ret; + + /* Verify the offset. */ + if (offset < fd->offset) { + ERROR("Can't seek backwards in pipe " + "(offset %"PRIu64" => %"PRIu64").\n" + " Make sure the WIM was captured as " + "pipable.", fd->offset, offset); + errno = ESPIPE; + return WIMLIB_ERR_RESOURCE_ORDER; } - return count - bytes_remaining; + + /* Manually seek to the requested position. */ + while (fd->offset != offset) { + size_t bytes_to_read = min(offset - fd->offset, BUFFER_SIZE); + u8 dummy[bytes_to_read]; + + ret = full_read(fd, dummy, bytes_to_read); + if (ret) + return ret; + } + + /* Do the actual read. */ + return full_read(fd, buf, count); } -/* Like pread(), but keep trying until everything has been read or we know for - * sure that there was an error (or end-of-file) */ -size_t -full_pread(int fd, void *buf, size_t count, off_t offset) +/* + * Wrapper around pread() that checks for errors and keeps retrying until all + * requested bytes have been read or until end-of file has occurred. This also + * transparently handle reading from pipe files, but the caller needs to be sure + * the requested offset is greater than or equal to the current offset, or else + * WIMLIB_ERR_RESOURCE_ORDER will be returned. + * + * Return values: + * WIMLIB_ERR_SUCCESS (0) + * WIMLIB_ERR_READ (errno set) + * WIMLIB_ERR_UNEXPECTED_END_OF_FILE (errno set to EINVAL) + * WIMLIB_ERR_RESOURCE_ORDER (errno set to ESPIPE) + */ +int +full_pread(struct filedes *fd, void *buf, size_t count, off_t offset) { - ssize_t bytes_read; - size_t bytes_remaining; - - for (bytes_remaining = count; - bytes_remaining != 0; - bytes_remaining -= bytes_read, buf += bytes_read, - offset += bytes_read) - { - bytes_read = pread(fd, buf, bytes_remaining, offset); - if (bytes_read <= 0) { - if (bytes_read == 0) - errno = EIO; - else if (errno == EINTR) + if (fd->is_pipe) + goto is_pipe; + + while (count) { + ssize_t ret = pread(fd->fd, buf, count, offset); + if (unlikely(ret <= 0)) { + if (ret == 0) { + errno = EINVAL; + return WIMLIB_ERR_UNEXPECTED_END_OF_FILE; + } + if (errno == EINTR) continue; - break; + if (errno == ESPIPE) { + fd->is_pipe = 1; + goto is_pipe; + } + return WIMLIB_ERR_READ; } + buf += ret; + count -= ret; + offset += ret; } - return count - bytes_remaining; + return 0; + +is_pipe: + return pipe_read(fd, buf, count, offset); } -/* Like pwrite(), but keep trying until everything has been written or we know - * for sure that there was an error. */ -size_t -full_pwrite(int fd, const void *buf, size_t count, off_t offset) +/* + * Wrapper around write() that checks for errors and keeps retrying until all + * requested bytes have been written. + * + * Return values: + * WIMLIB_ERR_SUCCESS (0) + * WIMLIB_ERR_WRITE (errno set) + */ +int +full_write(struct filedes *fd, const void *buf, size_t count) { - ssize_t bytes_written; - size_t bytes_remaining; - - for (bytes_remaining = count; - bytes_remaining != 0; - bytes_remaining -= bytes_written, buf += bytes_written, - offset += bytes_written) - { - bytes_written = pwrite(fd, buf, bytes_remaining, offset); - if (bytes_written < 0) { + while (count) { + ssize_t ret = write(fd->fd, buf, count); + if (unlikely(ret < 0)) { if (errno == EINTR) continue; - break; + return WIMLIB_ERR_WRITE; } + buf += ret; + count -= ret; + fd->offset += ret; } - return count - bytes_remaining; + return 0; } -/* Like writev(), but keep trying until everything has been written or we know - * for sure that there was an error. */ -size_t -full_writev(int fd, struct iovec *iov, int iovcnt) -{ - size_t total_bytes_written = 0; - while (iovcnt > 0) { - ssize_t bytes_written; - bytes_written = writev(fd, iov, iovcnt); - if (bytes_written < 0) { +/* + * Wrapper around pwrite() that checks for errors and keeps retrying until all + * requested bytes have been written. + * + * Return values: + * WIMLIB_ERR_SUCCESS (0) + * WIMLIB_ERR_WRITE (errno set) + */ +int +full_pwrite(struct filedes *fd, const void *buf, size_t count, off_t offset) +{ + while (count) { + ssize_t ret = pwrite(fd->fd, buf, count, offset); + if (unlikely(ret < 0)) { if (errno == EINTR) continue; - break; - } - total_bytes_written += bytes_written; - while (bytes_written) { - if (bytes_written >= iov[0].iov_len) { - bytes_written -= iov[0].iov_len; - iov++; - iovcnt--; - } else { - iov[0].iov_base += bytes_written; - iov[0].iov_len -= bytes_written; - bytes_written = 0; - } + return WIMLIB_ERR_WRITE; } + buf += ret; + count -= ret; + offset += ret; + } + return 0; +} + +off_t filedes_seek(struct filedes *fd, off_t offset) +{ + if (fd->is_pipe) { + errno = ESPIPE; + return -1; + } + if (fd->offset != offset) { + if (lseek(fd->fd, offset, SEEK_SET) == -1) + return -1; + fd->offset = offset; } - return total_bytes_written; + return offset; } -off_t -filedes_offset(int fd) +bool filedes_is_seekable(struct filedes *fd) { - return lseek(fd, 0, SEEK_CUR); + return !fd->is_pipe && lseek(fd->fd, 0, SEEK_CUR) != -1; }