* 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/.
*/
return NULL;
}
-struct lookup_table_entry *new_lookup_table_entry(WIMStruct *wim)
+struct lookup_table_entry *new_lookup_table_entry()
{
struct lookup_table_entry *lte;
lte->part_number = 1;
lte->refcnt = 1;
- lte->wim = wim;
INIT_LIST_HEAD(<e->lte_group_list);
return lte;
}
void free_lookup_table_entry(struct lookup_table_entry *lte)
{
if (lte) {
+#ifdef WITH_FUSE
if (lte->staging_list.next)
list_del(<e->staging_list);
- if (lte->resource_location != RESOURCE_IN_WIM &&
- lte->resource_location != RESOURCE_NONEXISTENT)
+#endif
+ switch (lte->resource_location) {
+ case RESOURCE_IN_STAGING_FILE:
+ case RESOURCE_IN_ATTACHED_BUFFER:
+ case RESOURCE_IN_FILE_ON_DISK:
+ wimlib_assert(((void*)<e->file_on_disk ==
+ (void*)<e->staging_file_name)
+ && ((void*)<e->file_on_disk ==
+ (void*)<e->attached_buffer));
FREE(lte->file_on_disk);
+ break;
+#ifdef WITH_NTFS_3G
+ case RESOURCE_IN_NTFS_VOLUME:
+ if (lte->ntfs_loc) {
+ FREE(lte->ntfs_loc->path_utf8);
+ FREE(lte->ntfs_loc->stream_name_utf16);
+ FREE(lte->ntfs_loc);
+ }
+ break;
+#endif
+ default:
+ break;
+ }
FREE(lte);
}
}
void free_lookup_table(struct lookup_table *table)
{
- DEBUG("Freeing lookup table");
+ DEBUG2("Freeing lookup table");
if (table) {
if (table->array) {
for_lookup_table_entry(table,
wimlib_assert(lte->refcnt);
if (--lte->refcnt == 0) {
lookup_table_unlink(table, lte);
- if (lte->num_opened_fds == 0) {
+ #ifdef WITH_FUSE
+ if (lte->num_opened_fds == 0)
+ #endif
+ {
free_lookup_table_entry(lte);
lte = NULL;
}
u8 buf[WIM_LOOKUP_TABLE_ENTRY_DISK_SIZE];
int ret;
struct lookup_table *table;
+ struct lookup_table_entry *cur_entry = NULL, *duplicate_entry;
DEBUG("Reading lookup table: offset %"PRIu64", size %"PRIu64"",
w->hdr.lookup_table_res_entry.offset,
while (num_entries--) {
const u8 *p;
- struct lookup_table_entry *cur_entry, *duplicate_entry;
if (fread(buf, 1, sizeof(buf), w->fp) != sizeof(buf)) {
if (feof(w->fp)) {
ret = WIMLIB_ERR_READ;
goto out;
}
- cur_entry = new_lookup_table_entry(w);
+ cur_entry = new_lookup_table_entry();
if (!cur_entry) {
ret = WIMLIB_ERR_NOMEM;
goto out;
p = get_u32(p, &cur_entry->refcnt);
p = get_bytes(p, SHA1_HASH_SIZE, cur_entry->hash);
+ if (cur_entry->part_number != w->hdr.part_number) {
+ ERROR("A lookup table entry in part %hu of the WIM "
+ "points to part %hu",
+ 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)) {
+ ERROR("The WIM lookup table contains an entry with a "
+ "SHA1 message digest of all 0's");
+ ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
+ goto out_free_cur_entry;
+ }
+
duplicate_entry = __lookup_resource(table, cur_entry->hash);
if (duplicate_entry) {
ERROR("The WIM lookup table contains two entries with the "
ERROR("The second entry is:");
print_lookup_table_entry(cur_entry);
ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
- goto out;
+ goto out_free_cur_entry;
}
- lookup_table_insert(table, cur_entry);
if (!(cur_entry->resource_entry.flags & WIM_RESHDR_FLAG_COMPRESSED)
&& (cur_entry->resource_entry.size !=
ERROR("The lookup table entry for the resource is as follows:");
print_lookup_table_entry(cur_entry);
ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
- goto out;
+ goto out_free_cur_entry;
}
+ lookup_table_insert(table, cur_entry);
+
}
DEBUG("Done reading lookup table.");
w->lookup_table = table;
return 0;
+out_free_cur_entry:
+ FREE(cur_entry);
out:
free_lookup_table(table);
return ret;
out = __out;
- /* do not write lookup table entries for empty files */
- if (lte->output_resource_entry.original_size == 0)
- return 0;
-
/* Don't write entries that have not had file resources or metadata
* resources written for them. */
if (lte->out_refcnt == 0)
case RESOURCE_IN_STAGING_FILE:
printf("Staging File = `%s'\n", lte->staging_file_name);
break;
+ default:
+ break;
}
putchar('\n');
}
struct dentry *dentry;
struct lookup_table_entry *lte;
unsigned stream_idx;
- const char *stream_name;
+ const char *stream_name = NULL;
char *p = NULL;
if (lookup_flags & LOOKUP_FLAG_ADS_OK) {
return 0;
}
+/* Return the lookup table entry for the unnamed data stream of a dentry, or
+ * NULL if there is none.
+ *
+ * You'd think this would be easier than it actually is, since the unnamed data
+ * stream should be the one referenced from the dentry itself. Alas, if there
+ * are named data streams, Microsoft's "imagex.exe" program will put the unnamed
+ * data stream in one of the alternate data streams instead of inside the
+ * dentry. So we need to check the alternate data streams too.
+ *
+ * Also, note that a dentry may appear to have than one unnamed stream, but if
+ * the SHA1 message digest is all 0's then the corresponding stream does not
+ * really "count" (this is the case for the dentry's own file stream when the
+ * file stream that should be there is actually in one of the alternate stream
+ * entries.). This is despite the fact that we may need to extract such a
+ * missing entry as an empty file or empty named data stream.
+ */
struct lookup_table_entry *
-dentry_first_lte(const struct dentry *dentry, const struct lookup_table *table)
+dentry_unnamed_lte(const struct dentry *dentry,
+ const struct lookup_table *table)
{
if (dentry->resolved)
- return dentry_first_lte_resolved(dentry);
+ return dentry_unnamed_lte_resolved(dentry);
else
- return dentry_first_lte_unresolved(dentry, table);
+ return dentry_unnamed_lte_unresolved(dentry, table);
}