Hard link disambiguation
authorEric Biggers <ebiggers3@gmail.com>
Tue, 28 Aug 2012 19:07:21 +0000 (14:07 -0500)
committerEric Biggers <ebiggers3@gmail.com>
Tue, 28 Aug 2012 19:07:21 +0000 (14:07 -0500)
Will be adding more comments and doing more testing soon

src/dentry.h
src/hardlink.c
src/modify.c
src/mount.c
src/ntfs-capture.c
src/resource.c
src/wimlib_internal.h

index ba10002..38ce12f 100644 (file)
@@ -110,6 +110,15 @@ static inline bool ads_entry_has_name(const struct ads_entry *entry,
        return memcmp(entry->stream_name_utf8, name, name_len) == 0;
 }
 
+static inline bool ads_entries_have_same_name(const struct ads_entry *entry_1,
+                                             const struct ads_entry *entry_2)
+{
+       if (entry_1->stream_name_len != entry_2->stream_name_len)
+               return false;
+       return memcmp(entry_1->stream_name, entry_2->stream_name,
+                     entry_1->stream_name_len) == 0;
+}
+
 
 /* 
  * In-memory structure for a WIM directory entry (dentry).  There is a directory
@@ -283,8 +292,11 @@ struct dentry {
        /* List of dentries in the hard link set */
        struct list_head link_group_list;
 
+       union {
        /* List of dentries sharing the same lookup table entry */
-       struct stream_list_head lte_group_list;
+               struct stream_list_head lte_group_list;
+               struct list_head tmp_list;
+       };
 
        /* Path to extracted file on disk (used during extraction only)
         * (malloc()ed buffer) */
index 0ceafb8..6200277 100644 (file)
@@ -41,14 +41,27 @@ struct link_group {
 /* Hash table to find hard link groups, identified by their hard link group ID.
  * */
 struct link_group_table {
+       /* Fields for the hash table */
        struct link_group **array;
        u64 num_entries;
        u64 capacity;
-       struct link_group *singles;
+
+       /* 
+        * Linked list of "extra" groups.  These may be:
+        *
+        * - Hard link groups of size 1, which are all allowed to have 0 for
+        *   their hard link group ID, meaning we cannot insert them into the
+        *   hash table
+        * - Groups we create ourselves by splitting a nominal hard link group
+        *   due to inconsistencies in the dentries.  These groups will have a
+        *   hard link group ID duplicated with some other group until
+        *   assign_link_group_ids() is called.
+        */
+       struct link_group *extra_groups;
 };
 
 /* Returns pointer to a new link group table having the specified capacity */
-struct link_group_table *new_link_group_table(u64 capacity)
+struct link_group_table *new_link_group_table(size_t capacity)
 {
        struct link_group_table *table;
        struct link_group **array;
@@ -61,10 +74,10 @@ struct link_group_table *new_link_group_table(u64 capacity)
                FREE(table);
                goto err;
        }
-       table->num_entries = 0;
-       table->capacity = capacity;
-       table->array = array;
-       table->singles = NULL;
+       table->num_entries  = 0;
+       table->capacity     = capacity;
+       table->array        = array;
+       table->extra_groups = NULL;
        return table;
 err:
        ERROR("Failed to allocate memory for link group table with capacity %zu",
@@ -93,15 +106,15 @@ int link_group_table_insert(struct dentry *dentry, void *__table)
        struct link_group *group;
 
        if (dentry->hard_link == 0) {
-               /* Single group--- Add to the singles list (we can't put it in
-                * the table itself because all the singles have a link group ID
-                * of 0) */
+               /* Single group--- Add to the list of extra groups (we can't put
+                * it in the table itself because all the singles have a link
+                * group ID of 0) */
                group = MALLOC(sizeof(struct link_group));
                if (!group)
                        return WIMLIB_ERR_NOMEM;
                group->link_group_id = 0;
-               group->next          = table->singles;
-               table->singles       = group;
+               group->next          = table->extra_groups;
+               table->extra_groups  = group;
                INIT_LIST_HEAD(&dentry->link_group_list);
                group->dentry_list = &dentry->link_group_list;
        } else {
@@ -139,6 +152,16 @@ int link_group_table_insert(struct dentry *dentry, void *__table)
        return 0;
 }
 
+static void free_link_group_list(struct link_group *group)
+{
+       struct link_group *next_group;
+       while (group) {
+               next_group = group->next;
+               FREE(group);
+               group = next_group;
+       }
+}
+
 /* Frees a link group table. */
 void free_link_group_table(struct link_group_table *table)
 {
@@ -146,83 +169,334 @@ void free_link_group_table(struct link_group_table *table)
 
        if (!table)
                return;
-       if (table->array) {
-               for (u64 i = 0; i < table->capacity; i++) {
-                       struct link_group *group = table->array[i];
-                       struct link_group *next;
-                       while (group) {
-                               next = group->next;
-                               FREE(group);
-                               group = next;
-                       }
-               }
-               FREE(table->array);
-       }
-       single = table->singles;
-       while (single) {
-               next = single->next;
-               FREE(single);
-               single = next;
-       }
+       if (table->array)
+               for (size_t i = 0; i < table->capacity; i++)
+                       free_link_group_list(table->array[i]);
+       free_link_group_list(table->extra_groups);
 
        FREE(table);
 }
 
+u64 assign_link_group_ids_to_list(struct link_group *group, u64 id)
+{
+       struct dentry *dentry;
+       struct list_head *cur;
+       while (group) {
+               cur = group->dentry_list;
+               do {
+                       dentry = container_of(cur,
+                                             struct dentry,
+                                             link_group_list);
+                       dentry->hard_link = id;
+                       cur = cur->next;
+               } while (cur != group->dentry_list);
+               group->link_group_id = id;
+               id++;
+               group = group->next;
+       }
+       return id;
+}
+
+/* Insert the link groups in the `extra_groups' list into the hash table */
+static void insert_extra_groups(struct link_group_table *table)
+{
+       struct link_group *group, *next_group;
+       size_t pos;
+
+       group = table->extra_groups;
+       while (group) {
+               next_group = group->next;
+               pos = group->link_group_id % table->capacity;
+               group->next = table->array[pos];
+               table->array[pos] = group;
+               group = next_group;
+       }
+       table->extra_groups = NULL;
+}
+
 /* Assign the link group IDs to dentries in a link group table, and return the
  * next available link group ID. */
-u64 assign_link_groups(struct link_group_table *table)
+u64 assign_link_group_ids(struct link_group_table *table)
 {
        DEBUG("Assigning link groups");
 
        /* Assign consecutive link group IDs to each link group in the hash
         * table */
        u64 id = 1;
-       for (u64 i = 0; i < table->capacity; i++) {
-               struct link_group *group = table->array[i];
-               struct link_group *next_group;
-               struct dentry *dentry;
-               struct list_head *cur;
-               while (group) {
-                       cur = group->dentry_list;
-                       do {
-                               dentry = container_of(cur,
-                                                     struct dentry,
-                                                     link_group_list);
-                               dentry->hard_link = id;
-                               cur = cur->next;
-                       } while (cur != group->dentry_list);
-                       id++;
-                       group = group->next;
-               }
+       for (size_t i = 0; i < table->capacity; i++)
+               id = assign_link_group_ids_to_list(table->array[i], id);
+
+       /* Assign link group IDs to the "extra" link groups and insert them into
+        * the hash table */
+       id = assign_link_group_ids_to_list(table->extra_groups, id);
+       insert_extra_groups(table);
+       return id;
+}
+
+
+
+static void inconsistent_link_group(const struct dentry *first_dentry)
+{
+       const struct dentry *dentry = first_dentry;
+
+       ERROR("An inconsistent hard link group that we cannot correct has been "
+             "detected");
+       ERROR("The dentries are located at the following paths:");
+       do {
+               ERROR("`%s'", dentry->full_path_utf8);
+       } while ((dentry = container_of(dentry->link_group_list.next,
+                                       struct dentry,
+                                       link_group_list)) != first_dentry);
+}
+
+static bool ref_dentries_consistent(const struct dentry * restrict ref_dentry_1,
+                                   const struct dentry * restrict ref_dentry_2)
+{
+       wimlib_assert(ref_dentry_1 != ref_dentry_2);
+
+       if (ref_dentry_1->num_ads != ref_dentry_2->num_ads)
+               return false;
+       if (ref_dentry_1->security_id != ref_dentry_2->security_id
+           || ref_dentry_1->attributes != ref_dentry_2->attributes)
+               return false;
+       for (unsigned i = 0; i <= ref_dentry_1->num_ads; i++) {
+               const u8 *ref_1_hash, *ref_2_hash;
+               ref_1_hash = dentry_stream_hash_unresolved(ref_dentry_1, i);
+               ref_2_hash = dentry_stream_hash_unresolved(ref_dentry_2, i);
+               if (!hashes_equal(ref_1_hash, ref_2_hash))
+                       return false;
+               if (i && !ads_entries_have_same_name(&ref_dentry_1->ads_entries[i - 1],
+                                                    &ref_dentry_2->ads_entries[i - 1]))
+                       return false;
+
        }
-       /* Assign link group IDs to the link groups that previously had link
-        * group IDs of 0, and insert them into the hash table */
-       struct link_group *single = table->singles;
-       while (single) {
-               struct dentry *dentry;
-               struct link_group *next_single;
-               size_t pos;
+       return true;
+}
+
+static bool dentries_consistent(const struct dentry * restrict ref_dentry,
+                               const struct dentry * restrict dentry)
+{
+       wimlib_assert(ref_dentry != dentry);
+
+       if (ref_dentry->num_ads != dentry->num_ads && dentry->num_ads != 0)
+               return false;
+       if (ref_dentry->security_id != dentry->security_id
+           || ref_dentry->attributes != dentry->attributes)
+               return false;
+       for (unsigned i = 0; i <= min(ref_dentry->num_ads, dentry->num_ads); i++) {
+               const u8 *ref_hash, *hash;
+               ref_hash = dentry_stream_hash_unresolved(ref_dentry, i);
+               hash = dentry_stream_hash_unresolved(dentry, i);
+               if (!hashes_equal(ref_hash, hash) && !is_zero_hash(hash))
+                       return false;
+               if (i && !ads_entries_have_same_name(&ref_dentry->ads_entries[i - 1],
+                                                    &dentry->ads_entries[i - 1]))
+                       return false;
+       }
+       return true;
+}
+
+static int
+fix_true_link_group(struct dentry *first_dentry)
+{
+       struct dentry *dentry;
+       struct dentry *ref_dentry = NULL;
+       u64 last_ctime = 0;
+       u64 last_mtime = 0;
+       u64 last_atime = 0;
+
+       dentry = first_dentry;
+       do {
+               if (!ref_dentry || ref_dentry->num_ads == 0)
+                       ref_dentry = dentry;
+               if (dentry->creation_time > last_ctime)
+                       last_ctime = dentry->creation_time;
+               if (dentry->last_write_time > last_mtime)
+                       last_mtime = dentry->last_write_time;
+               if (dentry->last_access_time > last_atime)
+                       last_atime = dentry->last_access_time;
+       } while ((dentry = container_of(dentry->link_group_list.next,
+                                       struct dentry,
+                                       link_group_list)) != first_dentry);
+
+
+       ref_dentry->ads_entries_status = ADS_ENTRIES_OWNER;
+       dentry = first_dentry;
+       do {
+               if (dentry != ref_dentry) {
+                       if (!dentries_consistent(ref_dentry, dentry)) {
+                               inconsistent_link_group(first_dentry);
+                               return WIMLIB_ERR_INVALID_DENTRY;
+                       }
+                       copy_hash(dentry->hash, ref_dentry->hash);
+                       dentry_free_ads_entries(dentry);
+                       dentry->num_ads            = ref_dentry->num_ads;
+                       dentry->ads_entries        = ref_dentry->ads_entries;
+                       dentry->ads_entries_status = ADS_ENTRIES_USER;
+               }
+               dentry->creation_time    = last_ctime;
+               dentry->last_write_time  = last_mtime;
+               dentry->last_access_time = last_atime;
+       } while ((dentry = container_of(dentry->link_group_list.next,
+                                       struct dentry,
+                                       link_group_list)) != first_dentry);
+       return 0;
+}
 
-               next_single = single->next;
+static int
+fix_nominal_link_group(struct link_group *group,
+                      struct link_group **new_groups)
+{
+       struct dentry *tmp, *dentry, *ref_dentry;
+       int ret;
+       size_t num_true_link_groups;
+       struct list_head *head;
+       u64 link_group_id;
+
+       LIST_HEAD(dentries_with_data_streams);
+       LIST_HEAD(dentries_with_no_data_streams);
+       LIST_HEAD(true_link_groups);
 
-               dentry = container_of(single->dentry_list, struct dentry,
+       /* Create the lists @dentries_with_data_streams and
+        * @dentries_with_no_data_streams. */
+       dentry = container_of(group->dentry_list, struct dentry,
+                             link_group_list);
+       do {
+               for (unsigned i = 0; i <= dentry->num_ads; i++) {
+                       const u8 *hash;
+                       hash = dentry_stream_hash_unresolved(dentry, i);
+                       if (!is_zero_hash(hash)) {
+                               list_add(&dentry->tmp_list,
+                                        &dentries_with_data_streams);
+                               goto next_dentry;
+                       }
+               }
+               list_add(&dentry->tmp_list,
+                        &dentries_with_no_data_streams);
+       next_dentry:
+               dentry = container_of(dentry->link_group_list.next,
+                                     struct dentry,
                                      link_group_list);
-               dentry->hard_link = id;
+       } while (&dentry->link_group_list != group->dentry_list);
 
-               pos = id % table->capacity;
-               single->next = table->array[pos];
-               table->array[pos] = single;
+       /* If there are no dentries with data streams, we require the nominal
+        * link group to be a true link group */
+       if (list_empty(&dentries_with_data_streams))
+               return fix_true_link_group(container_of(group->dentry_list,
+                                                       struct dentry,
+                                                       link_group_list));
 
-               single = next_single;
-               id++;
+       /* One or more dentries had data streams.  We check each of these
+        * dentries for consistency with the others to form a set of true link
+        * groups. */
+       num_true_link_groups = 0;
+       list_for_each_entry_safe(dentry, tmp, &dentries_with_data_streams,
+                                tmp_list)
+       {
+               list_del(&dentry->tmp_list);
+
+               /* Look for a true link group that is consistent with
+                * this dentry and add this dentry to it.  Or, if none
+                * of the true link groups are consistent with this
+                * dentry, make a new one. */
+               list_for_each_entry(ref_dentry, &true_link_groups, tmp_list) {
+                       if (ref_dentries_consistent(ref_dentry, dentry)) {
+                               list_add(&dentry->link_group_list,
+                                        &ref_dentry->link_group_list);
+                               goto next_dentry_2;
+                       }
+               }
+               num_true_link_groups++;
+               list_add(&dentry->tmp_list, &true_link_groups);
+               INIT_LIST_HEAD(&dentry->link_group_list);
+next_dentry_2:
+               ;
        }
-       table->singles = NULL;
-       return id;
+
+       wimlib_assert(num_true_link_groups != 0);
+
+       /* If there were dentries with no data streams, we require there to only
+        * be one true link group so that we know which link group to assign the
+        *
+        * streamless dentries to. */
+       if (!list_empty(&dentries_with_no_data_streams)) {
+               if (num_true_link_groups != 1) {
+                       ERROR("Hard link group ambiguity detected!");
+                       ERROR("We split up hard link group 0x%"PRIx64" due to "
+                             "inconsistencies,");
+                       ERROR("but dentries with no stream information remained. "
+                             "We don't know which true hard link");
+                       ERROR("group to assign them to.");
+                       return WIMLIB_ERR_INVALID_DENTRY;
+               }
+               ref_dentry = container_of(true_link_groups.next,
+                                         struct dentry,
+                                         tmp_list);
+               list_for_each_entry(dentry, &dentries_with_no_data_streams,
+                                   tmp_list)
+               {
+                       list_add(&dentry->link_group_list,
+                                &ref_dentry->link_group_list);
+               }
+       }
+
+       list_for_each_entry(dentry, &true_link_groups, tmp_list) {
+               ret = fix_true_link_group(dentry);
+               if (ret != 0)
+                       return ret;
+       }
+
+       /* Make new `struct link_group's for the new link groups */
+       for (head = true_link_groups.next->next;
+            head != &true_link_groups;
+            head = head->next)
+       {
+               dentry = container_of(head, struct dentry, tmp_list);
+               group = MALLOC(sizeof(*group));
+               if (!group) {
+                       ERROR("Out of memory");
+                       return WIMLIB_ERR_NOMEM;
+               }
+               group->link_group_id = link_group_id;
+               group->dentry_list = &dentry->link_group_list;
+               group->next = *new_groups;
+               *new_groups = group;
+       } while ((head = head->next) != &true_link_groups);
+       return 0;
+}
+
+/*
+ * Goes through each link group and shares the ads_entries (Alternate Data
+ * Stream entries) field of each dentry between members of a hard link group.
+ *
+ * In the process, the dentries in each link group are checked for consistency.
+ * If they contain data features that indicate they cannot really be in the same
+ * hard link group, this should be an error, but in reality this case needs to
+ * be handled, so we split the dentries into different hard link groups.
+ *
+ * One of the dentries in the group is arbitrarily assigned the role of "owner"
+ * (ADS_ENTRIES_OWNER), while the others are "users" (ADS_ENTRIES_USER).
+ */
+int fix_link_groups(struct link_group_table *table)
+{
+       for (u64 i = 0; i < table->capacity; i++) {
+               struct link_group *group = table->array[i];
+               while (group) {
+                       int ret;
+                       ret = fix_nominal_link_group(group, &table->extra_groups);
+                       if (ret != 0)
+                               return ret;
+                       group = group->next;
+               }
+       }
+       return 0;
 }
 
+#if 0
 static bool dentries_have_same_ads(const struct dentry *d1,
                                   const struct dentry *d2)
 {
+       wimlib_assert(d1->num_ads == d2->num_ads);
        /* Verify stream names and hashes are the same */
        for (u16 i = 0; i < d1->num_ads; i++) {
                if (strcmp(d1->ads_entries[i].stream_name_utf8,
@@ -291,6 +565,10 @@ static int share_dentry_ads(struct dentry *owner, struct dentry *user)
                        goto mismatch;
                }
        }
+       if (owner->last_access_time != user->last_access_time
+           || owner->last_write_time != user->last_write_time
+           || owner->creation_time != user->creation_time) {
+       }
        dentry_free_ads_entries(user);
        user->ads_entries = owner->ads_entries;
        user->ads_entries_status = ADS_ENTRIES_USER;
@@ -302,82 +580,4 @@ mismatch:
                mismatch_type);
        return WIMLIB_ERR_INVALID_DENTRY;
 }
-
-static int link_group_free_duplicate_data(struct link_group *group,
-                                         struct link_group **bad_links)
-{
-       struct dentry *owner, *user, *tmp;
-
-       /* Find a dentry with non-zero hash to use as a possible link group
-        * owner (see comments above the share_dentry_ads() function */
-       owner = container_of(group->dentry_list, struct dentry,
-                             link_group_list);
-       do {
-               /* imagex.exe may move the un-named data stream from the dentry
-                * itself to the first alternate data stream, if there are
-                * other alternate data streams */
-               if (!is_zero_hash(owner->hash) ||
-                   (owner->num_ads && !is_zero_hash(owner->ads_entries[0].hash)))
-                       goto found_owner;
-               owner = container_of(owner->link_group_list.next,
-                                    struct dentry,
-                                    link_group_list);
-       } while (&owner->link_group_list != group->dentry_list);
-
-       ERROR("Could not find owner of data streams in hard link group");
-       return WIMLIB_ERR_INVALID_DENTRY;
-found_owner:
-       owner->ads_entries_status = ADS_ENTRIES_OWNER;
-       list_for_each_entry_safe(user, tmp, &owner->link_group_list,
-                                link_group_list)
-       {
-               /* I would like it to be an error if two dentries are in the
-                * same hard link group but have irreconcilable differences such
-                * as different file permissions, but unfortunately some of M$'s
-                * WIMs contain many instances of this error.  This problem is
-                * worked around here by splitting each offending dentry off
-                * into its own hard link group. */
-               if (share_dentry_ads(owner, user) != 0) {
-                       struct link_group *single;
-                       single = MALLOC(sizeof(struct link_group));
-                       if (!single)
-                               return WIMLIB_ERR_NOMEM;
-                       list_del(&user->link_group_list);
-                       INIT_LIST_HEAD(&user->link_group_list);
-                       single->link_group_id = 0;
-                       single->next          = *bad_links;
-                       single->dentry_list   = &user->link_group_list;
-                       *bad_links            = single;
-                       user->ads_entries_status = ADS_ENTRIES_OWNER;
-               }
-       }
-       return 0;
-}
-
-/*
- * Goes through each link group and shares the ads_entries (Alternate Data
- * Stream entries) field of each dentry between members of a hard link group.
- *
- * In the process, the dentries in each link group are checked for consistency.
- * If they contain data features that indicate they cannot really be in the same
- * hard link group, this should be an error, but in reality this case needs to
- * be handled, so we split the dentries into different hard link groups.
- *
- * One of the dentries in the group is arbitrarily assigned the role of "owner"
- * (ADS_ENTRIES_OWNER), while the others are "users" (ADS_ENTRIES_USER).
- */
-int link_groups_free_duplicate_data(struct link_group_table *table)
-{
-       for (u64 i = 0; i < table->capacity; i++) {
-               struct link_group *group = table->array[i];
-               while (group) {
-                       int ret;
-                       ret = link_group_free_duplicate_data(group,
-                                                            &table->singles);
-                       if (ret != 0)
-                               return ret;
-                       group = group->next;
-               }
-       }
-       return 0;
-}
+#endif
index ff6e106..c979162 100644 (file)
@@ -745,6 +745,7 @@ int do_add_image(WIMStruct *w, const char *dir, const char *name,
        struct image_metadata *imd;
        struct wim_security_data *sd;
        struct capture_config config;
+       struct link_group_table *lgt;
        int ret;
 
        DEBUG("Adding dentry tree from dir `%s'.", dir);
@@ -803,13 +804,20 @@ int do_add_image(WIMStruct *w, const char *dir, const char *name,
        if (ret != 0)
                goto out_free_dentry_tree;
 
+       lgt = w->image_metadata[w->hdr.image_count - 1].lgt;
        DEBUG("Inserting dentries into hard link group table");
-       ret = for_dentry_in_tree(root_dentry, link_group_table_insert, 
-                                w->image_metadata[w->hdr.image_count - 1].lgt);
+       ret = for_dentry_in_tree(root_dentry, link_group_table_insert, lgt);
+                                
        if (ret != 0)
                goto out_destroy_imd;
-       DEBUG("Assigning hard link groups");
-       assign_link_groups(w->image_metadata[w->hdr.image_count - 1].lgt);
+
+       DEBUG("Cleanup up the hard link groups");
+       ret = fix_link_groups(lgt);
+       if (ret != 0)
+               goto out_destroy_imd;
+
+       DEBUG("Assigning hard link group IDs");
+       assign_link_group_ids(w->image_metadata[w->hdr.image_count - 1].lgt);
 
        if (flags & WIMLIB_ADD_IMAGE_FLAG_BOOT)
                wimlib_set_boot_idx(w, w->hdr.image_count);
index f6c178b..9385b52 100644 (file)
@@ -1829,7 +1829,7 @@ WIMLIBAPI int wimlib_mount(WIMStruct *wim, int image, const char *dir,
 
        DEBUG("Selected image %d", image);
 
-       next_link_group_id = assign_link_groups(wim->image_metadata[image - 1].lgt);
+       next_link_group_id = assign_link_group_ids(wim->image_metadata[image - 1].lgt);
 
        /* Resolve all the lookup table entries of the dentry tree */
        for_dentry_in_tree(wim_root_dentry(wim), dentry_resolve_ltes,
index 43caec0..1a2b496 100644 (file)
@@ -360,13 +360,13 @@ struct readdir_ctx {
        ntfs_volume        **ntfs_vol_p;
 };
 
-static int __build_dentry_tree_ntfs(struct dentry **root_p, ntfs_inode *ni,
-                                   char path[], size_t path_len,
-                                   struct lookup_table *lookup_table,
-                                   struct sd_set *sd_set,
-                                   const struct capture_config *config,
-                                   ntfs_volume **ntfs_vol_p);
-
+static int
+build_dentry_tree_ntfs_recursive(struct dentry **root_p, ntfs_inode *ni,
+                                char path[], size_t path_len,
+                                struct lookup_table *lookup_table,
+                                struct sd_set *sd_set,
+                                const struct capture_config *config,
+                                ntfs_volume **ntfs_vol_p);
 
 static int wim_ntfs_capture_filldir(void *dirent, const ntfschar *name,
                                    const int name_len, const int name_type,
@@ -412,9 +412,9 @@ static int wim_ntfs_capture_filldir(void *dirent, const ntfschar *name,
                ctx->path[path_len++] = '/';
        memcpy(ctx->path + path_len, utf8_name, utf8_name_len + 1);
        path_len += utf8_name_len;
-       ret = __build_dentry_tree_ntfs(&child, ni, ctx->path, path_len,
-                                      ctx->lookup_table, ctx->sd_set,
-                                      ctx->config, ctx->ntfs_vol_p);
+       ret = build_dentry_tree_ntfs_recursive(&child, ni, ctx->path, path_len,
+                                              ctx->lookup_table, ctx->sd_set,
+                                              ctx->config, ctx->ntfs_vol_p);
 
        if (child) {
                DEBUG("Linking dentry `%s' with parent `%s'",
@@ -433,12 +433,13 @@ out:
  * At the same time, update the WIM lookup table with lookup table entries for
  * the NTFS streams, and build an array of security descriptors.
  */
-static int __build_dentry_tree_ntfs(struct dentry **root_p, ntfs_inode *ni,
-                                   char path[], size_t path_len,
-                                   struct lookup_table *lookup_table,
-                                   struct sd_set *sd_set,
-                                   const struct capture_config *config,
-                                   ntfs_volume **ntfs_vol_p)
+static int build_dentry_tree_ntfs_recursive(struct dentry **root_p,
+                                           ntfs_inode *ni,
+                                           char path[], size_t path_len,
+                                           struct lookup_table *lookup_table,
+                                           struct sd_set *sd_set,
+                                           const struct capture_config *config,
+                                           ntfs_volume **ntfs_vol_p)
 {
        u32 attributes;
        int mrec_flags;
@@ -465,8 +466,8 @@ static int __build_dentry_tree_ntfs(struct dentry **root_p, ntfs_inode *ni,
        root->last_access_time = le64_to_cpu(ni->last_access_time);
        root->security_id      = le32_to_cpu(ni->security_id);
        root->attributes       = le32_to_cpu(attributes);
-       root->hard_link  = ni->mft_no;
-       root->resolved = true;
+       root->hard_link        = ni->mft_no;
+       root->resolved         = true;
 
        if (attributes & FILE_ATTR_REPARSE_POINT) {
                DEBUG("Reparse point `%s'", path);
@@ -571,12 +572,18 @@ static int build_dentry_tree_ntfs(struct dentry **root_p,
                ret = WIMLIB_ERR_NTFS_3G;
                goto out;
        }
-       char path[4096];
+       char *path = MALLOC(32769);
+       if (!path) {
+               ERROR("Could not allocate memory for NTFS pathname");
+               goto out_cleanup;
+       }
        path[0] = '/';
        path[1] = '\0';
-       ret = __build_dentry_tree_ntfs(root_p, root_ni, path, 1,
-                                      lookup_table, &sd_set, config,
-                                      ntfs_vol_p);
+       ret = build_dentry_tree_ntfs_recursive(root_p, root_ni, path, 1,
+                                              lookup_table, &sd_set,
+                                              config, ntfs_vol_p);
+out_cleanup:
+       FREE(path);
        ntfs_inode_close(root_ni);
        destroy_sd_set(&sd_set);
 
index 0e55725..aaa0dac 100644 (file)
@@ -1200,8 +1200,8 @@ int read_metadata_resource(WIMStruct *w, struct image_metadata *imd)
        if (ret != 0)
                goto out_free_lgt;
 
-       DEBUG("Freeing duplicate ADS entries in link group table");
-       ret = link_groups_free_duplicate_data(lgt);
+       DEBUG("Fixing inconsistencies in the link groups");
+       ret = fix_link_groups(lgt);
        if (ret != 0)
                goto out_free_lgt;
 
index c89d733..086765e 100644 (file)
@@ -335,12 +335,12 @@ struct capture_config {
 
 /* hardlink.c */
 
-struct link_group_table *new_link_group_table(u64 capacity);
+struct link_group_table *new_link_group_table(size_t capacity);
 int link_group_table_insert(struct dentry *dentry,
                            void *__table);
 void free_link_group_table(struct link_group_table *table);
-u64 assign_link_groups(struct link_group_table *table);
-int link_groups_free_duplicate_data(struct link_group_table *table);
+u64 assign_link_group_ids(struct link_group_table *table);
+int fix_link_groups(struct link_group_table *table);
 
 
 /* header.c */