extract.c: Pass orig stream to callbacks when reading tmpfile

[wimlib] / src / resource.c

diff --git a/src/resource.c b/src/resource.c
index ea2ff5fec573a4b4f5f7630e9db4c24cf0dcb174..300aec8f1cbec29e0b919bba8243984e7e518271 100644 (file)
--- a/src/resource.c
+++ b/src/resource.c
@@ -37,7 +37,7 @@
 #include "wimlib/wim.h"
 
 #ifdef __WIN32__
-/* for read_win32_file_prefix(), read_win32_encrypted_file_prefix() */
+/* for read_winnt_file_prefix(), read_win32_encrypted_file_prefix() */
 #  include "wimlib/win32.h"
 #endif
 
@@ -138,6 +138,7 @@ read_compressed_wim_resource(const struct wim_resource_spec * const rspec,
        int errno_save;
 
        u64 *chunk_offsets = NULL;
+       u8 *_ubuf = NULL;
        u8 *ubuf = NULL;
        void *cbuf = NULL;
        bool chunk_offsets_malloced = false;
@@ -169,9 +170,9 @@ read_compressed_wim_resource(const struct wim_resource_spec * const rspec,
        struct filedes * const in_fd = &rspec->wim->in_fd;
 
        /* Determine if we're reading a pipable resource from a pipe or not.  */
-       const bool is_pipe_read = !filedes_is_seekable(in_fd);
+       const bool is_pipe_read = (rspec->is_pipable && !filedes_is_seekable(in_fd));
 
-       /* Determine if the chunk table is in an altenate format.  */
+       /* Determine if the chunk table is in an alternate format.  */
        const bool alt_chunk_table = (rspec->flags & WIM_RESHDR_FLAG_PACKED_STREAMS)
                                        && !is_pipe_read;
 
@@ -193,6 +194,7 @@ read_compressed_wim_resource(const struct wim_resource_spec * const rspec,
                      "expected power-of-2 chunk size (got %"PRIu32")",
                      chunk_size);
                ret = WIMLIB_ERR_INVALID_CHUNK_SIZE;
+               errno = EINVAL;
                goto out_free_memory;
        }
 
@@ -207,8 +209,11 @@ read_compressed_wim_resource(const struct wim_resource_spec * const rspec,
        } else {
                ret = wimlib_create_decompressor(ctype, chunk_size, NULL,
                                                 &decompressor);
-               if (ret)
+               if (ret) {
+                       if (ret != WIMLIB_ERR_NOMEM)
+                               errno = EINVAL;
                        goto out_free_memory;
+               }
        }
 
        const u32 chunk_order = bsr32(chunk_size);
@@ -364,13 +369,14 @@ read_compressed_wim_resource(const struct wim_resource_spec * const rspec,
 
        /* Allocate buffer for holding the uncompressed data of each chunk.  */
        if (chunk_size <= STACK_MAX) {
-               ubuf = alloca(chunk_size);
+               _ubuf = alloca(chunk_size + 15);
        } else {
-               ubuf = MALLOC(chunk_size);
-               if (ubuf == NULL)
+               _ubuf = MALLOC(chunk_size + 15);
+               if (_ubuf == NULL)
                        goto oom;
                ubuf_malloced = true;
        }
+       ubuf = (u8 *)(((uintptr_t)_ubuf + 15) & ~15);
 
        /* Allocate a temporary buffer for reading compressed chunks, each of
         * which can be at most @chunk_size - 1 bytes.  This excludes compressed
@@ -544,7 +550,7 @@ out_free_memory:
        if (chunk_offsets_malloced)
                FREE(chunk_offsets);
        if (ubuf_malloced)
-               FREE(ubuf);
+               FREE(_ubuf);
        if (cbuf_malloced)
                FREE(cbuf);
        errno = errno_save;
@@ -789,6 +795,34 @@ read_file_on_disk_prefix(const struct wim_lookup_table_entry *lte, u64 size,
        return ret;
 }
 
+#ifdef WITH_FUSE
+static int
+read_staging_file_prefix(const struct wim_lookup_table_entry *lte, u64 size,
+                        consume_data_callback_t cb, void *cb_ctx)
+{
+       int raw_fd;
+       struct filedes fd;
+       int ret;
+
+       wimlib_assert(size <= lte->size);
+
+       DEBUG("Reading %"PRIu64" bytes from staging file \"%s\"",
+             size, lte->staging_file_name);
+
+       raw_fd = openat(lte->staging_dir_fd, lte->staging_file_name,
+                       O_RDONLY | O_NOFOLLOW);
+       if (raw_fd < 0) {
+               ERROR_WITH_ERRNO("Can't open staging file \"%s\"",
+                                lte->staging_file_name);
+               return WIMLIB_ERR_OPEN;
+       }
+       filedes_init(&fd, raw_fd);
+       ret = read_raw_file_data(&fd, 0, size, cb, cb_ctx);
+       filedes_close(&fd);
+       return ret;
+}
+#endif
+
 /* This function handles the trivial case of reading stream data that is, in
  * fact, already located in an in-memory buffer.  */
 static int
@@ -828,7 +862,7 @@ read_stream_prefix(const struct wim_lookup_table_entry *lte, u64 size,
                [RESOURCE_IN_FILE_ON_DISK]    = read_file_on_disk_prefix,
                [RESOURCE_IN_ATTACHED_BUFFER] = read_buffer_prefix,
        #ifdef WITH_FUSE
-               [RESOURCE_IN_STAGING_FILE]    = read_file_on_disk_prefix,
+               [RESOURCE_IN_STAGING_FILE]    = read_staging_file_prefix,
        #endif
        #ifdef WITH_NTFS_3G
                [RESOURCE_IN_NTFS_VOLUME]     = read_ntfs_file_prefix,
@@ -1002,9 +1036,9 @@ streamifier_cb(const void *chunk, size_t size, void *_ctx)
        /* Consume the chunk.  */
        ret = (*ctx->cbs.consume_chunk)(chunk, size,
                                        ctx->cbs.consume_chunk_ctx);
+       ctx->cur_stream_offset += size;
        if (ret)
                return ret;
-       ctx->cur_stream_offset += size;
 
        if (ctx->cur_stream_offset == ctx->cur_stream->size) {
                /* Finished reading all the data for a stream.  */