X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fextract.c;h=ea9c25228d8c8a4877a59223b6daa78e2777d749;hp=b0df25d0719245c3dbab0d3580ea524019a607cb;hb=846d3ae386f6c12953816108c04de244533e3a4a;hpb=29ac4319aa9c75811cd5629cd3471a681fbeb552

diff --git a/src/extract.c b/src/extract.c
index b0df25d0..ea9c2522 100644
--- a/src/extract.c
+++ b/src/extract.c
@@ -6,7 +6,7 @@
  */
 
 /*
- * Copyright (C) 2012, 2013, 2014 Eric Biggers
+ * Copyright (C) 2012, 2013, 2014, 2015 Eric Biggers
  *
  * 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
@@ -39,12 +39,18 @@
 #  include "config.h"
 #endif
 
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
 #include "wimlib/apply.h"
+#include "wimlib/assert.h"
+#include "wimlib/blob_table.h"
 #include "wimlib/dentry.h"
 #include "wimlib/encoding.h"
 #include "wimlib/endianness.h"
 #include "wimlib/error.h"
-#include "wimlib/lookup_table.h"
 #include "wimlib/metadata.h"
 #include "wimlib/pathlist.h"
 #include "wimlib/paths.h"
@@ -52,18 +58,10 @@
 #include "wimlib/resource.h"
 #include "wimlib/security.h"
 #include "wimlib/unix_data.h"
-#ifdef __WIN32__
-#  include "wimlib/win32.h" /* for realpath() equivalent */
-#endif
-#include "wimlib/xml.h"
 #include "wimlib/wildcard.h"
 #include "wimlib/wim.h"
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <sys/stat.h>
-#include <unistd.h>
+#include "wimlib/win32.h" /* for realpath() equivalent */
+#include "wimlib/xml.h"
 
 #define WIMLIB_EXTRACT_FLAG_FROM_PIPE   0x80000000
 #define WIMLIB_EXTRACT_FLAG_IMAGEMODE   0x40000000
@@ -98,7 +96,7 @@ do_file_extract_progress(struct apply_ctx *ctx, enum wimlib_progress_msg msg)
 }
 
 static int
-start_file_phase(struct apply_ctx *ctx, uint64_t end_file_count, enum wimlib_progress_msg msg)
+start_file_phase(struct apply_ctx *ctx, u64 end_file_count, enum wimlib_progress_msg msg)
 {
 	ctx->progress.extract.current_file_count = 0;
 	ctx->progress.extract.end_file_count = end_file_count;
@@ -106,13 +104,13 @@ start_file_phase(struct apply_ctx *ctx, uint64_t end_file_count, enum wimlib_pro
 }
 
 int
-start_file_structure_phase(struct apply_ctx *ctx, uint64_t end_file_count)
+start_file_structure_phase(struct apply_ctx *ctx, u64 end_file_count)
 {
 	return start_file_phase(ctx, end_file_count, WIMLIB_PROGRESS_MSG_EXTRACT_FILE_STRUCTURE);
 }
 
 int
-start_file_metadata_phase(struct apply_ctx *ctx, uint64_t end_file_count)
+start_file_metadata_phase(struct apply_ctx *ctx, u64 end_file_count)
 {
 	return start_file_phase(ctx, end_file_count, WIMLIB_PROGRESS_MSG_EXTRACT_METADATA);
 }
@@ -136,180 +134,124 @@ end_file_metadata_phase(struct apply_ctx *ctx)
 	return end_file_phase(ctx, WIMLIB_PROGRESS_MSG_EXTRACT_METADATA);
 }
 
-/* Check whether the extraction of a dentry should be skipped completely.  */
-static bool
-dentry_is_supported(struct wim_dentry *dentry,
-		    const struct wim_features *supported_features)
-{
-	struct wim_inode *inode = dentry->d_inode;
-
-	if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
-		return supported_features->reparse_points ||
-			(inode_is_symlink(inode) &&
-			 supported_features->symlink_reparse_points);
-	}
-	if (inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED) {
-		if (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY)
-			return supported_features->encrypted_directories != 0;
-		else
-			return supported_features->encrypted_files != 0;
-	}
-	return true;
-}
-
-
-#define PWM_ALLOW_WIM_HDR 0x00001
+#define PWM_FOUND_WIM_HDR (-1)
 
-/* Read the header from a stream in a pipable WIM.  */
+/* Read the header for a blob in a pipable WIM.  If @pwm_hdr_ret is not NULL,
+ * also look for a pipable WIM header and return PWM_FOUND_WIM_HDR if found.  */
 static int
-read_pwm_stream_header(WIMStruct *pwm, struct wim_lookup_table_entry *lte,
-		       struct wim_resource_spec *rspec,
-		       int flags, struct wim_header_disk *hdr_ret)
+read_pwm_blob_header(WIMStruct *pwm, u8 hash_ret[SHA1_HASH_SIZE],
+		     struct wim_reshdr *reshdr_ret,
+		     struct wim_header_disk *pwm_hdr_ret)
 {
-	union {
-		struct pwm_stream_hdr stream_hdr;
-		struct wim_header_disk pwm_hdr;
-	} buf;
-	struct wim_reshdr reshdr;
 	int ret;
+	struct pwm_blob_hdr blob_hdr;
+	u64 magic;
 
-	ret = full_read(&pwm->in_fd, &buf.stream_hdr, sizeof(buf.stream_hdr));
-	if (ret)
+	ret = full_read(&pwm->in_fd, &blob_hdr, sizeof(blob_hdr));
+	if (unlikely(ret))
 		goto read_error;
 
-	if ((flags & PWM_ALLOW_WIM_HDR) &&
-	    le64_to_cpu(buf.stream_hdr.magic) == PWM_MAGIC)
-	{
-		BUILD_BUG_ON(sizeof(buf.pwm_hdr) < sizeof(buf.stream_hdr));
-		ret = full_read(&pwm->in_fd, &buf.stream_hdr + 1,
-				sizeof(buf.pwm_hdr) - sizeof(buf.stream_hdr));
+	magic = le64_to_cpu(blob_hdr.magic);
 
-		if (ret)
+	if (magic == PWM_MAGIC && pwm_hdr_ret != NULL) {
+		memcpy(pwm_hdr_ret, &blob_hdr, sizeof(blob_hdr));
+		ret = full_read(&pwm->in_fd,
+				(u8 *)pwm_hdr_ret + sizeof(blob_hdr),
+				sizeof(*pwm_hdr_ret) - sizeof(blob_hdr));
+		if (unlikely(ret))
 			goto read_error;
-		lte->resource_location = RESOURCE_NONEXISTENT;
-		memcpy(hdr_ret, &buf.pwm_hdr, sizeof(buf.pwm_hdr));
-		return 0;
+		return PWM_FOUND_WIM_HDR;
 	}
 
-	if (le64_to_cpu(buf.stream_hdr.magic) != PWM_STREAM_MAGIC) {
-		ERROR("Data read on pipe is invalid (expected stream header).");
+	if (unlikely(magic != PWM_BLOB_MAGIC)) {
+		ERROR("Data read on pipe is invalid (expected blob header)");
 		return WIMLIB_ERR_INVALID_PIPABLE_WIM;
 	}
 
-	copy_hash(lte->hash, buf.stream_hdr.hash);
+	copy_hash(hash_ret, blob_hdr.hash);
+
+	reshdr_ret->size_in_wim = 0; /* Not available  */
+	reshdr_ret->flags = le32_to_cpu(blob_hdr.flags);
+	reshdr_ret->offset_in_wim = pwm->in_fd.offset;
+	reshdr_ret->uncompressed_size = le64_to_cpu(blob_hdr.uncompressed_size);
+
+	if (unlikely(reshdr_ret->uncompressed_size == 0)) {
+		ERROR("Data read on pipe is invalid (resource is of 0 size)");
+		return WIMLIB_ERR_INVALID_PIPABLE_WIM;
+	}
 
-	reshdr.size_in_wim = 0;
-	reshdr.flags = le32_to_cpu(buf.stream_hdr.flags);
-	reshdr.offset_in_wim = pwm->in_fd.offset;
-	reshdr.uncompressed_size = le64_to_cpu(buf.stream_hdr.uncompressed_size);
-	wim_res_hdr_to_spec(&reshdr, pwm, rspec);
-	lte_bind_wim_resource_spec(lte, rspec);
-	lte->flags = rspec->flags;
-	lte->size = rspec->uncompressed_size;
-	lte->offset_in_res = 0;
 	return 0;
 
 read_error:
-	ERROR_WITH_ERRNO("Error reading pipable WIM from pipe");
+	if (ret == WIMLIB_ERR_UNEXPECTED_END_OF_FILE)
+		ERROR("The pipe ended before all needed data was sent!");
+	else
+		ERROR_WITH_ERRNO("Error reading pipable WIM from pipe");
 	return ret;
 }
 
 static int
-load_streams_from_pipe(struct apply_ctx *ctx,
-		       const struct read_stream_list_callbacks *cbs)
+read_blobs_from_pipe(struct apply_ctx *ctx, const struct read_blob_callbacks *cbs)
 {
-	struct wim_lookup_table_entry *found_lte = NULL;
-	struct wim_resource_spec *rspec = NULL;
-	struct wim_lookup_table *lookup_table;
 	int ret;
+	u8 hash[SHA1_HASH_SIZE];
+	struct wim_reshdr reshdr;
+	struct wim_header_disk pwm_hdr;
+	struct wim_resource_descriptor rdesc;
+	struct blob_descriptor *blob;
 
-	ret = WIMLIB_ERR_NOMEM;
-	found_lte = new_lookup_table_entry();
-	if (!found_lte)
-		goto out;
-
-	rspec = MALLOC(sizeof(struct wim_resource_spec));
-	if (!rspec)
-		goto out;
-
-	lookup_table = ctx->wim->lookup_table;
-	memcpy(ctx->progress.extract.guid, ctx->wim->hdr.guid, WIM_GUID_LEN);
+	copy_guid(ctx->progress.extract.guid, ctx->wim->hdr.guid);
 	ctx->progress.extract.part_number = ctx->wim->hdr.part_number;
 	ctx->progress.extract.total_parts = ctx->wim->hdr.total_parts;
 	ret = extract_progress(ctx, WIMLIB_PROGRESS_MSG_EXTRACT_SPWM_PART_BEGIN);
 	if (ret)
-		goto out;
+		return ret;
 
-	while (ctx->num_streams_remaining) {
-		struct wim_header_disk pwm_hdr;
-		struct wim_lookup_table_entry *needed_lte;
+	while (ctx->num_blobs_remaining) {
 
-		if (found_lte->resource_location != RESOURCE_NONEXISTENT)
-			lte_unbind_wim_resource_spec(found_lte);
-		ret = read_pwm_stream_header(ctx->wim, found_lte, rspec,
-					     PWM_ALLOW_WIM_HDR, &pwm_hdr);
-		if (ret)
-			goto out;
+		ret = read_pwm_blob_header(ctx->wim, hash, &reshdr, &pwm_hdr);
 
-		if ((found_lte->resource_location != RESOURCE_NONEXISTENT)
-		    && !(found_lte->flags & WIM_RESHDR_FLAG_METADATA)
-		    && (needed_lte = lookup_stream(lookup_table, found_lte->hash))
-		    && (needed_lte->out_refcnt))
-		{
-			needed_lte->offset_in_res = found_lte->offset_in_res;
-			needed_lte->flags = found_lte->flags;
-			needed_lte->size = found_lte->size;
+		if (ret == PWM_FOUND_WIM_HDR) {
+			u16 part_number = le16_to_cpu(pwm_hdr.part_number);
+			u16 total_parts = le16_to_cpu(pwm_hdr.total_parts);
+
+			if (part_number == ctx->progress.extract.part_number &&
+			    total_parts == ctx->progress.extract.total_parts &&
+			    guids_equal(pwm_hdr.guid, ctx->progress.extract.guid))
+				continue;
 
-			lte_unbind_wim_resource_spec(found_lte);
-			lte_bind_wim_resource_spec(needed_lte, rspec);
+			copy_guid(ctx->progress.extract.guid, pwm_hdr.guid);
+			ctx->progress.extract.part_number = part_number;
+			ctx->progress.extract.total_parts = total_parts;
+			ret = extract_progress(ctx, WIMLIB_PROGRESS_MSG_EXTRACT_SPWM_PART_BEGIN);
+			if (ret)
+				return ret;
 
-			ret = (*cbs->begin_stream)(needed_lte,
-						   cbs->begin_stream_ctx);
-			if (ret) {
-				lte_unbind_wim_resource_spec(needed_lte);
-				goto out;
-			}
+			continue;
+		}
 
-			ret = extract_stream(needed_lte, needed_lte->size,
-					     cbs->consume_chunk,
-					     cbs->consume_chunk_ctx);
+		if (ret)
+			return ret;
 
-			ret = (*cbs->end_stream)(needed_lte, ret,
-						 cbs->end_stream_ctx);
-			lte_unbind_wim_resource_spec(needed_lte);
-			if (ret)
-				goto out;
-			ctx->num_streams_remaining--;
-		} else if (found_lte->resource_location != RESOURCE_NONEXISTENT) {
-			ret = skip_wim_stream(found_lte);
+		if (!(reshdr.flags & WIM_RESHDR_FLAG_METADATA)
+		    && (blob = lookup_blob(ctx->wim->blob_table, hash))
+		    && (blob->out_refcnt))
+		{
+			wim_reshdr_to_desc_and_blob(&reshdr, ctx->wim, &rdesc, blob);
+			ret = read_blob_with_sha1(blob, cbs);
+			blob_unset_is_located_in_wim_resource(blob);
 			if (ret)
-				goto out;
+				return ret;
+			ctx->num_blobs_remaining--;
 		} else {
-			u16 part_number = le16_to_cpu(pwm_hdr.part_number);
-			u16 total_parts = le16_to_cpu(pwm_hdr.total_parts);
-
-			if (part_number != ctx->progress.extract.part_number ||
-			    total_parts != ctx->progress.extract.total_parts ||
-			    memcmp(pwm_hdr.guid, ctx->progress.extract.guid,
-				   WIM_GUID_LEN))
-			{
-				ctx->progress.extract.part_number = part_number;
-				ctx->progress.extract.total_parts = total_parts;
-				memcpy(ctx->progress.extract.guid,
-				       pwm_hdr.guid, WIM_GUID_LEN);
-				ret = extract_progress(ctx,
-						       WIMLIB_PROGRESS_MSG_EXTRACT_SPWM_PART_BEGIN);
-				if (ret)
-					goto out;
-			}
+			wim_reshdr_to_desc(&reshdr, ctx->wim, &rdesc);
+			ret = skip_wim_resource(&rdesc);
+			if (ret)
+				return ret;
 		}
 	}
-	ret = 0;
-out:
-	if (found_lte && found_lte->resource_location != RESOURCE_IN_WIM)
-		FREE(rspec);
-	free_lookup_table_entry(found_lte);
-	return ret;
+
+	return 0;
 }
 
 /* Creates a temporary file opened for writing.  The open file descriptor is
@@ -352,17 +294,17 @@ retry:
 }
 
 static int
-begin_extract_stream_wrapper(struct wim_lookup_table_entry *lte, void *_ctx)
+begin_extract_blob_wrapper(struct blob_descriptor *blob, void *_ctx)
 {
 	struct apply_ctx *ctx = _ctx;
 
-	ctx->cur_stream = lte;
-	ctx->cur_stream_offset = 0;
+	ctx->cur_blob = blob;
+	ctx->cur_blob_offset = 0;
 
-	if (unlikely(lte->out_refcnt > MAX_OPEN_STREAMS))
+	if (unlikely(blob->out_refcnt > MAX_OPEN_FILES))
 		return create_temporary_file(&ctx->tmpfile_fd, &ctx->tmpfile_name);
-	else
-		return (*ctx->saved_cbs->begin_stream)(lte, ctx->saved_cbs->begin_stream_ctx);
+
+	return call_begin_blob(blob, ctx->saved_cbs);
 }
 
 static int
@@ -372,25 +314,23 @@ extract_chunk_wrapper(const void *chunk, size_t size, void *_ctx)
 	union wimlib_progress_info *progress = &ctx->progress;
 	int ret;
 
-	ctx->cur_stream_offset += size;
+	ctx->cur_blob_offset += size;
 
 	if (likely(ctx->supported_features.hard_links)) {
 		progress->extract.completed_bytes +=
-			(u64)size * ctx->cur_stream->out_refcnt;
-		if (ctx->cur_stream_offset == ctx->cur_stream->size)
-			progress->extract.completed_streams += ctx->cur_stream->out_refcnt;
+			(u64)size * ctx->cur_blob->out_refcnt;
+		if (ctx->cur_blob_offset == ctx->cur_blob->size)
+			progress->extract.completed_streams += ctx->cur_blob->out_refcnt;
 	} else {
-		const struct stream_owner *owners = stream_owners(ctx->cur_stream);
-		for (u32 i = 0; i < ctx->cur_stream->out_refcnt; i++) {
-			const struct wim_inode *inode = owners[i].inode;
+		const struct blob_extraction_target *targets =
+			blob_extraction_targets(ctx->cur_blob);
+		for (u32 i = 0; i < ctx->cur_blob->out_refcnt; i++) {
+			const struct wim_inode *inode = targets[i].inode;
 			const struct wim_dentry *dentry;
 
-			list_for_each_entry(dentry,
-					    &inode->i_extraction_aliases,
-					    d_extraction_alias_node)
-			{
+			inode_for_each_extraction_alias(dentry, inode) {
 				progress->extract.completed_bytes += size;
-				if (ctx->cur_stream_offset == ctx->cur_stream->size)
+				if (ctx->cur_blob_offset == ctx->cur_blob->size)
 					progress->extract.completed_streams++;
 			}
 		}
@@ -436,127 +376,91 @@ extract_chunk_wrapper(const void *chunk, size_t size, void *_ctx)
 					 ctx->tmpfile_name);
 		}
 		return ret;
-	} else {
-		return (*ctx->saved_cbs->consume_chunk)(chunk, size,
-							ctx->saved_cbs->consume_chunk_ctx);
 	}
+
+	return call_consume_chunk(chunk, size, ctx->saved_cbs);
 }
 
+/* Copy the blob's data from the temporary file to each of its targets.
+ *
+ * This is executed only in the very uncommon case that a blob is being
+ * extracted to more than MAX_OPEN_FILES targets!  */
 static int
-extract_from_tmpfile(const tchar *tmpfile_name, struct apply_ctx *ctx)
+extract_from_tmpfile(const tchar *tmpfile_name,
+		     const struct blob_descriptor *orig_blob,
+		     const struct read_blob_callbacks *cbs)
 {
-	struct wim_lookup_table_entry tmpfile_lte;
-	struct wim_lookup_table_entry *orig_lte = ctx->cur_stream;
-	const struct read_stream_list_callbacks *cbs = ctx->saved_cbs;
+	struct blob_descriptor tmpfile_blob;
+	const struct blob_extraction_target *targets = blob_extraction_targets(orig_blob);
 	int ret;
-	const u32 orig_refcnt = orig_lte->out_refcnt;
-
-	BUILD_BUG_ON(MAX_OPEN_STREAMS < ARRAY_LEN(orig_lte->inline_stream_owners));
-
-	struct stream_owner *owners = orig_lte->stream_owners;
-
-	/* Copy the stream's data from the temporary file to each of its
-	 * destinations.
-	 *
-	 * This is executed only in the very uncommon case that a
-	 * single-instance stream is being extracted to more than
-	 * MAX_OPEN_STREAMS locations!  */
-
-	memcpy(&tmpfile_lte, orig_lte, sizeof(struct wim_lookup_table_entry));
-	tmpfile_lte.resource_location = RESOURCE_IN_FILE_ON_DISK;
-	tmpfile_lte.file_on_disk = ctx->tmpfile_name;
-	ret = 0;
-	for (u32 i = 0; i < orig_refcnt; i++) {
-
-		/* Note: it usually doesn't matter whether we pass the original
-		 * stream entry to callbacks provided by the extraction backend
-		 * as opposed to the tmpfile stream entry, since they shouldn't
-		 * actually read data from the stream other than through the
-		 * read_stream_prefix() call below.  But for
-		 * WIMLIB_EXTRACT_FLAG_WIMBOOT mode on Windows it does matter
-		 * because it needs the original stream location in order to
-		 * create the external backing reference.  */
-
-		orig_lte->out_refcnt = 1;
-		orig_lte->inline_stream_owners[0] = owners[i];
-
-		ret = (*cbs->begin_stream)(orig_lte, cbs->begin_stream_ctx);
-		if (ret)
-			break;
 
-		/* Extra SHA-1 isn't necessary here, but it shouldn't hurt as
-		 * this case is very rare anyway.  */
-		ret = extract_stream(&tmpfile_lte, tmpfile_lte.size,
-				     cbs->consume_chunk,
-				     cbs->consume_chunk_ctx);
+	memcpy(&tmpfile_blob, orig_blob, sizeof(struct blob_descriptor));
+	tmpfile_blob.blob_location = BLOB_IN_FILE_ON_DISK;
+	tmpfile_blob.file_on_disk = (tchar *)tmpfile_name;
+	tmpfile_blob.out_refcnt = 1;
 
-		ret = (*cbs->end_stream)(orig_lte, ret, cbs->end_stream_ctx);
+	for (u32 i = 0; i < orig_blob->out_refcnt; i++) {
+		tmpfile_blob.inline_blob_extraction_targets[0] = targets[i];
+		ret = read_blob_with_cbs(&tmpfile_blob, cbs);
 		if (ret)
-			break;
+			return ret;
 	}
-	FREE(owners);
-	orig_lte->out_refcnt = 0;
-	return ret;
+	return 0;
 }
 
 static int
-end_extract_stream_wrapper(struct wim_lookup_table_entry *stream,
-			   int status, void *_ctx)
+end_extract_blob_wrapper(struct blob_descriptor *blob, int status, void *_ctx)
 {
 	struct apply_ctx *ctx = _ctx;
 
 	if (unlikely(filedes_valid(&ctx->tmpfile_fd))) {
 		filedes_close(&ctx->tmpfile_fd);
 		if (!status)
-			status = extract_from_tmpfile(ctx->tmpfile_name, ctx);
+			status = extract_from_tmpfile(ctx->tmpfile_name, blob,
+						      ctx->saved_cbs);
 		filedes_invalidate(&ctx->tmpfile_fd);
 		tunlink(ctx->tmpfile_name);
 		FREE(ctx->tmpfile_name);
 		return status;
-	} else {
-		return (*ctx->saved_cbs->end_stream)(stream, status,
-						     ctx->saved_cbs->end_stream_ctx);
 	}
+
+	return call_end_blob(blob, status, ctx->saved_cbs);
 }
 
 /*
- * Read the list of single-instance streams to extract and feed their data into
- * the specified callback functions.
+ * Read the list of blobs to extract and feed their data into the specified
+ * callback functions.
  *
- * This handles checksumming each stream.
+ * This handles checksumming each blob.
  *
  * This also handles sending WIMLIB_PROGRESS_MSG_EXTRACT_STREAMS.
  *
- * This also works if the WIM is being read from a pipe, whereas attempting to
- * read streams directly (e.g. with read_full_stream_into_buf()) will not.
+ * This also works if the WIM is being read from a pipe.
  *
- * This also will split up streams that will need to be extracted to more than
- * MAX_OPEN_STREAMS locations, as measured by the 'out_refcnt' of each stream.
+ * This also will split up blobs that will need to be extracted to more than
+ * MAX_OPEN_FILES locations, as measured by the 'out_refcnt' of each blob.
  * Therefore, the apply_operations implementation need not worry about running
  * out of file descriptors, unless it might open more than one file descriptor
- * per nominal destination (e.g. Win32 currently might because the destination
- * file system might not support hard links).
+ * per 'blob_extraction_target' (e.g. Win32 currently might because the
+ * destination file system might not support hard links).
  */
 int
-extract_stream_list(struct apply_ctx *ctx,
-		    const struct read_stream_list_callbacks *cbs)
+extract_blob_list(struct apply_ctx *ctx, const struct read_blob_callbacks *cbs)
 {
-	struct read_stream_list_callbacks wrapper_cbs = {
-		.begin_stream      = begin_extract_stream_wrapper,
-		.begin_stream_ctx  = ctx,
-		.consume_chunk     = extract_chunk_wrapper,
-		.consume_chunk_ctx = ctx,
-		.end_stream        = end_extract_stream_wrapper,
-		.end_stream_ctx    = ctx,
+	struct read_blob_callbacks wrapper_cbs = {
+		.begin_blob	= begin_extract_blob_wrapper,
+		.consume_chunk	= extract_chunk_wrapper,
+		.end_blob	= end_extract_blob_wrapper,
+		.ctx		= ctx,
 	};
 	ctx->saved_cbs = cbs;
 	if (ctx->extract_flags & WIMLIB_EXTRACT_FLAG_FROM_PIPE) {
-		return load_streams_from_pipe(ctx, &wrapper_cbs);
+		return read_blobs_from_pipe(ctx, &wrapper_cbs);
 	} else {
-		return read_stream_list(&ctx->stream_list,
-					offsetof(struct wim_lookup_table_entry,
-						 extraction_list),
-					&wrapper_cbs, VERIFY_STREAM_HASHES);
+		return read_blob_list(&ctx->blob_list,
+				      offsetof(struct blob_descriptor,
+					       extraction_list),
+				      &wrapper_cbs, VERIFY_BLOB_HASHES);
 	}
 }
 
@@ -567,38 +471,39 @@ extract_stream_list(struct apply_ctx *ctx,
  * unnamed data stream only.  */
 static int
 extract_dentry_to_stdout(struct wim_dentry *dentry,
-			 const struct wim_lookup_table *lookup_table)
+			 const struct blob_table *blob_table)
 {
 	struct wim_inode *inode = dentry->d_inode;
-	struct wim_lookup_table_entry *lte;
+	struct blob_descriptor *blob;
 	struct filedes _stdout;
 
 	if (inode->i_attributes & (FILE_ATTRIBUTE_REPARSE_POINT |
-				   FILE_ATTRIBUTE_DIRECTORY))
+				   FILE_ATTRIBUTE_DIRECTORY |
+				   FILE_ATTRIBUTE_ENCRYPTED))
 	{
 		ERROR("\"%"TS"\" is not a regular file and therefore cannot be "
 		      "extracted to standard output", dentry_full_path(dentry));
 		return WIMLIB_ERR_NOT_A_REGULAR_FILE;
 	}
 
-	lte = inode_unnamed_lte(inode, lookup_table);
-	if (!lte) {
-		const u8 *hash = inode_unnamed_stream_hash(inode);
+	blob = inode_get_blob_for_unnamed_data_stream(inode, blob_table);
+	if (!blob) {
+		const u8 *hash = inode_get_hash_of_unnamed_data_stream(inode);
 		if (!is_zero_hash(hash))
-			return stream_not_found_error(inode, hash);
+			return blob_not_found_error(inode, hash);
 		return 0;
 	}
 
 	filedes_init(&_stdout, STDOUT_FILENO);
-	return extract_full_stream_to_fd(lte, &_stdout);
+	return extract_blob_to_fd(blob, &_stdout);
 }
 
 static int
 extract_dentries_to_stdout(struct wim_dentry **dentries, size_t num_dentries,
-			   const struct wim_lookup_table *lookup_table)
+			   const struct blob_table *blob_table)
 {
 	for (size_t i = 0; i < num_dentries; i++) {
-		int ret = extract_dentry_to_stdout(dentries[i], lookup_table);
+		int ret = extract_dentry_to_stdout(dentries[i], blob_table);
 		if (ret)
 			return ret;
 	}
@@ -746,13 +651,13 @@ destroy_dentry_list(struct list_head *dentry_list)
 }
 
 static void
-destroy_stream_list(struct list_head *stream_list)
+destroy_blob_list(struct list_head *blob_list)
 {
-	struct wim_lookup_table_entry *lte;
+	struct blob_descriptor *blob;
 
-	list_for_each_entry(lte, stream_list, extraction_list)
-		if (lte->out_refcnt > ARRAY_LEN(lte->inline_stream_owners))
-			FREE(lte->stream_owners);
+	list_for_each_entry(blob, blob_list, extraction_list)
+		if (blob->out_refcnt > ARRAY_LEN(blob->inline_blob_extraction_targets))
+			FREE(blob->blob_extraction_targets);
 }
 
 #ifdef __WIN32__
@@ -808,9 +713,6 @@ dentry_calculate_extraction_name(struct wim_dentry *dentry,
 {
 	int ret;
 
-	if (!dentry_is_supported(dentry, &ctx->supported_features))
-		goto skip_dentry;
-
 	if (dentry_is_root(dentry))
 		return 0;
 
@@ -901,8 +803,7 @@ out_replace:
 
 		utf16le_put_tstr(tchar_name);
 
-		dentry->d_extraction_name = memdup(fixed_name,
-						   2 * fixed_name_num_chars + 2);
+		dentry->d_extraction_name = TSTRDUP(fixed_name);
 		if (!dentry->d_extraction_name)
 			return WIMLIB_ERR_NOMEM;
 		dentry->d_extraction_name_nchars = fixed_name_num_chars;
@@ -959,34 +860,35 @@ dentry_list_calculate_extraction_names(struct list_head *dentry_list,
 
 static int
 dentry_resolve_streams(struct wim_dentry *dentry, int extract_flags,
-		       struct wim_lookup_table *lookup_table)
+		       struct blob_table *blob_table)
 {
 	struct wim_inode *inode = dentry->d_inode;
-	struct wim_lookup_table_entry *lte;
+	struct blob_descriptor *blob;
 	int ret;
 	bool force = false;
 
-	/* Special case:  when extracting from a pipe, the WIM lookup table is
+	/* Special case:  when extracting from a pipe, the WIM blob table is
 	 * initially empty, so "resolving" an inode's streams is initially not
-	 * possible.  However, we still need to keep track of which streams,
-	 * identified by SHA1 message digests, need to be extracted, so we
-	 * "resolve" the inode's streams anyway by allocating new entries.  */
+	 * possible.  However, we still need to keep track of which blobs,
+	 * identified by SHA-1 message digests, need to be extracted, so we
+	 * "resolve" the inode's streams anyway by allocating a 'struct
+	 * blob_descriptor' for each one.  */
 	if (extract_flags & WIMLIB_EXTRACT_FLAG_FROM_PIPE)
 		force = true;
-	ret = inode_resolve_streams(inode, lookup_table, force);
+	ret = inode_resolve_streams(inode, blob_table, force);
 	if (ret)
 		return ret;
-	for (u32 i = 0; i <= inode->i_num_ads; i++) {
-		lte = inode_stream_lte_resolved(inode, i);
-		if (lte)
-			lte->out_refcnt = 0;
+	for (unsigned i = 0; i < inode->i_num_streams; i++) {
+		blob = stream_blob_resolved(&inode->i_streams[i]);
+		if (blob)
+			blob->out_refcnt = 0;
 	}
 	return 0;
 }
 
 /*
  * For each dentry to be extracted, resolve all streams in the corresponding
- * inode and set 'out_refcnt' in each to 0.
+ * inode and set 'out_refcnt' in all referenced blob_descriptors to 0.
  *
  * Possible error codes: WIMLIB_ERR_RESOURCE_NOT_FOUND, WIMLIB_ERR_NOMEM.
  */
@@ -1000,7 +902,7 @@ dentry_list_resolve_streams(struct list_head *dentry_list,
 	list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
 		ret = dentry_resolve_streams(dentry,
 					     ctx->extract_flags,
-					     ctx->wim->lookup_table);
+					     ctx->wim->blob_table);
 		if (ret)
 			return ret;
 	}
@@ -1008,145 +910,155 @@ dentry_list_resolve_streams(struct list_head *dentry_list,
 }
 
 static int
-ref_stream(struct wim_lookup_table_entry *lte, u32 stream_idx,
-	   struct wim_dentry *dentry, struct apply_ctx *ctx)
+ref_stream(struct wim_inode_stream *strm, struct wim_dentry *dentry,
+	   struct apply_ctx *ctx)
 {
 	struct wim_inode *inode = dentry->d_inode;
-	struct stream_owner *stream_owners;
+	struct blob_descriptor *blob = stream_blob_resolved(strm);
+	struct blob_extraction_target *targets;
 
-	if (!lte)
+	if (!blob)
 		return 0;
 
-	/* Tally the size only for each extraction of the stream (not hard
-	 * links).  */
+	/* Tally the size only for each actual extraction of the stream (not
+	 * additional hard links to the inode).  */
 	if (inode->i_visited && ctx->supported_features.hard_links)
 		return 0;
 
-	ctx->progress.extract.total_bytes += lte->size;
+	ctx->progress.extract.total_bytes += blob->size;
 	ctx->progress.extract.total_streams++;
 
 	if (inode->i_visited)
 		return 0;
 
-	/* Add stream to the dentry_list only one time, even if it's going
-	 * to be extracted to multiple inodes.  */
-	if (lte->out_refcnt == 0) {
-		list_add_tail(&lte->extraction_list, &ctx->stream_list);
-		ctx->num_streams_remaining++;
+	/* Add each blob to 'ctx->blob_list' only one time, regardless of how
+	 * many extraction targets it will have.  */
+	if (blob->out_refcnt == 0) {
+		list_add_tail(&blob->extraction_list, &ctx->blob_list);
+		ctx->num_blobs_remaining++;
 	}
 
-	/* If inode not yet been visited, append it to the stream_owners array.  */
-	if (lte->out_refcnt < ARRAY_LEN(lte->inline_stream_owners)) {
-		stream_owners = lte->inline_stream_owners;
+	/* Set this stream as an extraction target of 'blob'.  */
+
+	if (blob->out_refcnt < ARRAY_LEN(blob->inline_blob_extraction_targets)) {
+		targets = blob->inline_blob_extraction_targets;
 	} else {
-		struct stream_owner *prev_stream_owners;
-		size_t alloc_stream_owners;
+		struct blob_extraction_target *prev_targets;
+		size_t alloc_blob_extraction_targets;
 
-		if (lte->out_refcnt == ARRAY_LEN(lte->inline_stream_owners)) {
-			prev_stream_owners = NULL;
-			alloc_stream_owners = ARRAY_LEN(lte->inline_stream_owners);
+		if (blob->out_refcnt == ARRAY_LEN(blob->inline_blob_extraction_targets)) {
+			prev_targets = NULL;
+			alloc_blob_extraction_targets = ARRAY_LEN(blob->inline_blob_extraction_targets);
 		} else {
-			prev_stream_owners = lte->stream_owners;
-			alloc_stream_owners = lte->alloc_stream_owners;
+			prev_targets = blob->blob_extraction_targets;
+			alloc_blob_extraction_targets = blob->alloc_blob_extraction_targets;
 		}
 
-		if (lte->out_refcnt == alloc_stream_owners) {
-			alloc_stream_owners *= 2;
-			stream_owners = REALLOC(prev_stream_owners,
-					       alloc_stream_owners *
-						sizeof(stream_owners[0]));
-			if (!stream_owners)
+		if (blob->out_refcnt == alloc_blob_extraction_targets) {
+			alloc_blob_extraction_targets *= 2;
+			targets = REALLOC(prev_targets,
+					  alloc_blob_extraction_targets *
+					  sizeof(targets[0]));
+			if (!targets)
 				return WIMLIB_ERR_NOMEM;
-			if (!prev_stream_owners) {
-				memcpy(stream_owners,
-				       lte->inline_stream_owners,
-				       sizeof(lte->inline_stream_owners));
+			if (!prev_targets) {
+				memcpy(targets,
+				       blob->inline_blob_extraction_targets,
+				       sizeof(blob->inline_blob_extraction_targets));
 			}
-			lte->stream_owners = stream_owners;
-			lte->alloc_stream_owners = alloc_stream_owners;
+			blob->blob_extraction_targets = targets;
+			blob->alloc_blob_extraction_targets = alloc_blob_extraction_targets;
 		}
-		stream_owners = lte->stream_owners;
-	}
-	stream_owners[lte->out_refcnt].inode = inode;
-	if (stream_idx == 0) {
-		stream_owners[lte->out_refcnt].stream_name = NULL;
-	} else {
-		stream_owners[lte->out_refcnt].stream_name =
-			inode->i_ads_entries[stream_idx - 1].stream_name;
+		targets = blob->blob_extraction_targets;
 	}
-	lte->out_refcnt++;
+	targets[blob->out_refcnt].inode = inode;
+	targets[blob->out_refcnt].stream = strm;
+	blob->out_refcnt++;
 	return 0;
 }
 
 static int
-ref_unnamed_stream(struct wim_dentry *dentry, struct apply_ctx *ctx)
+ref_stream_if_needed(struct wim_dentry *dentry, struct wim_inode *inode,
+		     struct wim_inode_stream *strm, struct apply_ctx *ctx)
 {
-	struct wim_inode *inode = dentry->d_inode;
-	int ret;
-	u16 stream_idx;
-	struct wim_lookup_table_entry *stream;
-
-	if (unlikely(inode_is_encrypted_directory(inode)))
-		return 0;
-
-	if (unlikely(ctx->apply_ops->will_externally_back)) {
-		ret = (*ctx->apply_ops->will_externally_back)(dentry, ctx);
-		if (ret >= 0) {
-			if (ret) /* Error */
-				return ret;
-			/* Will externally back */
-			return 0;
+	bool need_stream = false;
+	switch (strm->stream_type) {
+	case STREAM_TYPE_DATA:
+		if (stream_is_named(strm)) {
+			/* Named data stream  */
+			if (ctx->supported_features.named_data_streams)
+				need_stream = true;
+		} else if (!(inode->i_attributes & (FILE_ATTRIBUTE_DIRECTORY |
+						    FILE_ATTRIBUTE_ENCRYPTED))
+			   && !(inode_is_symlink(inode)
+				&& !ctx->supported_features.reparse_points
+				&& ctx->supported_features.symlink_reparse_points))
+		{
+			/*
+			 * Unnamed data stream.  Skip if any of the following is true:
+			 *
+			 * - file is a directory
+			 * - file is encrypted
+			 * - backend needs to create the file as UNIX symlink
+			 * - backend will extract the stream as externally backed
+			 */
+			if (ctx->apply_ops->will_externally_back) {
+				int ret = (*ctx->apply_ops->will_externally_back)(dentry, ctx);
+				if (ret > 0) /* Error?  */
+					return ret;
+				if (ret < 0) /* Won't externally back?  */
+					need_stream = true;
+			} else {
+				need_stream = true;
+			}
+		}
+		break;
+	case STREAM_TYPE_REPARSE_POINT:
+		wimlib_assert(inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT);
+		if (ctx->supported_features.reparse_points ||
+		    (inode_is_symlink(inode) &&
+		     ctx->supported_features.symlink_reparse_points))
+			need_stream = true;
+		break;
+	case STREAM_TYPE_EFSRPC_RAW_DATA:
+		wimlib_assert(inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED);
+		if (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY) {
+			if (ctx->supported_features.encrypted_directories)
+				need_stream = true;
+		} else {
+			if (ctx->supported_features.encrypted_files)
+				need_stream = true;
 		}
-		/* Won't externally back */
+		break;
 	}
-
-	stream = inode_unnamed_stream_resolved(inode, &stream_idx);
-	return ref_stream(stream, stream_idx, dentry, ctx);
+	if (need_stream)
+		return ref_stream(strm, dentry, ctx);
+	return 0;
 }
 
 static int
 dentry_ref_streams(struct wim_dentry *dentry, struct apply_ctx *ctx)
 {
 	struct wim_inode *inode = dentry->d_inode;
-	int ret;
-
-	/* The unnamed data stream will almost always be extracted, but there
-	 * exist cases in which it won't be.  */
-	ret = ref_unnamed_stream(dentry, ctx);
-	if (ret)
-		return ret;
-
-	/* Named data streams will be extracted only if supported in the current
-	 * extraction mode and volume, and to avoid complications, if not doing
-	 * a linked extraction.  */
-	if (ctx->supported_features.named_data_streams) {
-		for (u16 i = 0; i < inode->i_num_ads; i++) {
-			if (!ads_entry_is_named_stream(&inode->i_ads_entries[i]))
-				continue;
-			ret = ref_stream(inode->i_ads_entries[i].lte, i + 1,
-					 dentry, ctx);
-			if (ret)
-				return ret;
-		}
+	for (unsigned i = 0; i < inode->i_num_streams; i++) {
+		int ret = ref_stream_if_needed(dentry, inode,
+					       &inode->i_streams[i], ctx);
+		if (ret)
+			return ret;
 	}
 	inode->i_visited = 1;
 	return 0;
 }
 
 /*
- * For each dentry to be extracted, iterate through the data streams of the
- * corresponding inode.  For each such stream that is not to be ignored due to
- * the supported features or extraction flags, add it to the list of streams to
- * be extracted (ctx->stream_list) if not already done so.
- *
- * Also builds a mapping from each stream to the inodes referencing it.
+ * Given a list of dentries to be extracted, build the list of blobs that need
+ * to be extracted, and for each blob determine the streams to which that blob
+ * will be extracted.
  *
- * This also initializes the extract progress info with byte and stream
+ * This also initializes the extract progress info with byte and blob
  * information.
  *
  * ctx->supported_features must be filled in.
- *
- * Possible error codes: WIMLIB_ERR_NOMEM.
  */
 static int
 dentry_list_ref_streams(struct list_head *dentry_list, struct apply_ctx *ctx)
@@ -1168,18 +1080,14 @@ static void
 dentry_list_build_inode_alias_lists(struct list_head *dentry_list)
 {
 	struct wim_dentry *dentry;
-	struct wim_inode *inode;
+
+	list_for_each_entry(dentry, dentry_list, d_extraction_list_node)
+		dentry->d_inode->i_first_extraction_alias = NULL;
 
 	list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
-		inode = dentry->d_inode;
-		if (!inode->i_visited)
-			INIT_LIST_HEAD(&inode->i_extraction_aliases);
-		list_add_tail(&dentry->d_extraction_alias_node,
-			      &inode->i_extraction_aliases);
-		inode->i_visited = 1;
+		dentry->d_next_extraction_alias = dentry->d_inode->i_first_extraction_alias;
+		dentry->d_inode->i_first_extraction_alias = dentry;
 	}
-	list_for_each_entry(dentry, dentry_list, d_extraction_list_node)
-		dentry->d_inode->i_visited = 0;
 }
 
 static void
@@ -1204,7 +1112,7 @@ inode_tally_features(const struct wim_inode *inode,
 		features->not_context_indexed_files++;
 	if (inode->i_attributes & FILE_ATTRIBUTE_SPARSE_FILE)
 		features->sparse_files++;
-	if (inode_has_named_stream(inode))
+	if (inode_has_named_data_stream(inode))
 		features->named_data_streams++;
 	if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
 		features->reparse_points++;
@@ -1213,7 +1121,7 @@ inode_tally_features(const struct wim_inode *inode,
 		else
 			features->other_reparse_points++;
 	}
-	if (inode->i_security_id != -1)
+	if (inode_has_security_descriptor(inode))
 		features->security_descriptors++;
 	if (inode_has_unix_data(inode))
 		features->unix_data++;
@@ -1255,6 +1163,18 @@ do_feature_check(const struct wim_features *required_features,
 		 const struct wim_features *supported_features,
 		 int extract_flags)
 {
+	/* Encrypted files.  */
+	if (required_features->encrypted_files &&
+	    !supported_features->encrypted_files)
+		WARNING("Ignoring EFS-encrypted data of %lu files",
+			required_features->encrypted_files);
+
+	/* Named data streams.  */
+	if (required_features->named_data_streams &&
+	    !supported_features->named_data_streams)
+		WARNING("Ignoring named data streams of %lu files",
+			required_features->named_data_streams);
+
 	/* File attributes.  */
 	if (!(extract_flags & WIMLIB_EXTRACT_FLAG_NO_ATTRIBUTES)) {
 		/* Note: Don't bother the user about FILE_ATTRIBUTE_ARCHIVE.
@@ -1292,18 +1212,6 @@ do_feature_check(const struct wim_features *required_features,
 				required_features->encrypted_directories);
 	}
 
-	/* Encrypted files.  */
-	if (required_features->encrypted_files &&
-	    !supported_features->encrypted_files)
-		WARNING("Ignoring %lu encrypted files",
-			required_features->encrypted_files);
-
-	/* Named data streams.  */
-	if (required_features->named_data_streams &&
-	    (!supported_features->named_data_streams))
-		WARNING("Ignoring named data streams of %lu files",
-			required_features->named_data_streams);
-
 	/* Hard links.  */
 	if (required_features->hard_links && !supported_features->hard_links)
 		WARNING("Extracting %lu hard links as independent files",
@@ -1323,12 +1231,11 @@ do_feature_check(const struct wim_features *required_features,
 	{
 		if (supported_features->symlink_reparse_points) {
 			if (required_features->other_reparse_points) {
-				WARNING("Ignoring %lu non-symlink/junction "
-					"reparse point files",
+				WARNING("Ignoring reparse data of %lu non-symlink/junction files",
 					required_features->other_reparse_points);
 			}
 		} else {
-			WARNING("Ignoring %lu reparse point files",
+			WARNING("Ignoring reparse data of %lu files",
 				required_features->reparse_points);
 		}
 	}
@@ -1412,7 +1319,7 @@ extract_trees(WIMStruct *wim, struct wim_dentry **trees, size_t num_trees,
 
 	if (extract_flags & WIMLIB_EXTRACT_FLAG_TO_STDOUT) {
 		ret = extract_dentries_to_stdout(trees, num_trees,
-						 wim->lookup_table);
+						 wim->blob_table);
 		goto out;
 	}
 
@@ -1450,7 +1357,7 @@ extract_trees(WIMStruct *wim, struct wim_dentry **trees, size_t num_trees,
 									 wim->current_image);
 		ctx->progress.extract.target = target;
 	}
-	INIT_LIST_HEAD(&ctx->stream_list);
+	INIT_LIST_HEAD(&ctx->blob_list);
 	filedes_invalidate(&ctx->tmpfile_fd);
 	ctx->apply_ops = ops;
 
@@ -1473,6 +1380,11 @@ extract_trees(WIMStruct *wim, struct wim_dentry **trees, size_t num_trees,
 	if (ret)
 		goto out_cleanup;
 
+	if (unlikely(list_empty(&dentry_list))) {
+		WARNING("There is nothing to extract!");
+		goto out_cleanup;
+	}
+
 	ret = dentry_list_resolve_streams(&dentry_list, ctx);
 	if (ret)
 		goto out_cleanup;
@@ -1486,8 +1398,8 @@ extract_trees(WIMStruct *wim, struct wim_dentry **trees, size_t num_trees,
 	if (extract_flags & WIMLIB_EXTRACT_FLAG_FROM_PIPE) {
 		/* When extracting from a pipe, the number of bytes of data to
 		 * extract can't be determined in the normal way (examining the
-		 * lookup table), since at this point all we have is a set of
-		 * SHA1 message digests of streams that need to be extracted.
+		 * blob table), since at this point all we have is a set of
+		 * SHA-1 message digests of blobs that need to be extracted.
 		 * However, we can get a reasonably accurate estimate by taking
 		 * <TOTALBYTES> from the corresponding <IMAGE> in the WIM XML
 		 * data.  This does assume that a full image is being extracted,
@@ -1530,7 +1442,7 @@ extract_trees(WIMStruct *wim, struct wim_dentry **trees, size_t num_trees,
 				       WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_END :
 				       WIMLIB_PROGRESS_MSG_EXTRACT_TREE_END));
 out_cleanup:
-	destroy_stream_list(&ctx->stream_list);
+	destroy_blob_list(&ctx->blob_list);
 	destroy_dentry_list(&dentry_list);
 	FREE(ctx);
 out:
@@ -1675,7 +1587,7 @@ do_wimlib_extract_paths(WIMStruct *wim, int image, const tchar *target,
 	if (ret)
 		return ret;
 
-	ret = wim_checksum_unhashed_streams(wim);
+	ret = wim_checksum_unhashed_blobs(wim);
 	if (ret)
 		return ret;
 
@@ -1897,8 +1809,8 @@ wimlib_extract_image_from_pipe_with_progress(int pipe_fd,
 
 	/* Read the WIM header from the pipe and get a WIMStruct to represent
 	 * the pipable WIM.  Caveats:  Unlike getting a WIMStruct with
-	 * wimlib_open_wim(), getting a WIMStruct in this way will result in
-	 * an empty lookup table, no XML data read, and no filename set.  */
+	 * wimlib_open_wim(), getting a WIMStruct in this way will result in an
+	 * empty blob table, no XML data read, and no filename set.  */
 	ret = open_wim_as_WIMStruct(&pipe_fd, WIMLIB_OPEN_FLAG_FROM_PIPE, &pwm,
 				    progfunc, progctx);
 	if (ret)
@@ -1930,22 +1842,19 @@ wimlib_extract_image_from_pipe_with_progress(int pipe_fd,
 	 * write_pipable_wim() for more details about the format of pipable
 	 * WIMs.)  */
 	{
-		struct wim_lookup_table_entry xml_lte;
-		struct wim_resource_spec xml_rspec;
-		ret = read_pwm_stream_header(pwm, &xml_lte, &xml_rspec, 0, NULL);
+		u8 hash[SHA1_HASH_SIZE];
+
+		ret = read_pwm_blob_header(pwm, hash,
+					   &pwm->hdr.xml_data_reshdr, NULL);
 		if (ret)
 			goto out_wimlib_free;
 
-		if (!(xml_lte.flags & WIM_RESHDR_FLAG_METADATA))
-		{
-			ERROR("Expected XML data, but found non-metadata "
-			      "stream.");
+		if (!(pwm->hdr.xml_data_reshdr.flags & WIM_RESHDR_FLAG_METADATA)) {
+			ERROR("Expected XML data, but found non-metadata resource.");
 			ret = WIMLIB_ERR_INVALID_PIPABLE_WIM;
 			goto out_wimlib_free;
 		}
 
-		wim_res_spec_to_hdr(&xml_rspec, &pwm->hdr.xml_data_reshdr);
-
 		ret = read_wim_xml_data(pwm);
 		if (ret)
 			goto out_wimlib_free;
@@ -1983,48 +1892,49 @@ wimlib_extract_image_from_pipe_with_progress(int pipe_fd,
 
 	/* Load the needed metadata resource.  */
 	for (i = 1; i <= pwm->hdr.image_count; i++) {
-		struct wim_lookup_table_entry *metadata_lte;
 		struct wim_image_metadata *imd;
-		struct wim_resource_spec *metadata_rspec;
+		struct wim_reshdr reshdr;
+		struct wim_resource_descriptor *metadata_rdesc;
 
-		metadata_lte = new_lookup_table_entry();
-		if (metadata_lte == NULL) {
-			ret = WIMLIB_ERR_NOMEM;
-			goto out_wimlib_free;
-		}
-		metadata_rspec = MALLOC(sizeof(struct wim_resource_spec));
-		if (metadata_rspec == NULL) {
-			ret = WIMLIB_ERR_NOMEM;
-			free_lookup_table_entry(metadata_lte);
+		imd = pwm->image_metadata[i - 1];
+
+		ret = WIMLIB_ERR_NOMEM;
+		imd->metadata_blob = new_blob_descriptor();
+		if (!imd->metadata_blob)
 			goto out_wimlib_free;
-		}
 
-		ret = read_pwm_stream_header(pwm, metadata_lte, metadata_rspec, 0, NULL);
-		imd = pwm->image_metadata[i - 1];
-		imd->metadata_lte = metadata_lte;
-		if (ret) {
-			FREE(metadata_rspec);
+		imd->metadata_blob->is_metadata = 1;
+
+		ret = read_pwm_blob_header(pwm, imd->metadata_blob->hash,
+					   &reshdr, NULL);
+		if (ret)
 			goto out_wimlib_free;
-		}
 
-		if (!(metadata_lte->flags & WIM_RESHDR_FLAG_METADATA)) {
+		if (!(reshdr.flags & WIM_RESHDR_FLAG_METADATA)) {
 			ERROR("Expected metadata resource, but found "
-			      "non-metadata stream.");
+			      "non-metadata resource");
 			ret = WIMLIB_ERR_INVALID_PIPABLE_WIM;
 			goto out_wimlib_free;
 		}
 
+		ret = WIMLIB_ERR_NOMEM;
+		metadata_rdesc = MALLOC(sizeof(struct wim_resource_descriptor));
+		if (!metadata_rdesc)
+			goto out_wimlib_free;
+		wim_reshdr_to_desc_and_blob(&reshdr, pwm, metadata_rdesc,
+					    imd->metadata_blob);
+
 		if (i == image) {
 			/* Metadata resource is for the image being extracted.
 			 * Parse it and save the metadata in memory.  */
-			ret = read_metadata_resource(pwm, imd);
+			ret = read_metadata_resource(imd);
 			if (ret)
 				goto out_wimlib_free;
 			imd->modified = 1;
 		} else {
 			/* Metadata resource is not for the image being
 			 * extracted.  Skip over it.  */
-			ret = skip_wim_stream(metadata_lte);
+			ret = skip_wim_resource(metadata_rdesc);
 			if (ret)
 				goto out_wimlib_free;
 		}