X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fresource.c;h=300aec8f1cbec29e0b919bba8243984e7e518271;hp=b45db5973a9e261dfb316e0c355dbee04ce5f130;hb=9e5404f2c773173ebaae519d7ebacb2d802b263f;hpb=ad8c3f70361e25b7c1bbc46d4429749c7215fa12

diff --git a/src/resource.c b/src/resource.c
index b45db597..300aec8f 100644
--- 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;
@@ -562,6 +568,28 @@ read_error:
 	goto out_free_memory;
 }
 
+static int
+fill_zeroes(u64 size, consume_data_callback_t cb, void *cb_ctx)
+{
+	if (unlikely(size)) {
+		u8 buf[min(size, BUFFER_SIZE)];
+
+		memset(buf, 0, sizeof(buf));
+
+		do {
+			size_t len;
+			int ret;
+
+			len = min(size, BUFFER_SIZE);
+			ret = cb(buf, len, cb_ctx);
+			if (ret)
+				return ret;
+			size -= len;
+		} while (size);
+	}
+	return 0;
+}
+
 /* Read raw data from a file descriptor at the specified offset, feeding the
  * data it in chunks into the specified callback function.  */
 static int
@@ -654,11 +682,37 @@ read_partial_wim_resource(const struct wim_resource_spec *rspec,
 		return read_compressed_wim_resource(rspec, &range, 1,
 						    cb, cb_ctx);
 	} else {
-		return read_raw_file_data(&rspec->wim->in_fd,
-					  rspec->offset_in_wim + offset,
-					  size,
-					  cb,
-					  cb_ctx);
+		/* Reading uncompressed resource.  For completeness, handle the
+		 * weird case where size_in_wim < uncompressed_size.  */
+
+		u64 read_size;
+		u64 zeroes_size;
+		int ret;
+
+		if (likely(offset + size <= rspec->size_in_wim) ||
+		    rspec->is_pipable)
+		{
+			read_size = size;
+			zeroes_size = 0;
+		} else {
+			if (offset >= rspec->size_in_wim) {
+				read_size = 0;
+				zeroes_size = size;
+			} else {
+				read_size = rspec->size_in_wim - offset;
+				zeroes_size = offset + size - rspec->size_in_wim;
+			}
+		}
+
+		ret = read_raw_file_data(&rspec->wim->in_fd,
+					 rspec->offset_in_wim + offset,
+					 read_size,
+					 cb,
+					 cb_ctx);
+		if (ret)
+			return ret;
+
+		return fill_zeroes(zeroes_size, cb, cb_ctx);
 	}
 }
 
@@ -710,7 +764,6 @@ read_wim_stream_prefix(const struct wim_lookup_table_entry *lte, u64 size,
 					 cb, cb_ctx);
 }
 
-#ifndef __WIN32__
 /* This function handles reading stream data that is located in an external
  * file,  such as a file that has been added to the WIM image through execution
  * of a wimlib_add_command.
@@ -731,7 +784,7 @@ read_file_on_disk_prefix(const struct wim_lookup_table_entry *lte, u64 size,
 
 	DEBUG("Reading %"PRIu64" bytes from \"%"TS"\"", size, lte->file_on_disk);
 
-	raw_fd = open(lte->file_on_disk, O_BINARY | O_RDONLY);
+	raw_fd = topen(lte->file_on_disk, O_BINARY | O_RDONLY);
 	if (raw_fd < 0) {
 		ERROR_WITH_ERRNO("Can't open \"%"TS"\"", lte->file_on_disk);
 		return WIMLIB_ERR_OPEN;
@@ -741,7 +794,34 @@ read_file_on_disk_prefix(const struct wim_lookup_table_entry *lte, u64 size,
 	filedes_close(&fd);
 	return ret;
 }
-#endif /* !__WIN32__ */
+
+#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.  */
@@ -779,19 +859,16 @@ read_stream_prefix(const struct wim_lookup_table_entry *lte, u64 size,
 {
 	static const read_stream_prefix_handler_t handlers[] = {
 		[RESOURCE_IN_WIM]             = read_wim_stream_prefix,
-	#ifdef __WIN32__
-		[RESOURCE_IN_FILE_ON_DISK]    = read_win32_file_prefix,
-	#else
 		[RESOURCE_IN_FILE_ON_DISK]    = read_file_on_disk_prefix,
-	#endif
 		[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,
 	#endif
 	#ifdef __WIN32__
+		[RESOURCE_IN_WINNT_FILE_ON_DISK] = read_winnt_file_prefix,
 		[RESOURCE_WIN32_ENCRYPTED]    = read_win32_encrypted_file_prefix,
 	#endif
 	};
@@ -940,10 +1017,17 @@ streamifier_cb(const void *chunk, size_t size, void *_ctx)
 	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);
-		ret = (*ctx->cbs.begin_stream)(ctx->cur_stream, true,
+
+		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;
@@ -952,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.  */
@@ -989,7 +1073,7 @@ struct hasher_context {
 /* Callback for starting to read a stream while calculating its SHA1 message
  * digest.  */
 static int
-hasher_begin_stream(struct wim_lookup_table_entry *lte, bool is_partial_res,
+hasher_begin_stream(struct wim_lookup_table_entry *lte, u32 flags,
 		    void *_ctx)
 {
 	struct hasher_context *ctx = _ctx;
@@ -999,7 +1083,7 @@ hasher_begin_stream(struct wim_lookup_table_entry *lte, bool is_partial_res,
 	if (ctx->cbs.begin_stream == NULL)
 		return 0;
 	else
-		return (*ctx->cbs.begin_stream)(lte, is_partial_res,
+		return (*ctx->cbs.begin_stream)(lte, flags,
 						ctx->cbs.begin_stream_ctx);
 }
 
@@ -1089,7 +1173,7 @@ read_full_stream_with_cbs(struct wim_lookup_table_entry *lte,
 {
 	int ret;
 
-	ret = (*cbs->begin_stream)(lte, false, cbs->begin_stream_ctx);
+	ret = (*cbs->begin_stream)(lte, 0, cbs->begin_stream_ctx);
 	if (ret)
 		return ret;
 
@@ -1117,7 +1201,6 @@ read_full_stream_with_sha1(struct wim_lookup_table_entry *lte,
 		.consume_chunk_ctx	= &hasher_ctx,
 		.end_stream		= hasher_end_stream,
 		.end_stream_ctx		= &hasher_ctx,
-
 	};
 	return read_full_stream_with_cbs(lte, &hasher_cbs);
 }