* This file is part of wimlib, a library for working with WIM files.
*
* wimlib is free software; you can redistribute it and/or modify it under the
- * terms of the GNU Lesser General Public License as published by the Free
- * Software Foundation; either version 2.1 of the License, or (at your option)
+ * terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 3 of the License, or (at your option)
* any later version.
*
* wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
* along with wimlib; if not, see http://www.gnu.org/licenses/.
*/
/* Frees a link group table. */
void free_link_group_table(struct link_group_table *table)
{
- struct link_group *single, *next;
-
if (table) {
if (table->array)
for (size_t i = 0; i < table->capacity; i++)
}
}
-u64 assign_link_group_ids_to_list(struct link_group *group, u64 id,
- struct link_group **extra_groups)
+static u64
+assign_link_group_ids_to_list(struct link_group *group, u64 id,
+ struct link_group **extra_groups)
{
struct dentry *dentry;
struct list_head *cur_head;
static void
print_dentry_list(const struct dentry *first_dentry)
{
- const struct dentry *dentry;
+ const struct dentry *dentry = first_dentry;
do {
printf("`%s'\n", dentry->full_path_utf8);
} while ((dentry = container_of(dentry->link_group_list.next,
u64 last_ctime = 0;
u64 last_mtime = 0;
u64 last_atime = 0;
+ bool found_short_name = false;
dentry = first_dentry;
do {
if (!ref_dentry || ref_dentry->num_ads == 0)
ref_dentry = dentry;
+ if (dentry->short_name_len) {
+ if (found_short_name) {
+ ERROR("Multiple short names in hard link "
+ "group!");
+ inconsistent_link_group(first_dentry);
+ return WIMLIB_ERR_INVALID_DENTRY;
+ } else {
+ found_short_name = true;
+ }
+ }
if (dentry->creation_time > last_ctime)
last_ctime = dentry->creation_time;
if (dentry->last_write_time > last_mtime)
* the same hard link group ID.
*
* If dentries in the group are found to be inconsistent, we may split the group
- * into several groups. @new_groups points to a linked list of these "extra"
- * groups, and if we create any, they will be added to this list.
+ * into several "true" hard link groups. @new_groups points to a linked list of
+ * these split groups, and if we create any, they will be added to this list.
*
* After splitting up each nominal link group into the "true" link groups we
* will canonicalize the link groups. To do this, we:
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);
* link group to be a true link group */
if (list_empty(&dentries_with_data_streams)) {
#ifdef ENABLE_DEBUG
-
+ {
+ size_t size = dentry_link_group_size(dentry);
+ if (size > 1) {
+ DEBUG("Found link group of size %zu without "
+ "any data streams:", size);
+ print_dentry_list(dentry);
+ DEBUG("We are going to interpret it as true "
+ "link group, provided that the dentries "
+ "are consistent.");
+ }
+ }
#endif
return fix_true_link_group(container_of(group->dentry_list,
struct dentry,
ERROR("group to assign them to.");
return WIMLIB_ERR_INVALID_DENTRY;
}
+ /* Assign the streamless dentries to the one and only true link
+ * group. */
ref_dentry = container_of(true_link_groups.next,
struct dentry,
tmp_list);
- list_splice(&dentries_with_no_data_streams,
- &ref_dentry->link_group_list);
+ list_for_each_entry(dentry, &dentries_with_no_data_streams, tmp_list)
+ list_add(&dentry->link_group_list, &ref_dentry->link_group_list);
}
if (num_true_link_groups != 1) {
- WARNING("Split nominal link group 0x%"PRIx64" into %zu "
- "link groups",
- group->link_group_id, num_true_link_groups);
+ #ifdef ENABLE_DEBUG
+ {
+ printf("Split nominal link group 0x%"PRIx64" into %zu "
+ "link groups:\n",
+ group->link_group_id, num_true_link_groups);
+ puts("------------------------------------------------------------------------------");
+ size_t i = 1;
+ list_for_each_entry(dentry, &true_link_groups, tmp_list) {
+ printf("[Split link group %zu]\n", i++);
+ print_dentry_list(dentry);
+ putchar('\n');
+ }
+ puts("------------------------------------------------------------------------------");
+ }
+ #endif
}
list_for_each_entry(dentry, &true_link_groups, tmp_list) {
ERROR("Out of memory");
return WIMLIB_ERR_NOMEM;
}
- group->link_group_id = link_group_id;
+ group->link_group_id = dentry->link_group_id;
group->dentry_list = &dentry->link_group_list;
group->next = *new_groups;
*new_groups = group;
/*
* 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.
+ * Stream entries) field of each dentry among 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).
+ * One of the dentries in each hard link group group is arbitrarily assigned the
+ * role of "owner" of the memory pointed to by the @ads_entries field,
+ * (ADS_ENTRIES_OWNER), while the others are "users" (ADS_ENTRIES_USER) who are
+ * not allowed to free the memory.
*/
int fix_link_groups(struct link_group_table *table)
{