diff --git a/lib/libarchive/archive_read_open_fd.c b/lib/libarchive/archive_read_open_fd.c index 13afe63f8c2b..a7c2e29fd5f2 100644 --- a/lib/libarchive/archive_read_open_fd.c +++ b/lib/libarchive/archive_read_open_fd.c @@ -1,187 +1,176 @@ /*- * Copyright (c) 2003-2007 Tim Kientzle * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "archive_platform.h" __FBSDID("$FreeBSD$"); #ifdef HAVE_SYS_STAT_H #include #endif #ifdef HAVE_ERRNO_H #include #endif #ifdef HAVE_STDLIB_H #include #endif #ifdef HAVE_STRING_H #include #endif #ifdef HAVE_UNISTD_H #include #endif #include "archive.h" struct read_fd_data { int fd; size_t block_size; char can_skip; void *buffer; }; static int file_close(struct archive *, void *); -static int file_open(struct archive *, void *); static ssize_t file_read(struct archive *, void *, const void **buff); #if ARCHIVE_API_VERSION < 2 static ssize_t file_skip(struct archive *, void *, size_t request); #else static off_t file_skip(struct archive *, void *, off_t request); #endif int archive_read_open_fd(struct archive *a, int fd, size_t block_size) { + struct stat st; struct read_fd_data *mine; + void *b; - mine = (struct read_fd_data *)malloc(sizeof(*mine)); - if (mine == NULL) { - archive_set_error(a, ENOMEM, "No memory"); + if (fstat(fd, &st) != 0) { + archive_set_error(a, errno, "Can't stat fd %d", fd); return (ARCHIVE_FATAL); } - mine->block_size = block_size; - mine->buffer = malloc(mine->block_size); - if (mine->buffer == NULL) { + + mine = (struct read_fd_data *)malloc(sizeof(*mine)); + b = malloc(block_size); + if (mine == NULL || b == NULL) { archive_set_error(a, ENOMEM, "No memory"); free(mine); + free(b); return (ARCHIVE_FATAL); } + mine->block_size = block_size; + mine->buffer = b; mine->fd = fd; - /* lseek() hardly ever works, so disable it by default. See below. */ - mine->can_skip = 0; - return (archive_read_open2(a, mine, file_open, file_read, file_skip, file_close)); -} - -static int -file_open(struct archive *a, void *client_data) -{ - struct read_fd_data *mine = (struct read_fd_data *)client_data; - struct stat st; - - if (fstat(mine->fd, &st) != 0) { - archive_set_error(a, errno, "Can't stat fd %d", mine->fd); - return (ARCHIVE_FATAL); - } - + /* + * Skip support is a performance optimization for anything + * that supports lseek(). On FreeBSD, only regular files and + * raw disk devices support lseek() and there's no portable + * way to determine if a device is a raw disk device, so we + * only enable this optimization for regular files. + */ if (S_ISREG(st.st_mode)) { archive_read_extract_set_skip_file(a, st.st_dev, st.st_ino); - /* - * Enabling skip here is a performance optimization for - * anything that supports lseek(). On FreeBSD, only - * regular files and raw disk devices support lseek() and - * there's no portable way to determine if a device is - * a raw disk device, so we only enable this optimization - * for regular files. - */ mine->can_skip = 1; - } - return (ARCHIVE_OK); + } else + mine->can_skip = 0; + + return (archive_read_open2(a, mine, + NULL, file_read, file_skip, file_close)); } static ssize_t file_read(struct archive *a, void *client_data, const void **buff) { struct read_fd_data *mine = (struct read_fd_data *)client_data; ssize_t bytes_read; *buff = mine->buffer; bytes_read = read(mine->fd, mine->buffer, mine->block_size); if (bytes_read < 0) { archive_set_error(a, errno, "Error reading fd %d", mine->fd); } return (bytes_read); } #if ARCHIVE_API_VERSION < 2 static ssize_t file_skip(struct archive *a, void *client_data, size_t request) #else static off_t file_skip(struct archive *a, void *client_data, off_t request) #endif { struct read_fd_data *mine = (struct read_fd_data *)client_data; off_t old_offset, new_offset; if (!mine->can_skip) return (0); /* Reduce request to the next smallest multiple of block_size */ request = (request / mine->block_size) * mine->block_size; if (request == 0) return (0); /* * Hurray for lazy evaluation: if the first lseek fails, the second * one will not be executed. */ if (((old_offset = lseek(mine->fd, 0, SEEK_CUR)) < 0) || ((new_offset = lseek(mine->fd, request, SEEK_CUR)) < 0)) { /* If seek failed once, it will probably fail again. */ mine->can_skip = 0; if (errno == ESPIPE) { /* * Failure to lseek() can be caused by the file * descriptor pointing to a pipe, socket or FIFO. * Return 0 here, so the compression layer will use * read()s instead to advance the file descriptor. * It's slower of course, but works as well. */ return (0); } /* * There's been an error other than ESPIPE. This is most * likely caused by a programmer error (too large request) * or a corrupted archive file. */ archive_set_error(a, errno, "Error seeking"); return (-1); } return (new_offset - old_offset); } static int file_close(struct archive *a, void *client_data) { struct read_fd_data *mine = (struct read_fd_data *)client_data; (void)a; /* UNUSED */ - if (mine->buffer != NULL) - free(mine->buffer); + free(mine->buffer); free(mine); return (ARCHIVE_OK); } diff --git a/lib/libarchive/archive_read_open_file.c b/lib/libarchive/archive_read_open_file.c index eb440845a899..e77d4471c94d 100644 --- a/lib/libarchive/archive_read_open_file.c +++ b/lib/libarchive/archive_read_open_file.c @@ -1,167 +1,157 @@ /*- * Copyright (c) 2003-2007 Tim Kientzle * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "archive_platform.h" __FBSDID("$FreeBSD$"); #ifdef HAVE_SYS_STAT_H #include #endif #ifdef HAVE_ERRNO_H #include #endif #ifdef HAVE_FCNTL_H #include #endif #ifdef HAVE_STDLIB_H #include #endif #ifdef HAVE_STRING_H #include #endif #ifdef HAVE_UNISTD_H #include #endif #include "archive.h" struct read_FILE_data { FILE *f; size_t block_size; void *buffer; char can_skip; }; static int file_close(struct archive *, void *); -static int file_open(struct archive *, void *); static ssize_t file_read(struct archive *, void *, const void **buff); #if ARCHIVE_API_VERSION < 2 static ssize_t file_skip(struct archive *, void *, size_t request); #else static off_t file_skip(struct archive *, void *, off_t request); #endif int archive_read_open_FILE(struct archive *a, FILE *f) { + struct stat st; struct read_FILE_data *mine; + size_t block_size = 128 * 1024; + void *b; mine = (struct read_FILE_data *)malloc(sizeof(*mine)); - if (mine == NULL) { - archive_set_error(a, ENOMEM, "No memory"); - return (ARCHIVE_FATAL); - } - mine->block_size = 128 * 1024; - mine->buffer = malloc(mine->block_size); - if (mine->buffer == NULL) { + b = malloc(block_size); + if (mine == NULL || b == NULL) { archive_set_error(a, ENOMEM, "No memory"); free(mine); + free(b); return (ARCHIVE_FATAL); } + mine->block_size = block_size; + mine->buffer = b; mine->f = f; - /* Suppress skip by default. See below. */ - mine->can_skip = 0; - return (archive_read_open2(a, mine, file_open, file_read, - file_skip, file_close)); -} - -static int -file_open(struct archive *a, void *client_data) -{ - struct read_FILE_data *mine = (struct read_FILE_data *)client_data; - struct stat st; - /* - * If we can't fstat() the file, it may just be that - * it's not a file. (FILE * objects can wrap many kinds - * of I/O streams.) + * If we can't fstat() the file, it may just be that it's not + * a file. (FILE * objects can wrap many kinds of I/O + * streams, some of which don't support fileno()).) */ if (fstat(fileno(mine->f), &st) == 0 && S_ISREG(st.st_mode)) { archive_read_extract_set_skip_file(a, st.st_dev, st.st_ino); - /* Enable the seek optimization for regular files. */ + /* Enable the seek optimization only for regular files. */ mine->can_skip = 1; - } + } else + mine->can_skip = 0; - return (ARCHIVE_OK); + return (archive_read_open2(a, mine, NULL, file_read, + file_skip, file_close)); } static ssize_t file_read(struct archive *a, void *client_data, const void **buff) { struct read_FILE_data *mine = (struct read_FILE_data *)client_data; ssize_t bytes_read; *buff = mine->buffer; bytes_read = fread(mine->buffer, 1, mine->block_size, mine->f); if (bytes_read < 0) { archive_set_error(a, errno, "Error reading file"); } return (bytes_read); } #if ARCHIVE_API_VERSION < 2 static ssize_t file_skip(struct archive *a, void *client_data, size_t request) #else static off_t file_skip(struct archive *a, void *client_data, off_t request) #endif { struct read_FILE_data *mine = (struct read_FILE_data *)client_data; (void)a; /* UNUSED */ /* * If we can't skip, return 0 as the amount we did step and * the caller will work around by reading and discarding. */ if (!mine->can_skip) return (0); if (request == 0) return (0); #if HAVE_FSEEKO if (fseeko(mine->f, request, SEEK_CUR) != 0) #else if (fseek(mine->f, request, SEEK_CUR) != 0) #endif { mine->can_skip = 0; return (0); } return (request); } static int file_close(struct archive *a, void *client_data) { struct read_FILE_data *mine = (struct read_FILE_data *)client_data; (void)a; /* UNUSED */ if (mine->buffer != NULL) free(mine->buffer); free(mine); return (ARCHIVE_OK); } diff --git a/lib/libarchive/archive_read_open_filename.c b/lib/libarchive/archive_read_open_filename.c index 9745b44af583..e86a93d2b3d0 100644 --- a/lib/libarchive/archive_read_open_filename.c +++ b/lib/libarchive/archive_read_open_filename.c @@ -1,269 +1,232 @@ /*- * Copyright (c) 2003-2007 Tim Kientzle * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "archive_platform.h" __FBSDID("$FreeBSD$"); #ifdef HAVE_SYS_STAT_H #include #endif #ifdef HAVE_ERRNO_H #include #endif #ifdef HAVE_FCNTL_H #include #endif #ifdef HAVE_STDLIB_H #include #endif #ifdef HAVE_STRING_H #include #endif #ifdef HAVE_UNISTD_H #include #endif #include "archive.h" #ifndef O_BINARY #define O_BINARY 0 #endif struct read_file_data { int fd; size_t block_size; void *buffer; mode_t st_mode; /* Mode bits for opened file. */ char can_skip; /* This file supports skipping. */ char filename[1]; /* Must be last! */ }; static int file_close(struct archive *, void *); -static int file_open(struct archive *, void *); static ssize_t file_read(struct archive *, void *, const void **buff); #if ARCHIVE_API_VERSION < 2 static ssize_t file_skip(struct archive *, void *, size_t request); #else static off_t file_skip(struct archive *, void *, off_t request); #endif int archive_read_open_file(struct archive *a, const char *filename, size_t block_size) { return (archive_read_open_filename(a, filename, block_size)); } int archive_read_open_filename(struct archive *a, const char *filename, size_t block_size) { + struct stat st; struct read_file_data *mine; + void *b; + int fd; - if (filename == NULL || filename[0] == '\0') { - mine = (struct read_file_data *)malloc(sizeof(*mine)); - if (mine == NULL) { - archive_set_error(a, ENOMEM, "No memory"); - return (ARCHIVE_FATAL); - } - mine->filename[0] = '\0'; - } else { - mine = (struct read_file_data *)malloc(sizeof(*mine) + strlen(filename)); - if (mine == NULL) { - archive_set_error(a, ENOMEM, "No memory"); - return (ARCHIVE_FATAL); - } - strcpy(mine->filename, filename); - } - mine->block_size = block_size; - mine->buffer = NULL; - mine->fd = -1; - /* lseek() almost never works; disable it by default. See below. */ - mine->can_skip = 0; - return (archive_read_open2(a, mine, file_open, file_read, file_skip, file_close)); -} + if (filename == NULL || filename[0] == '\0') + return (archive_read_open_fd(a, 0, block_size)); -static int -file_open(struct archive *a, void *client_data) -{ - struct read_file_data *mine = (struct read_file_data *)client_data; - struct stat st; - - mine->buffer = malloc(mine->block_size); - if (mine->buffer == NULL) { - archive_set_error(a, ENOMEM, "No memory"); + fd = open(filename, O_RDONLY | O_BINARY); + if (fd < 0) { + archive_set_error(a, errno, "Failed to open '%s'", filename); return (ARCHIVE_FATAL); } - if (mine->filename[0] != '\0') - mine->fd = open(mine->filename, O_RDONLY | O_BINARY); - else - mine->fd = 0; /* Fake "open" for stdin. */ - if (mine->fd < 0) { - archive_set_error(a, errno, "Failed to open '%s'", - mine->filename); + if (fstat(fd, &st) != 0) { + archive_set_error(a, errno, "Can't stat '%s'", filename); return (ARCHIVE_FATAL); } - if (fstat(mine->fd, &st) == 0) { - /* If we're reading a file from disk, ensure that we don't - overwrite it with an extracted file. */ - if (S_ISREG(st.st_mode)) { - archive_read_extract_set_skip_file(a, st.st_dev, st.st_ino); - /* - * Enabling skip here is a performance - * optimization for anything that supports - * lseek(). On FreeBSD, only regular files - * and raw disk devices support lseek() and - * there's no portable way to determine if a - * device is a raw disk device, so we only - * enable this optimization for regular files. - */ - mine->can_skip = 1; - } - /* Remember mode so close can decide whether to flush. */ - mine->st_mode = st.st_mode; - } else { - if (mine->filename[0] == '\0') - archive_set_error(a, errno, "Can't stat stdin"); - else - archive_set_error(a, errno, "Can't stat '%s'", - mine->filename); + + mine = (struct read_file_data *)malloc(sizeof(*mine) + strlen(filename)); + b = malloc(block_size); + if (mine == NULL || b == NULL) { + archive_set_error(a, ENOMEM, "No memory"); + free(mine); + free(b); return (ARCHIVE_FATAL); } - return (0); + strcpy(mine->filename, filename); + mine->block_size = block_size; + mine->buffer = b; + mine->fd = fd; + /* Remember mode so close can decide whether to flush. */ + mine->st_mode = st.st_mode; + /* If we're reading a file from disk, ensure that we don't + overwrite it with an extracted file. */ + if (S_ISREG(st.st_mode)) { + archive_read_extract_set_skip_file(a, st.st_dev, st.st_ino); + /* + * Skip is a performance optimization for anything + * that supports lseek(). Generally, that only + * includes regular files and possibly raw disk + * devices, but there's no good portable way to detect + * raw disks. + */ + mine->can_skip = 1; + } else + mine->can_skip = 0; + return (archive_read_open2(a, mine, + NULL, file_read, file_skip, file_close)); } static ssize_t file_read(struct archive *a, void *client_data, const void **buff) { struct read_file_data *mine = (struct read_file_data *)client_data; ssize_t bytes_read; *buff = mine->buffer; bytes_read = read(mine->fd, mine->buffer, mine->block_size); if (bytes_read < 0) { - if (mine->filename[0] == '\0') - archive_set_error(a, errno, "Error reading stdin"); - else - archive_set_error(a, errno, "Error reading '%s'", - mine->filename); + archive_set_error(a, errno, "Error reading '%s'", + mine->filename); } return (bytes_read); } #if ARCHIVE_API_VERSION < 2 static ssize_t file_skip(struct archive *a, void *client_data, size_t request) #else static off_t file_skip(struct archive *a, void *client_data, off_t request) #endif { struct read_file_data *mine = (struct read_file_data *)client_data; off_t old_offset, new_offset; if (!mine->can_skip) /* We can't skip, so ... */ return (0); /* ... skip zero bytes. */ /* Reduce request to the next smallest multiple of block_size */ request = (request / mine->block_size) * mine->block_size; if (request == 0) return (0); /* * Hurray for lazy evaluation: if the first lseek fails, the second * one will not be executed. */ if (((old_offset = lseek(mine->fd, 0, SEEK_CUR)) < 0) || ((new_offset = lseek(mine->fd, request, SEEK_CUR)) < 0)) { /* If skip failed once, it will probably fail again. */ mine->can_skip = 0; if (errno == ESPIPE) { /* * Failure to lseek() can be caused by the file * descriptor pointing to a pipe, socket or FIFO. * Return 0 here, so the compression layer will use * read()s instead to advance the file descriptor. * It's slower of course, but works as well. */ return (0); } /* * There's been an error other than ESPIPE. This is most * likely caused by a programmer error (too large request) * or a corrupted archive file. */ - if (mine->filename[0] == '\0') - /* - * Should never get here, since lseek() on stdin ought - * to return an ESPIPE error. - */ - archive_set_error(a, errno, "Error seeking in stdin"); - else - archive_set_error(a, errno, "Error seeking in '%s'", - mine->filename); + archive_set_error(a, errno, "Error seeking in '%s'", + mine->filename); return (-1); } return (new_offset - old_offset); } static int file_close(struct archive *a, void *client_data) { struct read_file_data *mine = (struct read_file_data *)client_data; (void)a; /* UNUSED */ /* Only flush and close if open succeeded. */ if (mine->fd >= 0) { /* * Sometimes, we should flush the input before closing. * Regular files: faster to just close without flush. * Devices: must not flush (user might need to * read the "next" item on a non-rewind device). * Pipes and sockets: must flush (otherwise, the * program feeding the pipe or socket may complain). * Here, I flush everything except for regular files and * device nodes. */ if (!S_ISREG(mine->st_mode) && !S_ISCHR(mine->st_mode) && !S_ISBLK(mine->st_mode)) { ssize_t bytesRead; do { bytesRead = read(mine->fd, mine->buffer, mine->block_size); } while (bytesRead > 0); } - /* If a named file was opened, then it needs to be closed. */ - if (mine->filename[0] != '\0') - close(mine->fd); + close(mine->fd); } free(mine->buffer); free(mine); return (ARCHIVE_OK); }