Various cleanups

[wimlib] / src / lookup_table.c

diff --git a/src/lookup_table.c b/src/lookup_table.c
index 57bbc0c63d9bb1c116f7a6147cd55d1129d1a37b..1226488acebee959713f8cbbd9a89287c9334c6f 100644 (file)
--- a/src/lookup_table.c
+++ b/src/lookup_table.c
@@ -61,18 +61,72 @@ struct lookup_table_entry *new_lookup_table_entry()
        struct lookup_table_entry *lte;
        
        lte = CALLOC(1, sizeof(struct lookup_table_entry));
-       if (!lte) {
+       if (lte) {
+               lte->part_number  = 1;
+               lte->refcnt       = 1;
+       } else {
                ERROR("Out of memory (tried to allocate %zu bytes for "
                      "lookup table entry)",
                      sizeof(struct lookup_table_entry));
-               return NULL;
        }
-
-       lte->part_number  = 1;
-       lte->refcnt       = 1;
        return lte;
 }
 
+struct lookup_table_entry *
+clone_lookup_table_entry(const struct lookup_table_entry *old)
+{
+       struct lookup_table_entry *new;
+
+       new = MALLOC(sizeof(*new));
+       if (!new)
+               return NULL;
+
+       memcpy(new, old, sizeof(*old));
+       new->extracted_file = NULL;
+       switch (new->resource_location) {
+       case RESOURCE_IN_STAGING_FILE:
+       case RESOURCE_IN_FILE_ON_DISK:
+               wimlib_assert((void*)&old->file_on_disk ==
+                             (void*)&old->staging_file_name);
+               new->staging_file_name = STRDUP(old->staging_file_name);
+               if (!new->staging_file_name)
+                       goto out_free;
+               break;
+       case RESOURCE_IN_ATTACHED_BUFFER:
+               new->attached_buffer = MALLOC(wim_resource_size(old));
+               if (!new->attached_buffer)
+                       goto out_free;
+               memcpy(new->attached_buffer, old->attached_buffer,
+                      wim_resource_size(old));
+               break;
+       case RESOURCE_IN_NTFS_VOLUME:
+               if (old->ntfs_loc) {
+                       struct ntfs_location *loc;
+                       loc = MALLOC(sizeof(*loc));
+                       if (!loc)
+                               goto out_free;
+                       memcpy(loc, old->ntfs_loc, sizeof(*loc));
+                       loc->path_utf8 = NULL;
+                       loc->stream_name_utf16 = NULL;
+                       new->ntfs_loc = loc;
+                       loc->path_utf8 = STRDUP(old->ntfs_loc->path_utf8);
+                       if (!loc->path_utf8)
+                               goto out_free;
+                       loc->stream_name_utf16 = MALLOC(loc->stream_name_utf16_num_chars * 2);
+                       if (!loc->stream_name_utf16)
+                               goto out_free;
+                       memcpy(loc->stream_name_utf16,
+                              old->ntfs_loc->stream_name_utf16,
+                              loc->stream_name_utf16_num_chars * 2);
+               }
+               break;
+       }
+       return new;
+out_free:
+       free_lookup_table_entry(new);
+       return NULL;
+}
+
 void free_lookup_table_entry(struct lookup_table_entry *lte)
 {
        if (lte) {
@@ -223,7 +277,8 @@ int read_lookup_table(WIMStruct *w)
              w->hdr.lookup_table_res_entry.offset,
              w->hdr.lookup_table_res_entry.original_size);
 
-       if (fseeko(w->fp, w->hdr.lookup_table_res_entry.offset, SEEK_SET) != 0) {
+       if (fseeko(w->fp, w->hdr.lookup_table_res_entry.offset, SEEK_SET) != 0)
+       {
                ERROR_WITH_ERRNO("Failed to seek to byte %"PRIu64" to read "
                                 "lookup table",
                                 w->hdr.lookup_table_res_entry.offset);
@@ -268,7 +323,6 @@ int read_lookup_table(WIMStruct *w)
                              w->hdr.part_number, cur_entry->part_number);
                        ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
                        goto out_free_cur_entry;
-                       
                }
 
                if (is_zero_hash(cur_entry->hash)) {
@@ -292,7 +346,7 @@ int read_lookup_table(WIMStruct *w)
 
                if (!(cur_entry->resource_entry.flags & WIM_RESHDR_FLAG_COMPRESSED)
                    && (cur_entry->resource_entry.size !=
-                     cur_entry->resource_entry.original_size))
+                       cur_entry->resource_entry.original_size))
                {
                        ERROR("Found uncompressed resource with original size "
                              "not the same as compressed size");
@@ -440,7 +494,8 @@ __lookup_resource(const struct lookup_table *table, const u8 hash[])
        struct lookup_table_entry *lte;
        struct hlist_node *pos;
 
-       wimlib_assert(table);
+       wimlib_assert(table != NULL);
+       wimlib_assert(hash != NULL);
 
        i = *(size_t*)hash % table->capacity;
        hlist_for_each_entry(lte, pos, &table->array[i], hash_list)
@@ -522,6 +577,8 @@ static 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;
@@ -535,6 +592,24 @@ static void inode_resolve_ltes(struct inode *inode, struct lookup_table *table)
        }
 }
 
+static 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);
+               else
+                       zero_out_hash(inode->ads_entries[i].hash);
+       }
+       inode->resolved = false;
+}
+
 /* Resolve a dentry's lookup table entries 
  *
  * This replaces the SHA1 hash fields (which are used to lookup an entry in the
@@ -551,6 +626,13 @@ int dentry_resolve_ltes(struct dentry *dentry, void *table)
        return 0;
 }
 
+int dentry_unresolve_ltes(struct dentry *dentry, void *ignore)
+{
+       if (dentry->d_inode->resolved)
+               inode_unresolve_ltes(dentry->d_inode);
+       return 0;
+}
+
 /* Return the lookup table entry for the unnamed data stream of an inode, or
  * NULL if there is none.
  *