X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Flookup_table.c;h=67ce92a3f37b79617ac2a9c370e5980c0fe18f9a;hp=cc71c8bec4e19b6adc6a59e0a04bb6fb9d8e67a4;hb=c92b18f7074e6d632c555bed5897c5723abde720;hpb=597e700af87a07ec12f2bd10690954473cf1ca93

diff --git a/src/lookup_table.c b/src/lookup_table.c
index cc71c8be..67ce92a3 100644
--- a/src/lookup_table.c
+++ b/src/lookup_table.c
@@ -26,7 +26,7 @@
 
 #include "wimlib_internal.h"
 #include "lookup_table.h"
-#include "io.h"
+#include "buffer_io.h"
 #include <errno.h>
 
 #ifdef WITH_FUSE
@@ -39,21 +39,20 @@ struct lookup_table *new_lookup_table(size_t capacity)
 	struct hlist_head *array;
 
 	table = MALLOC(sizeof(struct lookup_table));
-	if (!table)
-		goto err;
-	array = CALLOC(capacity, sizeof(array[0]));
-	if (!array) {
-		FREE(table);
-		goto err;
+	if (table) {
+		array = CALLOC(capacity, sizeof(array[0]));
+		if (array) {
+			table->num_entries = 0;
+			table->capacity = capacity;
+			table->array = array;
+		} else {
+			FREE(table);
+			table = NULL;
+			ERROR("Failed to allocate memory for lookup table with capacity %zu",
+			      capacity);
+		}
 	}
-	table->num_entries = 0;
-	table->capacity = capacity;
-	table->array = array;
 	return table;
-err:
-	ERROR("Failed to allocate memory for lookup table with capacity %zu",
-	      capacity);
-	return NULL;
 }
 
 struct lookup_table_entry *new_lookup_table_entry()
@@ -122,6 +121,8 @@ clone_lookup_table_entry(const struct lookup_table_entry *old)
 		}
 		break;
 #endif
+	default:
+		break;
 	}
 	return new;
 out_free:
@@ -154,7 +155,6 @@ void free_lookup_table_entry(struct lookup_table_entry *lte)
 		default:
 			break;
 		}
-		FREE(lte->extracted_file);
 		FREE(lte);
 	}
 }
@@ -217,8 +217,8 @@ static void finalize_lte(struct lookup_table_entry *lte)
 void lte_decrement_refcnt(struct lookup_table_entry *lte,
 			  struct lookup_table *table)
 {
-	wimlib_assert(lte);
-	wimlib_assert(lte->refcnt);
+	wimlib_assert(lte != NULL);
+	wimlib_assert(lte->refcnt != 0);
 	if (--lte->refcnt == 0) {
 		lookup_table_unlink(table, lte);
 	#ifdef WITH_FUSE
@@ -231,10 +231,11 @@ void lte_decrement_refcnt(struct lookup_table_entry *lte,
 #ifdef WITH_FUSE
 void lte_decrement_num_opened_fds(struct lookup_table_entry *lte)
 {
-	wimlib_assert(lte);
-	wimlib_assert(lte->num_opened_fds);
-	if (--lte->num_opened_fds == 0 && lte->refcnt == 0)
-		finalize_lte(lte);
+	wimlib_assert(lte != NULL);
+	if (lte->num_opened_fds != 0) {
+		if (--lte->num_opened_fds == 0 && lte->refcnt == 0)
+			finalize_lte(lte);
+	}
 }
 #endif
 
@@ -268,12 +269,18 @@ int for_lookup_table_entry(struct lookup_table *table,
  */
 int read_lookup_table(WIMStruct *w)
 {
-	u64    num_entries;
-	u8     buf[WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE];
-	int    ret;
+	u64 num_entries;
+	u8 buf[WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE];
+	int ret;
 	struct lookup_table *table;
 	struct lookup_table_entry *cur_entry = NULL, *duplicate_entry;
 
+	if (resource_is_compressed(&w->hdr.lookup_table_res_entry)) {
+		ERROR("Didn't expect a compressed lookup table!");
+		ERROR("Ask the author to implement support for this.");
+		return WIMLIB_ERR_COMPRESSED_LOOKUP_TABLE;
+	}
+
 	DEBUG("Reading lookup table: offset %"PRIu64", size %"PRIu64"",
 	      w->hdr.lookup_table_res_entry.offset,
 	      w->hdr.lookup_table_res_entry.original_size);
@@ -363,6 +370,14 @@ int read_lookup_table(WIMStruct *w)
 			ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
 			goto out_free_cur_entry;
 		}
+		if ((cur_entry->resource_entry.flags & WIM_RESHDR_FLAG_METADATA)
+		    && cur_entry->refcnt != 1)
+		{
+			ERROR("Found metadata resource with refcnt != 1:");
+			print_lookup_table_entry(cur_entry);
+			ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
+			goto out_free_cur_entry;
+		}
 		lookup_table_insert(table, cur_entry);
 
 	}
@@ -408,6 +423,33 @@ int write_lookup_table_entry(struct lookup_table_entry *lte, void *__out)
 	return 0;
 }
 
+/* Writes the lookup table to the output file. */
+int write_lookup_table(struct lookup_table *table, FILE *out,
+		       struct resource_entry *out_res_entry)
+{
+	off_t start_offset, end_offset;
+	int ret;
+
+	start_offset = ftello(out);
+	if (start_offset == -1)
+		return WIMLIB_ERR_WRITE;
+
+	ret = for_lookup_table_entry(table, write_lookup_table_entry, out);
+	if (ret != 0)
+		return ret;
+
+	end_offset = ftello(out);
+	if (end_offset == -1)
+		return WIMLIB_ERR_WRITE;
+
+	out_res_entry->offset        = start_offset;
+	out_res_entry->size          = end_offset - start_offset;
+	out_res_entry->original_size = end_offset - start_offset;
+	out_res_entry->flags         = WIM_RESHDR_FLAG_METADATA;
+
+	return 0;
+}
+
 
 int lte_zero_real_refcnt(struct lookup_table_entry *lte, void *ignore)
 {
@@ -421,13 +463,21 @@ int lte_zero_out_refcnt(struct lookup_table_entry *lte, void *ignore)
 	return 0;
 }
 
-int lte_free_extracted_file(struct lookup_table_entry *lte, void *ignone)
+int lte_zero_extracted_file(struct lookup_table_entry *lte, void *ignore)
 {
-	FREE(lte->extracted_file);
 	lte->extracted_file = NULL;
 	return 0;
 }
 
+int lte_free_extracted_file(struct lookup_table_entry *lte, void *ignore)
+{
+	if (lte->extracted_file != NULL) {
+		FREE(lte->extracted_file);
+		lte->extracted_file = NULL;
+	}
+	return 0;
+}
+
 void print_lookup_table_entry(const struct lookup_table_entry *lte)
 {
 	if (!lte) {
@@ -581,41 +631,42 @@ out:
 }
 #endif
 
-static void inode_resolve_ltes(struct inode *inode, struct lookup_table *table)
+void inode_resolve_ltes(struct inode *inode, struct lookup_table *table)
 {
-	struct lookup_table_entry *lte;
 
-	wimlib_assert(!inode->resolved);
-
-	/* Resolve the default file stream */
-	lte = __lookup_resource(table, inode->hash);
-	inode->lte = lte;
-	inode->resolved = true;
-
-	/* Resolve the alternate data streams */
-	for (u16 i = 0; i < inode->num_ads; i++) {
-		struct ads_entry *cur_entry = &inode->ads_entries[i];
-		lte = __lookup_resource(table, cur_entry->hash);
-		cur_entry->lte = lte;
+	if (!inode->resolved) {
+		struct lookup_table_entry *lte;
+		/* Resolve the default file stream */
+		lte = __lookup_resource(table, inode->hash);
+		inode->lte = lte;
+		inode->resolved = 1;
+
+		/* Resolve the alternate data streams */
+		for (u16 i = 0; i < inode->num_ads; i++) {
+			struct ads_entry *cur_entry = &inode->ads_entries[i];
+			lte = __lookup_resource(table, cur_entry->hash);
+			cur_entry->lte = lte;
+		}
 	}
 }
 
-static void inode_unresolve_ltes(struct inode *inode)
+void inode_unresolve_ltes(struct inode *inode)
 {
-	wimlib_assert(inode->resolved);
-	if (inode->lte)
-		copy_hash(inode->hash, inode->lte->hash);
-	else
-		zero_out_hash(inode->hash);
-
-	for (u16 i = 0; i < inode->num_ads; i++) {
-		if (inode->ads_entries[i].lte)
-			copy_hash(inode->ads_entries[i].hash,
-				  inode->ads_entries[i].lte->hash);
+	if (inode->resolved) {
+		if (inode->lte)
+			copy_hash(inode->hash, inode->lte->hash);
 		else
-			zero_out_hash(inode->ads_entries[i].hash);
+			zero_out_hash(inode->hash);
+
+		for (u16 i = 0; i < inode->num_ads; i++) {
+			if (inode->ads_entries[i].lte)
+				copy_hash(inode->ads_entries[i].hash,
+					  inode->ads_entries[i].lte->hash);
+			else
+				zero_out_hash(inode->ads_entries[i].hash);
+		}
+		inode->resolved = 0;
 	}
-	inode->resolved = false;
 }
 
 /* Resolve a dentry's lookup table entries
@@ -629,18 +680,35 @@ static void inode_unresolve_ltes(struct inode *inode)
  */
 int dentry_resolve_ltes(struct dentry *dentry, void *table)
 {
-	if (!dentry->d_inode->resolved)
-		inode_resolve_ltes(dentry->d_inode, table);
+	wimlib_assert(dentry->refcnt == 1);
+	inode_resolve_ltes(dentry->d_inode, table);
 	return 0;
 }
 
 int dentry_unresolve_ltes(struct dentry *dentry, void *ignore)
 {
-	if (dentry->d_inode->resolved)
-		inode_unresolve_ltes(dentry->d_inode);
+	inode_unresolve_ltes(dentry->d_inode);
 	return 0;
 }
 
+/*
+ * Returns the lookup table entry for stream @stream_idx of the inode, where
+ * stream_idx = 0 means the default un-named file stream, and stream_idx >= 1
+ * corresponds to an alternate data stream.
+ *
+ * This works for both resolved and un-resolved dentries.
+ */
+struct lookup_table_entry *
+inode_stream_lte(const struct inode *inode, unsigned stream_idx,
+		 const struct lookup_table *table)
+{
+	if (inode->resolved)
+		return inode_stream_lte_resolved(inode, stream_idx);
+	else
+		return inode_stream_lte_unresolved(inode, stream_idx, table);
+}
+
+
 /* Return the lookup table entry for the unnamed data stream of an inode, or
  * NULL if there is none.
  *
@@ -659,7 +727,7 @@ int dentry_unresolve_ltes(struct dentry *dentry, void *ignore)
  */
 struct lookup_table_entry *
 inode_unnamed_lte(const struct inode *inode,
-		   const struct lookup_table *table)
+		  const struct lookup_table *table)
 {
 	if (inode->resolved)
 		return inode_unnamed_lte_resolved(inode);
@@ -667,3 +735,16 @@ inode_unnamed_lte(const struct inode *inode,
 		return inode_unnamed_lte_unresolved(inode, table);
 }
 
+static int lte_add_stream_size(struct lookup_table_entry *lte,
+			       void *total_bytes_p)
+{
+	*(u64*)total_bytes_p += lte->resource_entry.size;
+	return 0;
+}
+
+u64 lookup_table_total_stream_size(struct lookup_table *table)
+{
+	u64 total_size = 0;
+	for_lookup_table_entry(table, lte_add_stream_size, &total_size);
+	return total_size;
+}