X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Flookup_table.c;h=553cf33b1c413f4dbfa430291b8439b85abec869;hp=7441932c169a06912fd31ec41a05c7628ef6f043;hb=db52422f8a9e87e7d160b68b3271d26c41f0687e;hpb=0a859cd076a942d7145e203c596892ca66f7e4a2

diff --git a/src/lookup_table.c b/src/lookup_table.c
index 7441932c..553cf33b 100644
--- a/src/lookup_table.c
+++ b/src/lookup_table.c
@@ -31,6 +31,7 @@
 #include "wimlib/endianness.h"
 #include "wimlib/error.h"
 #include "wimlib/file_io.h"
+#include "wimlib/glob.h"
 #include "wimlib/lookup_table.h"
 #include "wimlib/metadata.h"
 #include "wimlib/paths.h"
@@ -484,7 +485,7 @@ read_wim_lookup_table(WIMStruct *wim)
 	size_t num_entries;
 	struct wim_lookup_table *table;
 	struct wim_lookup_table_entry *cur_entry, *duplicate_entry;
-	struct wim_lookup_table_entry_disk *buf;
+	void *buf;
 
 	BUILD_BUG_ON(sizeof(struct wim_lookup_table_entry_disk) !=
 		     WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE);
@@ -499,8 +500,7 @@ read_wim_lookup_table(WIMStruct *wim)
 
 
 	/* Read the lookup table into a buffer.  */
-	ret = res_entry_to_data(&wim->hdr.lookup_table_res_entry, wim,
-				(void**)&buf);
+	ret = res_entry_to_data(&wim->hdr.lookup_table_res_entry, wim, &buf);
 	if (ret)
 		goto out;
 
@@ -516,7 +516,8 @@ read_wim_lookup_table(WIMStruct *wim)
 	 * on-disk lookup table.  */
 	wim->current_image = 0;
 	for (i = 0; i < num_entries; i++) {
-		const struct wim_lookup_table_entry_disk *disk_entry = &buf[i];
+		const struct wim_lookup_table_entry_disk *disk_entry =
+			&((const struct wim_lookup_table_entry_disk*)buf)[i];
 
 		cur_entry = new_lookup_table_entry();
 		if (!cur_entry) {
@@ -573,6 +574,13 @@ read_wim_lookup_table(WIMStruct *wim)
 		if (cur_entry->resource_entry.flags & WIM_RESHDR_FLAG_METADATA) {
 			/* Lookup table entry for a metadata resource */
 			if (cur_entry->refcnt != 1) {
+				/* Metadata entries with no references must be
+				 * ignored.  See for example the WinPE WIMs from
+				 * WAIK v2.1.  */
+				if (cur_entry->refcnt == 0) {
+					free_lookup_table_entry(cur_entry);
+					continue;
+				}
 				if (wimlib_print_errors) {
 					ERROR("Found metadata resource with refcnt != 1:");
 					print_lookup_table_entry(cur_entry, stderr);
@@ -612,7 +620,7 @@ read_wim_lookup_table(WIMStruct *wim)
 		} else {
 			/* Lookup table entry for a stream that is not a
 			 * metadata resource */
-			duplicate_entry = __lookup_resource(table, cur_entry->hash);
+			duplicate_entry = lookup_resource(table, cur_entry->hash);
 			if (duplicate_entry) {
 				if (wimlib_print_errors) {
 					WARNING("The WIM lookup table contains two entries with the "
@@ -670,7 +678,8 @@ static int
 write_wim_lookup_table_from_stream_list(struct list_head *stream_list,
 					struct filedes *out_fd,
 					struct resource_entry *out_res_entry,
-					int write_resource_flags)
+					int write_resource_flags,
+					struct wimlib_lzx_context **comp_ctx)
 {
 	size_t table_size;
 	struct wim_lookup_table_entry *lte;
@@ -704,16 +713,39 @@ write_wim_lookup_table_from_stream_list(struct list_head *stream_list,
 					     WIMLIB_COMPRESSION_TYPE_NONE,
 					     out_res_entry,
 					     NULL,
-					     write_resource_flags);
+					     write_resource_flags,
+					     comp_ctx);
 	FREE(table_buf);
+	DEBUG("ret=%d", ret);
 	return ret;
 }
 
 static int
 append_lookup_table_entry(struct wim_lookup_table_entry *lte, void *_list)
 {
-	if (lte->out_refcnt != 0)
+	/* Lookup table entries with 'out_refcnt' == 0 correspond to streams not
+	 * written and not present in the resulting WIM file, and should not be
+	 * included in the lookup table.
+	 *
+	 * Lookup table entries marked as filtered (EXTERNAL_WIM) with
+	 * 'out_refcnt != 0' were referenced as part of the logical write but
+	 * correspond to streams that were not in fact written, and should not
+	 * be included in the lookup table.
+	 *
+	 * Lookup table entries marked as filtered (SAME_WIM) with 'out_refcnt
+	 * != 0' were referenced as part of the logical write but correspond to
+	 * streams that were not in fact written, but nevertheless were already
+	 * present in the WIM being overwritten in-place.  These entries must be
+	 * included in the lookup table, and the resource information to write
+	 * needs to be copied from the resource information read originally.
+	 */
+	if (lte->out_refcnt != 0 && !(lte->filtered & FILTERED_EXTERNAL_WIM)) {
+		if (lte->filtered & FILTERED_SAME_WIM) {
+			copy_resource_entry(&lte->output_resource_entry,
+					    &lte->resource_entry);
+		}
 		list_add_tail(&lte->lookup_table_list, (struct list_head*)_list);
+	}
 	return 0;
 }
 
@@ -760,7 +792,9 @@ write_wim_lookup_table(WIMStruct *wim, int image, int write_flags,
 		}
 	}
 
-	/* Append additional lookup table entries that have out_refcnt != 0.  */
+	/* Append additional lookup table entries that need to be written, with
+	 * some special handling for streams that have been marked as filtered.
+	 */
 	if (!stream_list_override) {
 		for_lookup_table_entry(wim->lookup_table,
 				       append_lookup_table_entry, stream_list);
@@ -772,7 +806,8 @@ write_wim_lookup_table(WIMStruct *wim, int image, int write_flags,
 	return write_wim_lookup_table_from_stream_list(stream_list,
 						       &wim->out_fd,
 						       out_res_entry,
-						       write_resource_flags);
+						       write_resource_flags,
+						       &wim->lzx_context);
 }
 
 
@@ -921,7 +956,7 @@ wimlib_iterate_lookup_table(WIMStruct *wim, int flags,
 /* Given a SHA1 message digest, return the corresponding entry in the WIM's
  * lookup table, or NULL if there is none.  */
 struct wim_lookup_table_entry *
-__lookup_resource(const struct wim_lookup_table *table, const u8 hash[])
+lookup_resource(const struct wim_lookup_table *table, const u8 hash[])
 {
 	size_t i;
 	struct wim_lookup_table_entry *lte;
@@ -945,12 +980,12 @@ __lookup_resource(const struct wim_lookup_table *table, const u8 hash[])
  * This is only for pre-resolved inodes.
  */
 int
-lookup_resource(WIMStruct *wim,
-		const tchar *path,
-		int lookup_flags,
-		struct wim_dentry **dentry_ret,
-		struct wim_lookup_table_entry **lte_ret,
-		u16 *stream_idx_ret)
+wim_pathname_to_stream(WIMStruct *wim,
+		       const tchar *path,
+		       int lookup_flags,
+		       struct wim_dentry **dentry_ret,
+		       struct wim_lookup_table_entry **lte_ret,
+		       u16 *stream_idx_ret)
 {
 	struct wim_dentry *dentry;
 	struct wim_lookup_table_entry *lte;
@@ -996,8 +1031,7 @@ lookup_resource(WIMStruct *wim,
 			return -ENOENT;
 		}
 	} else {
-		lte = inode->i_lte;
-		stream_idx = 0;
+		lte = inode_unnamed_stream_resolved(inode, &stream_idx);
 	}
 out:
 	if (dentry_ret)
@@ -1010,6 +1044,18 @@ out:
 }
 #endif
 
+int
+resource_not_found_error(const struct wim_inode *inode, const u8 *hash)
+{
+	if (wimlib_print_errors) {
+		ERROR("\"%"TS"\": resource not found", inode_first_full_path(inode));
+		tfprintf(stderr, T("        SHA-1 message digest of missing resource:\n        "));
+		print_hash(hash, stderr);
+		tputc(T('\n'), stderr);
+	}
+	return WIMLIB_ERR_RESOURCE_NOT_FOUND;
+}
+
 /*
  * Resolve an inode's lookup table entries.
  *
@@ -1037,7 +1083,7 @@ inode_resolve_ltes(struct wim_inode *inode, struct wim_lookup_table *table,
 		lte = NULL;
 		hash = inode->i_hash;
 		if (!is_zero_hash(hash)) {
-			lte = __lookup_resource(table, hash);
+			lte = lookup_resource(table, hash);
 			if (!lte) {
 				if (force) {
 					lte = new_lookup_table_entry();
@@ -1060,7 +1106,7 @@ inode_resolve_ltes(struct wim_inode *inode, struct wim_lookup_table *table,
 			cur_entry = &inode->i_ads_entries[i];
 			hash = cur_entry->hash;
 			if (!is_zero_hash(hash)) {
-				ads_lte = __lookup_resource(table, hash);
+				ads_lte = lookup_resource(table, hash);
 				if (!ads_lte) {
 					if (force) {
 						ads_lte = new_lookup_table_entry();
@@ -1081,14 +1127,9 @@ inode_resolve_ltes(struct wim_inode *inode, struct wim_lookup_table *table,
 		inode->i_resolved = 1;
 	}
 	return 0;
+
 resource_not_found:
-	if (wimlib_print_errors) {
-		ERROR("\"%"TS"\": resource not found", inode_first_full_path(inode));
-		tfprintf(stderr, T("        SHA-1 message digest of missing resource:\n        "));
-		print_hash(hash, stderr);
-		tputc(T('\n'), stderr);
-	}
-	return WIMLIB_ERR_RESOURCE_NOT_FOUND;
+	return resource_not_found_error(inode, hash);
 }
 
 void
@@ -1129,19 +1170,28 @@ inode_stream_lte(const struct wim_inode *inode, unsigned stream_idx,
 }
 
 struct wim_lookup_table_entry *
-inode_unnamed_lte_resolved(const struct wim_inode *inode)
+inode_unnamed_stream_resolved(const struct wim_inode *inode, u16 *stream_idx_ret)
 {
 	wimlib_assert(inode->i_resolved);
 	for (unsigned i = 0; i <= inode->i_num_ads; i++) {
 		if (inode_stream_name_nbytes(inode, i) == 0 &&
 		    !is_zero_hash(inode_stream_hash_resolved(inode, i)))
 		{
+			*stream_idx_ret = i;
 			return inode_stream_lte_resolved(inode, i);
 		}
 	}
+	*stream_idx_ret = 0;
 	return NULL;
 }
 
+struct wim_lookup_table_entry *
+inode_unnamed_lte_resolved(const struct wim_inode *inode)
+{
+	u16 stream_idx;
+	return inode_unnamed_stream_resolved(inode, &stream_idx);
+}
+
 struct wim_lookup_table_entry *
 inode_unnamed_lte_unresolved(const struct wim_inode *inode,
 			     const struct wim_lookup_table *table)
@@ -1183,6 +1233,25 @@ inode_unnamed_lte(const struct wim_inode *inode,
 		return inode_unnamed_lte_unresolved(inode, table);
 }
 
+/* Returns the SHA1 message digest of the unnamed data stream of a WIM inode, or
+ * 'zero_hash' if the unnamed data stream is missing has all zeroes in its SHA1
+ * message digest field.  */
+const u8 *
+inode_unnamed_stream_hash(const struct wim_inode *inode)
+{
+	const u8 *hash;
+
+	for (unsigned i = 0; i <= inode->i_num_ads; i++) {
+		if (inode_stream_name_nbytes(inode, i) == 0) {
+			hash = inode_stream_hash(inode, i);
+			if (!is_zero_hash(hash))
+				return hash;
+		}
+	}
+	return zero_hash;
+}
+
+
 static int
 lte_add_stream_size(struct wim_lookup_table_entry *lte, void *total_bytes_p)
 {
@@ -1248,7 +1317,7 @@ hash_unhashed_stream(struct wim_lookup_table_entry *lte,
 		return ret;
 
 	/* Look for a duplicate stream */
-	duplicate_lte = __lookup_resource(lookup_table, lte->hash);
+	duplicate_lte = lookup_resource(lookup_table, lte->hash);
 	list_del(&lte->unhashed_list);
 	if (duplicate_lte) {
 		/* We have a duplicate stream.  Transfer the reference counts
@@ -1257,7 +1326,7 @@ hash_unhashed_stream(struct wim_lookup_table_entry *lte,
 		 * duplicate, then free this stream. */
 		wimlib_assert(!(duplicate_lte->unhashed));
 		duplicate_lte->refcnt += lte->refcnt;
-		duplicate_lte->out_refcnt += lte->refcnt;
+		duplicate_lte->out_refcnt += lte->out_refcnt;
 		*back_ptr = duplicate_lte;
 		free_lookup_table_entry(lte);
 		lte = duplicate_lte;
@@ -1272,3 +1341,183 @@ hash_unhashed_stream(struct wim_lookup_table_entry *lte,
 		*lte_ret = lte;
 	return 0;
 }
+
+static int
+lte_clone_if_new(struct wim_lookup_table_entry *lte, void *_lookup_table)
+{
+	struct wim_lookup_table *lookup_table = _lookup_table;
+
+	if (lookup_resource(lookup_table, lte->hash))
+		return 0;  /*  Resource already present.  */
+
+	lte = clone_lookup_table_entry(lte);
+	if (!lte)
+		return WIMLIB_ERR_NOMEM;
+	lte->out_refcnt = 1;
+	lookup_table_insert(lookup_table, lte);
+	return 0;
+}
+
+static int
+lte_delete_if_new(struct wim_lookup_table_entry *lte, void *_lookup_table)
+{
+	struct wim_lookup_table *lookup_table = _lookup_table;
+
+	if (lte->out_refcnt) {
+		lookup_table_unlink(lookup_table, lte);
+		free_lookup_table_entry(lte);
+	}
+	return 0;
+}
+
+/* API function documented in wimlib.h  */
+WIMLIBAPI int
+wimlib_reference_resources(WIMStruct *wim,
+			   WIMStruct **resource_wims, unsigned num_resource_wims,
+			   int ref_flags)
+{
+	int ret;
+	unsigned i;
+
+	if (wim == NULL)
+		return WIMLIB_ERR_INVALID_PARAM;
+
+	if (num_resource_wims != 0 && resource_wims == NULL)
+		return WIMLIB_ERR_INVALID_PARAM;
+
+	for (i = 0; i < num_resource_wims; i++)
+		if (resource_wims[i] == NULL)
+			return WIMLIB_ERR_INVALID_PARAM;
+
+	for_lookup_table_entry(wim->lookup_table, lte_zero_out_refcnt, NULL);
+
+	for (i = 0; i < num_resource_wims; i++) {
+		ret = for_lookup_table_entry(resource_wims[i]->lookup_table,
+					     lte_clone_if_new,
+					     wim->lookup_table);
+		if (ret)
+			goto out_rollback;
+	}
+	return 0;
+
+out_rollback:
+	for_lookup_table_entry(wim->lookup_table, lte_delete_if_new,
+			       wim->lookup_table);
+	return ret;
+}
+
+static int
+reference_resource_paths(WIMStruct *wim,
+			 const tchar * const *resource_wimfiles,
+			 unsigned num_resource_wimfiles,
+			 int ref_flags,
+			 int open_flags,
+			 wimlib_progress_func_t progress_func)
+{
+	WIMStruct **resource_wims;
+	unsigned i;
+	int ret;
+
+	resource_wims = CALLOC(num_resource_wimfiles, sizeof(resource_wims[0]));
+	if (!resource_wims)
+		return WIMLIB_ERR_NOMEM;
+
+	for (i = 0; i < num_resource_wimfiles; i++) {
+		DEBUG("Referencing resources from path \"%"TS"\"",
+		      resource_wimfiles[i]);
+		ret = wimlib_open_wim(resource_wimfiles[i], open_flags,
+				      &resource_wims[i], progress_func);
+		if (ret)
+			goto out_free_resource_wims;
+	}
+
+	ret = wimlib_reference_resources(wim, resource_wims,
+					 num_resource_wimfiles, ref_flags);
+	if (ret)
+		goto out_free_resource_wims;
+
+	for (i = 0; i < num_resource_wimfiles; i++)
+		list_add_tail(&resource_wims[i]->subwim_node, &wim->subwims);
+
+	ret = 0;
+	goto out_free_array;
+
+out_free_resource_wims:
+	for (i = 0; i < num_resource_wimfiles; i++)
+		wimlib_free(resource_wims[i]);
+out_free_array:
+	FREE(resource_wims);
+	return ret;
+}
+
+static int
+reference_resource_glob(WIMStruct *wim, const tchar *refglob,
+			int ref_flags, int open_flags,
+			wimlib_progress_func_t progress_func)
+{
+	glob_t globbuf;
+	int ret;
+
+	/* Note: glob() is replaced in Windows native builds.  */
+	ret = tglob(refglob, GLOB_ERR | GLOB_NOSORT, NULL, &globbuf);
+	if (ret) {
+		if (ret == GLOB_NOMATCH) {
+			if (ref_flags & WIMLIB_REF_FLAG_GLOB_ERR_ON_NOMATCH) {
+				ERROR("Found no files for glob \"%"TS"\"", refglob);
+				return WIMLIB_ERR_GLOB_HAD_NO_MATCHES;
+			} else {
+				return reference_resource_paths(wim,
+								&refglob,
+								1,
+								ref_flags,
+								open_flags,
+								progress_func);
+			}
+		} else {
+			ERROR_WITH_ERRNO("Failed to process glob \"%"TS"\"", refglob);
+			if (ret == GLOB_NOSPACE)
+				return WIMLIB_ERR_NOMEM;
+			else
+				return WIMLIB_ERR_READ;
+		}
+	}
+
+	ret = reference_resource_paths(wim,
+				       (const tchar * const *)globbuf.gl_pathv,
+				       globbuf.gl_pathc,
+				       ref_flags,
+				       open_flags,
+				       progress_func);
+	globfree(&globbuf);
+	return ret;
+}
+
+/* API function documented in wimlib.h  */
+WIMLIBAPI int
+wimlib_reference_resource_files(WIMStruct *wim,
+				const tchar * const * resource_wimfiles_or_globs,
+				unsigned count,
+				int ref_flags,
+				int open_flags,
+				wimlib_progress_func_t progress_func)
+{
+	unsigned i;
+	int ret;
+
+	if (ref_flags & WIMLIB_REF_FLAG_GLOB_ENABLE) {
+		for (i = 0; i < count; i++) {
+			ret = reference_resource_glob(wim,
+						      resource_wimfiles_or_globs[i],
+						      ref_flags,
+						      open_flags,
+						      progress_func);
+			if (ret)
+				return ret;
+		}
+		return 0;
+	} else {
+		return reference_resource_paths(wim, resource_wimfiles_or_globs,
+						count, ref_flags,
+						open_flags, progress_func);
+	}
+}