X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Flookup_table.c;h=66c4670076f61dfabf8e278d91caef7d3276f427;hp=1f6384cfcf6d9f9d945d88b2d6406b7d394a068a;hb=d125eeb310e7e4d3e4288293acc32997462a39ca;hpb=53d4db68e30bf45b983c59f91e5e2a3e039e1426

diff --git a/src/lookup_table.c b/src/lookup_table.c
index 1f6384cf..66c46700 100644
--- a/src/lookup_table.c
+++ b/src/lookup_table.c
@@ -27,13 +27,14 @@
 #include "wimlib_internal.h"
 #include "lookup_table.h"
 #include "io.h"
+#include <errno.h>
 
 struct lookup_table *new_lookup_table(size_t capacity)
 {
 	struct lookup_table *table;
 	struct lookup_table_entry **array;
 
-	table = CALLOC(1, sizeof(struct lookup_table));
+	table = MALLOC(sizeof(struct lookup_table));
 	if (!table)
 		goto err;
 	array = CALLOC(capacity, sizeof(array[0]));
@@ -46,8 +47,8 @@ struct lookup_table *new_lookup_table(size_t capacity)
 	table->array = array;
 	return table;
 err:
-	ERROR("Failed to allocate memory for lookup table with capacity "
-			"%zu\n", capacity);
+	ERROR("Failed to allocate memory for lookup table with capacity %zu",
+	      capacity);
 	return NULL;
 }
 
@@ -55,24 +56,30 @@ struct lookup_table_entry *new_lookup_table_entry()
 {
 	struct lookup_table_entry *lte;
 	
-	lte = MALLOC(sizeof(struct lookup_table_entry));
+	lte = CALLOC(1, sizeof(struct lookup_table_entry));
 	if (!lte) {
 		ERROR("Out of memory (tried to allocate %zu bytes for "
-				"lookup table entry)\n", 
-				sizeof(struct lookup_table_entry));
+		      "lookup table entry)",
+		      sizeof(struct lookup_table_entry));
 		return NULL;
 	}
 
-	lte->file_on_disk = NULL;
-	lte->other_wim_fp = NULL;
-	lte->next         = NULL;
 	lte->part_number  = 1;
 	lte->refcnt       = 1;
-	lte->staging_num_times_opened = 0;
+	INIT_LIST_HEAD(&lte->lte_group_list);
 	return lte;
 }
 
 
+void free_lookup_table_entry(struct lookup_table_entry *lte)
+{
+	if (lte) {
+		if (lte->staging_list.next)
+			list_del(&lte->staging_list);
+		FREE(lte->file_on_disk);
+		FREE(lte);
+	}
+}
 
 /*
  * Inserts an entry into the lookup table.
@@ -122,7 +129,8 @@ void lookup_table_unlink(struct lookup_table *table,
 /* Decrement the reference count for the dentry having hash value @hash in the
  * lookup table.  The lookup table entry is unlinked and freed if there are no
  * references to in remaining.  */
-void lookup_table_decrement_refcnt(struct lookup_table* table, const u8 hash[])
+struct lookup_table_entry *
+lookup_table_decrement_refcnt(struct lookup_table* table, const u8 hash[])
 {
 	size_t pos = *(size_t*)hash % table->capacity;
 	struct lookup_table_entry *prev = NULL;
@@ -133,35 +141,39 @@ void lookup_table_decrement_refcnt(struct lookup_table* table, const u8 hash[])
 		if (memcmp(hash, entry->hash, WIM_HASH_SIZE) == 0) {
 			wimlib_assert(entry->refcnt != 0);
 			if (--entry->refcnt == 0) {
-				free_lookup_table_entry(entry);
+				if (entry->num_opened_fds == 0) {
+					free_lookup_table_entry(entry);
+					entry = NULL;
+				}
 				if (prev)
 					prev->next = next;
 				else
 					table->array[pos] = next;
+				break;
 			}
 		}
 		prev = entry;
 		entry = next;
 	}
+	return entry;
 }
 
-/* 
- * Looks up an entry in the lookup table.
- */
-struct lookup_table_entry *lookup_resource(const struct lookup_table *lookup_table, 
-				     const u8 hash[])
+/* Like lookup_table_decrement_refcnt(), but for when we already know the lookup
+ * table entry. */
+struct lookup_table_entry *
+lte_decrement_refcnt(struct lookup_table_entry *lte, struct lookup_table *table)
 {
-	size_t pos;
-	struct lookup_table_entry *lte;
-
-	pos = *(size_t*)hash % lookup_table->capacity;
-	lte = lookup_table->array[pos];
-	while (lte) {
-		if (memcmp(hash, lte->hash, WIM_HASH_SIZE) == 0)
-			return lte;
-		lte = lte->next;
+	if (lte) {
+		wimlib_assert(lte->refcnt);
+		if (--lte->refcnt == 0) {
+			lookup_table_unlink(table, lte);
+			if (lte->num_opened_fds == 0) {
+				free_lookup_table_entry(lte);
+				lte = NULL;
+			}
+		}
 	}
-	return NULL;
+	return lte;
 }
 
 /* 
@@ -169,7 +181,8 @@ struct lookup_table_entry *lookup_resource(const struct lookup_table *lookup_tab
  * return nonzero if any call to the function returns nonzero.
  */
 int for_lookup_table_entry(struct lookup_table *table, 
-		int (*visitor)(struct lookup_table_entry *, void *), void *arg)
+			   int (*visitor)(struct lookup_table_entry *, void *),
+			   void *arg)
 {
 	struct lookup_table_entry *entry, *next;
 	size_t i;
@@ -209,12 +222,12 @@ int read_lookup_table(FILE *fp, u64 offset, u64 size,
 	const u8 *p;
 	struct lookup_table_entry *cur_entry;
 
-	DEBUG("Reading lookup table: offset %"PRIu64", size %"PRIu64"\n",
-			offset, size);
+	DEBUG("Reading lookup table: offset %"PRIu64", size %"PRIu64"",
+	      offset, size);
 
 	if (fseeko(fp, offset, SEEK_SET) != 0) {
-		ERROR("Failed to seek to byte %"PRIu64" to read lookup table: "
-				"%m\n", offset);
+		ERROR_WITH_ERRNO("Failed to seek to byte %"PRIu64" to read "
+				 "lookup table", offset);
 		return WIMLIB_ERR_READ;
 	}
 
@@ -226,30 +239,30 @@ int read_lookup_table(FILE *fp, u64 offset, u64 size,
 	while (num_entries--) {
 		if (fread(buf, 1, sizeof(buf), fp) != sizeof(buf)) {
 			if (feof(fp)) {
-				ERROR("Unexpected EOF in lookup table!\n");
+				ERROR("Unexpected EOF in WIM lookup table!");
 			} else {
-				ERROR("Stream read error while reading "
-						"lookup table!\n");
+				ERROR_WITH_ERRNO("Error reading WIM lookup "
+						 "table");
 			}
 			ret = WIMLIB_ERR_READ;
-			goto err;
+			goto out;
 		}
 		cur_entry = new_lookup_table_entry();
 		if (!cur_entry) {
 			ret = WIMLIB_ERR_NOMEM;
-			goto err;
+			goto out;
 		}
 			 
 		p = get_resource_entry(buf, &cur_entry->resource_entry);
 		p = get_u16(p, &cur_entry->part_number);
 		p = get_u32(p, &cur_entry->refcnt);
-		p = get_bytes(p, sizeof(cur_entry->hash), cur_entry->hash);
+		p = get_bytes(p, WIM_HASH_SIZE, cur_entry->hash);
 		lookup_table_insert(table, cur_entry);
 	}
-	DEBUG("Done reading lookup table.\n");
+	DEBUG("Done reading lookup table.");
 	*table_ret = table;
 	return 0;
-err:
+out:
 	free_lookup_table(table);
 	return ret;
 }
@@ -276,20 +289,22 @@ int write_lookup_table_entry(struct lookup_table_entry *lte, void *__out)
 		return 0;
 
 	if (lte->output_resource_entry.flags & WIM_RESHDR_FLAG_METADATA)
-		DEBUG("Writing metadata entry at %lu\n", ftello(out));
+		DEBUG("Writing metadata entry at %lu (orig size = %zu)",
+		      ftello(out), lte->output_resource_entry.original_size);
 
 	p = put_resource_entry(buf, &lte->output_resource_entry);
 	p = put_u16(p, lte->part_number);
 	p = put_u32(p, lte->out_refcnt);
 	p = put_bytes(p, WIM_HASH_SIZE, lte->hash);
 	if (fwrite(buf, 1, sizeof(buf), out) != sizeof(buf)) {
-		ERROR("Failed to write lookup table entry: %m\n");
+		ERROR_WITH_ERRNO("Failed to write lookup table entry");
 		return WIMLIB_ERR_WRITE;
 	}
 	return 0;
 }
 
-static int do_free_lookup_table_entry(struct lookup_table_entry *entry, void *ignore)
+static int do_free_lookup_table_entry(struct lookup_table_entry *entry,
+				      void *ignore)
 {
 	free_lookup_table_entry(entry);
 	return 0;
@@ -297,15 +312,13 @@ static int do_free_lookup_table_entry(struct lookup_table_entry *entry, void *ig
 
 void free_lookup_table(struct lookup_table *table)
 {
-	if (table) {
-		if (table->array) {
-			for_lookup_table_entry(table, 
-					       do_free_lookup_table_entry, 
-					       NULL);
-			FREE(table->array);
-		}
-		FREE(table);
+	if (!table)
+		return;
+	if (table->array) {
+		for_lookup_table_entry(table, do_free_lookup_table_entry, NULL);
+		FREE(table->array);
 	}
+	FREE(table);
 }
 
 int zero_out_refcnts(struct lookup_table_entry *entry, void *ignore)
@@ -317,11 +330,11 @@ int zero_out_refcnts(struct lookup_table_entry *entry, void *ignore)
 int print_lookup_table_entry(struct lookup_table_entry *entry, void *ignore)
 {
 	printf("Offset            = %"PRIu64" bytes\n", 
-			entry->resource_entry.offset);
+	       entry->resource_entry.offset);
 	printf("Size              = %"PRIu64" bytes\n", 
-			(u64)entry->resource_entry.size);
+	       (u64)entry->resource_entry.size);
 	printf("Original size     = %"PRIu64" bytes\n", 
-			entry->resource_entry.original_size);
+	       entry->resource_entry.original_size);
 	printf("Part Number       = %hu\n", entry->part_number);
 	printf("Reference Count   = %u\n", entry->refcnt);
 	printf("Hash              = ");
@@ -339,7 +352,7 @@ int print_lookup_table_entry(struct lookup_table_entry *entry, void *ignore)
 		fputs("WIM_RESHDR_FLAG_SPANNED, ", stdout);
 	putchar('\n');
 	if (entry->file_on_disk)
-		printf("File on Disk      = \"%s\"\n", entry->file_on_disk);
+		printf("File on Disk      = `%s'\n", entry->file_on_disk);
 	putchar('\n');
 	return 0;
 }
@@ -352,3 +365,119 @@ WIMLIBAPI void wimlib_print_lookup_table(WIMStruct *w)
 	for_lookup_table_entry(w->lookup_table, 
 			       print_lookup_table_entry, NULL);
 }
+
+/* 
+ * Looks up an entry in the lookup table.
+ */
+struct lookup_table_entry *
+__lookup_resource(const struct lookup_table *lookup_table, const u8 hash[])
+{
+	size_t pos;
+	struct lookup_table_entry *lte;
+
+	pos = *(size_t*)hash % lookup_table->capacity;
+	lte = lookup_table->array[pos];
+	while (lte) {
+		if (memcmp(hash, lte->hash, WIM_HASH_SIZE) == 0)
+			return lte;
+		lte = lte->next;
+	}
+	return NULL;
+}
+
+/* 
+ * Finds the dentry, lookup table entry, and stream index for a WIM file stream,
+ * given a path name.
+ *
+ * This is only for pre-resolved dentries.
+ */
+int lookup_resource(WIMStruct *w, const char *path,
+		    int lookup_flags,
+		    struct dentry **dentry_ret,
+		    struct lookup_table_entry **lte_ret,
+		    unsigned *stream_idx_ret)
+{
+	struct dentry *dentry;
+	struct lookup_table_entry *lte;
+	unsigned stream_idx;
+	dentry = get_dentry(w, path);
+	if (!dentry)
+		return -ENOENT;
+
+	wimlib_assert(dentry->resolved);
+
+	lte = dentry->lte;
+	if (!(lookup_flags & LOOKUP_FLAG_DIRECTORY_OK)
+	      && dentry_is_directory(dentry))
+		return -EISDIR;
+	stream_idx = 0;
+	if (lookup_flags & LOOKUP_FLAG_ADS_OK) {
+		const char *stream_name = path_stream_name(path);
+		if (stream_name) {
+			size_t stream_name_len = strlen(stream_name);
+			for (u16 i = 0; i < dentry->num_ads; i++) {
+				if (ads_entry_has_name(&dentry->ads_entries[i],
+						       stream_name,
+						       stream_name_len))
+				{
+					stream_idx = i + 1;
+					lte = dentry->ads_entries[i].lte;
+					goto out;
+				}
+			}
+			return -ENOENT;
+		}
+	}
+out:
+	if (dentry_ret)
+		*dentry_ret = dentry;
+	if (lte_ret)
+		*lte_ret = lte;
+	if (stream_idx_ret)
+		*stream_idx_ret = stream_idx;
+	return 0;
+}
+
+/* Resolve a dentry's lookup table entries 
+ *
+ * This replaces the SHA1 hash fields (which are used to lookup an entry in the
+ * lookup table) with pointers directly to the lookup table entries.  A circular
+ * linked list of streams sharing the same lookup table entry is created.
+ *
+ * This function always succeeds; unresolved lookup table entries are given a
+ * NULL pointer.
+ */
+int dentry_resolve_ltes(struct dentry *dentry, void *__table)
+{
+	struct lookup_table *table = __table;
+	struct lookup_table_entry *lte;
+
+	wimlib_assert(!dentry->resolved);
+
+	/* Resolve the default file stream */
+	lte = __lookup_resource(table, dentry->hash);
+	if (lte)
+		list_add(&dentry->lte_group_list.list, &lte->lte_group_list);
+	else
+		INIT_LIST_HEAD(&dentry->lte_group_list.list);
+	dentry->lte = lte;
+	dentry->lte_group_list.type = STREAM_TYPE_NORMAL;
+	dentry->resolved = true;
+
+	/* Resolve the alternate data streams */
+	if (dentry->ads_entries_status != ADS_ENTRIES_USER) {
+		for (u16 i = 0; i < dentry->num_ads; i++) {
+			struct ads_entry *cur_entry = &dentry->ads_entries[i];
+
+			lte = __lookup_resource(table, cur_entry->hash);
+			if (lte)
+				list_add(&cur_entry->lte_group_list.list,
+					 &lte->lte_group_list);
+			else
+				INIT_LIST_HEAD(&cur_entry->lte_group_list.list);
+			cur_entry->lte = lte;
+			cur_entry->lte_group_list.type = STREAM_TYPE_ADS;
+		}
+	}
+	return 0;
+}