X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fresource.c;h=4b91be6b010104fc2c26cf65f5a16b77606f357a;hp=5237b88a37fd646613770df5768e3f56625cd2ab;hb=ef8f175fc63c907e7f65498c2979f0da153a20d9;hpb=f3e97b29c4a8c564d54b0fd11cd43a9b4cd6a8ad

diff --git a/src/resource.c b/src/resource.c
index 5237b88a..4b91be6b 100644
--- a/src/resource.c
+++ b/src/resource.c
@@ -42,59 +42,13 @@
 #  include <alloca.h>
 #endif
 
-/* Write @n bytes from @buf to the file descriptor @fd, retrying on internupt
- * and on short writes.
- *
- * Returns short count and set errno on failure. */
-static ssize_t
-full_write(int fd, const void *buf, size_t n)
-{
-	const void *p = buf;
-	ssize_t ret;
-	ssize_t total = 0;
-
-	while (total != n) {
-		ret = write(fd, p, n);
-		if (ret < 0) {
-			if (errno == EINTR)
-				continue;
-			else
-				break;
-		}
-		total += ret;
-		p += ret;
-	}
-	return total;
-}
-
-/* Read @n bytes from the file descriptor @fd to the buffer @buf, retrying on
- * internupt and on short reads.
- *
- * Returns short count and set errno on failure. */
-static size_t
-full_read(int fd, void *buf, size_t n)
-{
-	size_t bytes_remaining = n;
-	while (bytes_remaining) {
-		ssize_t bytes_read = read(fd, buf, bytes_remaining);
-		if (bytes_read < 0) {
-			if (errno == EINTR)
-				continue;
-			break;
-		}
-		bytes_remaining -= bytes_read;
-		buf += bytes_read;
-	}
-	return n - bytes_remaining;
-}
-
 /*
  * Reads all or part of a compressed WIM resource.
  *
  * Returns zero on success, nonzero on failure.
  */
 static int
-read_compressed_resource(FILE *fp,
+read_compressed_resource(int in_fd,
 			 u64 resource_compressed_size,
 			 u64 resource_uncompressed_size,
 			 u64 resource_offset,
@@ -208,8 +162,6 @@ read_compressed_resource(FILE *fp,
 	/* Skip over unneeded chunk table entries. */
 	u64 file_offset_of_needed_chunk_entries = resource_offset +
 				start_table_idx * chunk_entry_size;
-	if (fseeko(fp, file_offset_of_needed_chunk_entries, SEEK_SET))
-		goto read_error;
 
 	/* Number of bytes we need to read from the chunk table. */
 	size_t size = num_needed_chunk_entries * chunk_entry_size;
@@ -218,7 +170,8 @@ read_compressed_resource(FILE *fp,
 	 * avoid allocating another array. */
 	void *chunk_tab_buf = (void*)&chunk_offsets[num_needed_chunks] - size;
 
-	if (fread(chunk_tab_buf, 1, size, fp) != size)
+	if (full_pread(in_fd, chunk_tab_buf, size,
+		       file_offset_of_needed_chunk_entries) != size)
 		goto read_error;
 
 	/* Now fill in chunk_offsets from the entries we have read in
@@ -241,10 +194,7 @@ read_compressed_resource(FILE *fp,
 	/* Done with the chunk table now.  We must now seek to the first chunk
 	 * that is needed for the read. */
 
-	u64 file_offset_of_first_needed_chunk = resource_offset +
-				chunk_table_size + chunk_offsets[0];
-	if (fseeko(fp, file_offset_of_first_needed_chunk, SEEK_SET))
-		goto read_error;
+	u64 cur_read_offset = resource_offset + chunk_table_size + chunk_offsets[0];
 
 	/* Pointer to current position in the output buffer for uncompressed
 	 * data.  Alternatively, if using a callback function, we repeatedly
@@ -320,19 +270,24 @@ read_compressed_resource(FILE *fp,
 		 * is equal to the uncompressed chunk size. */
 		if (compressed_chunk_size == uncompressed_chunk_size) {
 			/* Uncompressed chunk */
-
-			if (start_offset != 0)
-				if (fseeko(fp, start_offset, SEEK_CUR))
-					goto read_error;
-			if (fread(out_p, 1, partial_chunk_size, fp) != partial_chunk_size)
+			if (full_pread(in_fd,
+				       cb ? out_p + start_offset : out_p,
+				       partial_chunk_size,
+				       cur_read_offset + start_offset) != partial_chunk_size)
+			{
 				goto read_error;
+			}
 		} else {
 			/* Compressed chunk */
 
 			/* Read the compressed data into compressed_buf. */
-			if (fread(compressed_buf, 1, compressed_chunk_size,
-						fp) != compressed_chunk_size)
+			if (full_pread(in_fd,
+				       compressed_buf,
+				       compressed_chunk_size,
+				       cur_read_offset) != compressed_chunk_size)
+			{
 				goto read_error;
+			}
 
 			/* For partial chunks and when writing directly to a
 			 * buffer, we must buffer the uncompressed data because
@@ -374,6 +329,7 @@ read_compressed_resource(FILE *fp,
 			 * written.  */
 			out_p += partial_chunk_size;
 		}
+		cur_read_offset += compressed_chunk_size;
 	}
 
 	ret = 0;
@@ -383,39 +339,11 @@ out:
 	return ret;
 
 read_error:
-	if (feof(fp))
-		ERROR("Unexpected EOF in compressed file resource");
-	else
-		ERROR_WITH_ERRNO("Error reading compressed file resource");
+	ERROR_WITH_ERRNO("Error reading compressed file resource");
 	ret = WIMLIB_ERR_READ;
 	goto out;
 }
 
-/*
- * Reads uncompressed data from an open file stream.
- */
-int
-read_uncompressed_resource(FILE *fp, u64 offset, u64 len, void *contents_ret)
-{
-	if (fseeko(fp, offset, SEEK_SET) != 0) {
-		ERROR("Failed to seek to byte %"PRIu64" of input file "
-		      "to read uncompressed resource (len = %"PRIu64")",
-		      offset, len);
-		return WIMLIB_ERR_READ;
-	}
-	if (fread(contents_ret, 1, len, fp) != len) {
-		if (feof(fp)) {
-			ERROR("Unexpected EOF in uncompressed file resource");
-		} else {
-			ERROR("Failed to read %"PRIu64" bytes from "
-			      "uncompressed resource at offset %"PRIu64,
-			      len, offset);
-		}
-		return WIMLIB_ERR_READ;
-	}
-	return 0;
-}
-
 /* Reads the contents of a struct resource_entry, as represented in the on-disk
  * format, from the memory pointed to by @p, and fills in the fields of @entry.
  * A pointer to the byte after the memory read at @p is returned. */
@@ -460,66 +388,6 @@ put_resource_entry(void *p, const struct resource_entry *entry)
 	return p;
 }
 
-static FILE *
-wim_get_fp(WIMStruct *w)
-{
-#ifdef WITH_FUSE
-	pthread_mutex_lock(&w->fp_tab_mutex);
-	FILE *fp;
-
-	wimlib_assert(w->filename != NULL);
-
-	for (size_t i = 0; i < w->num_allocated_fps; i++) {
-		if (w->fp_tab[i]) {
-			fp = w->fp_tab[i];
-			w->fp_tab[i] = NULL;
-			goto out_unlock;
-		}
-	}
-	DEBUG("Opening extra file descriptor to `%"TS"'", w->filename);
-	fp = tfopen(w->filename, T("rb"));
-	if (!fp)
-		ERROR_WITH_ERRNO("Failed to open `%"TS"'", w->filename);
-out_unlock:
-	pthread_mutex_unlock(&w->fp_tab_mutex);
-#else /* WITH_FUSE */
-	fp = w->fp;
-#endif /* !WITH_FUSE */
-	return fp;
-}
-
-static int
-wim_release_fp(WIMStruct *w, FILE *fp)
-{
-	int ret = 0;
-#ifdef WITH_FUSE
-	FILE **fp_tab;
-
-	pthread_mutex_lock(&w->fp_tab_mutex);
-
-	for (size_t i = 0; i < w->num_allocated_fps; i++) {
-		if (w->fp_tab[i] == NULL) {
-			w->fp_tab[i] = fp;
-			goto out_unlock;
-		}
-	}
-
-	fp_tab = REALLOC(w->fp_tab, sizeof(FILE*) * (w->num_allocated_fps + 4));
-	if (!fp_tab) {
-		ret = WIMLIB_ERR_NOMEM;
-		fclose(fp);
-		goto out_unlock;
-	}
-	w->fp_tab = fp_tab;
-	memset(&w->fp_tab[w->num_allocated_fps], 0, 4 * sizeof(FILE*));
-	w->fp_tab[w->num_allocated_fps] = fp;
-	w->num_allocated_fps += 4;
-out_unlock:
-	pthread_mutex_unlock(&w->fp_tab_mutex);
-#endif /* WITH_FUSE */
-	return ret;
-}
-
 static int
 read_partial_wim_resource(const struct wim_lookup_table_entry *lte,
 			  u64 size,
@@ -528,31 +396,19 @@ read_partial_wim_resource(const struct wim_lookup_table_entry *lte,
 			  int flags,
 			  u64 offset)
 {
-	FILE *wim_fp;
 	WIMStruct *wim;
+	int in_fd;
 	int ret;
 
 	wimlib_assert(lte->resource_location == RESOURCE_IN_WIM);
-	wimlib_assert(offset + size <= lte->resource_entry.original_size);
 
 	wim = lte->wim;
-
-	if (flags & WIMLIB_RESOURCE_FLAG_THREADSAFE_READ) {
-		wim_fp = wim_get_fp(wim);
-		if (!wim_fp) {
-			ret = -1;
-			goto out;
-		}
-	} else {
-		wim_fp = lte->wim->fp;
-	}
-
-	wimlib_assert(wim_fp != NULL);
+	in_fd = wim->in_fd;
 
 	if (lte->resource_entry.flags & WIM_RESHDR_FLAG_COMPRESSED &&
 	    !(flags & WIMLIB_RESOURCE_FLAG_RAW))
 	{
-		ret = read_compressed_resource(wim_fp,
+		ret = read_compressed_resource(in_fd,
 					       lte->resource_entry.size,
 					       lte->resource_entry.original_size,
 					       lte->resource_entry.offset,
@@ -563,41 +419,32 @@ read_partial_wim_resource(const struct wim_lookup_table_entry *lte,
 					       ctx_or_buf);
 	} else {
 		offset += lte->resource_entry.offset;
-
-		if (fseeko(wim_fp, offset, SEEK_SET)) {
-			ERROR_WITH_ERRNO("Failed to seek to offset %"PRIu64
-					 " in WIM", offset);
-			ret = WIMLIB_ERR_READ;
-			goto out_release_fp;
-		}
 		if (cb) {
 			/* Send data to callback function */
 			u8 buf[min(WIM_CHUNK_SIZE, size)];
 			while (size) {
 				size_t bytes_to_read = min(WIM_CHUNK_SIZE, size);
-				size_t bytes_read = fread(buf, 1, bytes_to_read, wim_fp);
-				
+				size_t bytes_read = full_pread(in_fd, buf,
+							       bytes_to_read, offset);
 				if (bytes_read != bytes_to_read)
 					goto read_error;
 				ret = cb(buf, bytes_read, ctx_or_buf);
 				if (ret)
-					goto out_release_fp;
+					goto out;
 				size -= bytes_read;
+				offset += bytes_read;
 			}
 		} else {
 			/* Send data directly to a buffer */
-			if (fread(ctx_or_buf, 1, size, wim_fp) != size)
+			if (full_pread(in_fd, ctx_or_buf, size, offset) != size)
 				goto read_error;
 		}
 		ret = 0;
 	}
-	goto out_release_fp;
+	goto out;
 read_error:
 	ERROR_WITH_ERRNO("Error reading data from WIM");
 	ret = WIMLIB_ERR_READ;
-out_release_fp:
-	if (flags & WIMLIB_RESOURCE_FLAG_THREADSAFE_READ)
-		ret |= wim_release_fp(wim, wim_fp);
 out:
 	if (ret) {
 		if (errno == 0)
@@ -609,12 +456,9 @@ out:
 
 int
 read_partial_wim_resource_into_buf(const struct wim_lookup_table_entry *lte,
-				   size_t size, u64 offset, void *buf,
-				   bool threadsafe)
+				   size_t size, u64 offset, void *buf)
 {
-	return read_partial_wim_resource(lte, size, NULL, buf,
-					 threadsafe ? WIMLIB_RESOURCE_FLAG_THREADSAFE_READ : 0,
-					 offset);
+	return read_partial_wim_resource(lte, size, NULL, buf, 0, offset);
 }
 
 static int
@@ -628,6 +472,7 @@ read_wim_resource_prefix(const struct wim_lookup_table_entry *lte,
 }
 
 
+#ifndef __WIN32__
 static int
 read_file_on_disk_prefix(const struct wim_lookup_table_entry *lte,
 			 u64 size,
@@ -674,6 +519,7 @@ out_close:
 	close(fd);
 	return ret;
 }
+#endif /* !__WIN32__ */
 
 static int
 read_buffer_prefix(const struct wim_lookup_table_entry *lte,
@@ -717,8 +563,6 @@ typedef int (*read_resource_prefix_handler_t)(const struct wim_lookup_table_entr
  * size until the resource is exhausted.
  *
  * If the resource is located in a WIM file, @flags can be:
- *   * WIMLIB_RESOURCE_FLAG_THREADSAFE_READ if it must be safe to access the resource
- *     concurrently by multiple threads.
  *   * WIMLIB_RESOURCE_FLAG_RAW if the raw compressed data is to be supplied
  *     instead of the uncompressed data.
  * Otherwise, the @flags are ignored.
@@ -730,7 +574,9 @@ read_resource_prefix(const struct wim_lookup_table_entry *lte,
 {
 	static const read_resource_prefix_handler_t handlers[] = {
 		[RESOURCE_IN_WIM]             = read_wim_resource_prefix,
+	#ifndef __WIN32__
 		[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,
@@ -750,12 +596,9 @@ read_resource_prefix(const struct wim_lookup_table_entry *lte,
 
 int
 read_full_resource_into_buf(const struct wim_lookup_table_entry *lte,
-			    void *buf, bool thread_safe)
+			    void *buf)
 {
-	return read_resource_prefix(lte,
-				    wim_resource_size(lte),
-				    NULL, buf,
-				    thread_safe ? WIMLIB_RESOURCE_FLAG_THREADSAFE_READ : 0);
+	return read_resource_prefix(lte, wim_resource_size(lte), NULL, buf, 0);
 }
 
 struct extract_ctx {
@@ -801,13 +644,13 @@ extract_wim_resource(const struct wim_lookup_table_entry *lte,
 			sha1_final(hash, &ctx.sha_ctx);
 			if (!hashes_equal(hash, lte->hash)) {
 			#ifdef ENABLE_ERROR_MESSAGES
-				ERROR_WITH_ERRNO("Invalid SHA1 message digest "
-						 "on the following WIM resource:");
+				ERROR("Invalid SHA1 message digest "
+				      "on the following WIM resource:");
 				print_lookup_table_entry(lte, stderr);
 				if (lte->resource_location == RESOURCE_IN_WIM)
 					ERROR("The WIM file appears to be corrupt!");
-				ret = WIMLIB_ERR_INVALID_RESOURCE_HASH;
 			#endif
+				ret = WIMLIB_ERR_INVALID_RESOURCE_HASH;
 			}
 		}
 	} else {
@@ -838,6 +681,29 @@ extract_wim_resource_to_fd(const struct wim_lookup_table_entry *lte,
 	return extract_wim_resource(lte, size, extract_wim_chunk_to_fd, &fd);
 }
 
+
+static int
+sha1_chunk(const void *buf, size_t len, void *ctx)
+{
+	sha1_update(ctx, buf, len);
+	return 0;
+}
+
+/* Calculate the SHA1 message digest of a stream. */
+int
+sha1_resource(struct wim_lookup_table_entry *lte)
+{
+	int ret;
+	SHA_CTX sha_ctx;
+
+	sha1_init(&sha_ctx);
+	ret = read_resource_prefix(lte, wim_resource_size(lte),
+				   sha1_chunk, &sha_ctx, 0);
+	if (ret == 0)
+		sha1_final(lte->hash, &sha_ctx);
+	return ret;
+}
+
 /*
  * Copies the file resource specified by the lookup table entry @lte from the
  * input WIM to the output WIM that has its FILE * given by
@@ -854,7 +720,7 @@ copy_resource(struct wim_lookup_table_entry *lte, void *wim)
 	WIMStruct *w = wim;
 	int ret;
 
-	ret = write_wim_resource(lte, w->out_fp,
+	ret = write_wim_resource(lte, w->out_fd,
 				 wim_resource_compression_type(lte),
 				 &lte->output_resource_entry, 0);
 	if (ret == 0) {