/*
* Copyright (C) 2012, 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.
+ * 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.
*
- * 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 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.h"
#include "wimlib/assert.h"
+#include "wimlib/bitops.h"
#include "wimlib/endianness.h"
#include "wimlib/error.h"
#include "wimlib/file_io.h"
#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
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;
"expected power-of-2 chunk size (got %"PRIu32")",
chunk_size);
ret = WIMLIB_ERR_INVALID_CHUNK_SIZE;
+ errno = EINVAL;
goto out_free_memory;
}
rspec->wim->decompressor_ctype = WIMLIB_COMPRESSION_TYPE_NONE;
rspec->wim->decompressor = NULL;
} else {
- ret = wimlib_create_decompressor(ctype, chunk_size, NULL,
+ ret = wimlib_create_decompressor(ctype, chunk_size,
&decompressor);
- if (ret)
+ if (ret) {
+ if (ret != WIMLIB_ERR_NOMEM)
+ errno = EINVAL;
goto out_free_memory;
+ }
}
- const u32 chunk_order = bsr32(chunk_size);
+ const u32 chunk_order = fls32(chunk_size);
/* Calculate the total number of chunks the resource is divided into. */
const u64 num_chunks = (rspec->uncompressed_size + chunk_size - 1) >> chunk_order;
/* Now fill in chunk_offsets from the entries we have read in
* chunk_tab_data. We break aliasing rules here to avoid having
* to allocate yet another array. */
- typedef le64 __attribute__((may_alias)) aliased_le64_t;
- typedef le32 __attribute__((may_alias)) aliased_le32_t;
+ typedef le64 _may_alias_attribute aliased_le64_t;
+ typedef le32 _may_alias_attribute aliased_le32_t;
u64 * chunk_offsets_p = chunk_offsets;
if (alt_chunk_table) {
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
[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,
wimlib_assert(size <= ctx->cur_stream->size - ctx->cur_stream_offset);
if (ctx->cur_stream_offset == 0) {
- u32 flags;
/* Starting a new stream. */
DEBUG("Begin new stream (size=%"PRIu64").",
ctx->cur_stream->size);
- flags = BEGIN_STREAM_FLAG_PARTIAL_RESOURCE;
- if (size == ctx->cur_stream->size)
- flags |= BEGIN_STREAM_FLAG_WHOLE_STREAM;
ret = (*ctx->cbs.begin_stream)(ctx->cur_stream,
- flags,
ctx->cbs.begin_stream_ctx);
if (ret)
return ret;
/* 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. */
/* Callback for starting to read a stream while calculating its SHA1 message
* digest. */
static int
-hasher_begin_stream(struct wim_lookup_table_entry *lte, u32 flags,
- void *_ctx)
+hasher_begin_stream(struct wim_lookup_table_entry *lte, void *_ctx)
{
struct hasher_context *ctx = _ctx;
if (ctx->cbs.begin_stream == NULL)
return 0;
else
- return (*ctx->cbs.begin_stream)(lte, flags,
- ctx->cbs.begin_stream_ctx);
+ return (*ctx->cbs.begin_stream)(lte, ctx->cbs.begin_stream_ctx);
}
/* A consume_data_callback_t implementation that continues calculating the SHA1
return (*ctx->cbs.consume_chunk)(chunk, size, ctx->cbs.consume_chunk_ctx);
}
-static void
-get_sha1_string(const u8 md[SHA1_HASH_SIZE], tchar *str)
-{
- for (size_t i = 0; i < SHA1_HASH_SIZE; i++)
- str += tsprintf(str, T("%02x"), md[i]);
-}
-
/* Callback for finishing reading a stream while calculating its SHA1 message
* digest. */
static int
if (wimlib_print_errors) {
tchar expected_hashstr[SHA1_HASH_SIZE * 2 + 1];
tchar actual_hashstr[SHA1_HASH_SIZE * 2 + 1];
- get_sha1_string(lte->hash, expected_hashstr);
- get_sha1_string(hash, actual_hashstr);
+ sprint_hash(lte->hash, expected_hashstr);
+ sprint_hash(hash, actual_hashstr);
ERROR("The stream is corrupted!\n"
" (Expected SHA1=%"TS",\n"
" got SHA1=%"TS")",
{
int ret;
- ret = (*cbs->begin_stream)(lte, 0, cbs->begin_stream_ctx);
+ ret = (*cbs->begin_stream)(lte, cbs->begin_stream_ctx);
if (ret)
return ret;
/* A consume_data_callback_t implementation that writes the chunk of data to a
* file descriptor. */
-int
+static int
extract_chunk_to_fd(const void *chunk, size_t size, void *_fd_p)
{
struct filedes *fd = _fd_p;
git://wimlib.net / wimlib / blobdiff