X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Flookup_table.c;h=6ad8872f37c579bdebb1782c04066d448939f53a;hp=46ab456198dba57caf6a88b77e73caa1953343bd;hb=2a7e6a7d014689899c90a926a095a53753488967;hpb=751a849fe04a9230a661e38429ff4d971f74bdbf diff --git a/src/lookup_table.c b/src/lookup_table.c index 46ab4561..6ad8872f 100644 --- a/src/lookup_table.c +++ b/src/lookup_table.c @@ -3,23 +3,25 @@ * * Lookup table, implemented as a hash table, that maps dentries to file * resources. - * + */ + +/* * Copyright (C) 2012 Eric Biggers * - * wimlib - Library for working with WIM files + * This file is part of wimlib, a library for working with WIM files. * - * This library 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) any - * later version. + * 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) + * any later version. * - * This library 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 details. + * 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 + * details. * - * You should have received a copy of the GNU Lesser General Public License along - * with this library; if not, write to the Free Software Foundation, Inc., 59 - * Temple Place, Suite 330, Boston, MA 02111-1307 USA + * You should have received a copy of the GNU Lesser General Public License + * along with wimlib; if not, see http://www.gnu.org/licenses/. */ #include "wimlib_internal.h" @@ -31,7 +33,7 @@ struct lookup_table *new_lookup_table(size_t capacity) struct lookup_table *table; struct lookup_table_entry **array; - table = CALLOC(1, sizeof(struct lookup_table)); + table = MALLOC(sizeof(struct lookup_table)); if (!table) goto err; array = CALLOC(capacity, sizeof(array[0])); @@ -44,8 +46,8 @@ struct lookup_table *new_lookup_table(size_t capacity) table->array = array; return table; err: - ERROR("Failed to allocate memory for lookup table with capacity " - "%zu\n", capacity); + ERROR("Failed to allocate memory for lookup table with capacity %zu", + capacity); return NULL; } @@ -53,20 +55,16 @@ struct lookup_table_entry *new_lookup_table_entry() { struct lookup_table_entry *lte; - lte = MALLOC(sizeof(struct lookup_table_entry)); + lte = CALLOC(1, sizeof(struct lookup_table_entry)); if (!lte) { ERROR("Out of memory (tried to allocate %zu bytes for " - "lookup table entry)\n", - sizeof(struct lookup_table_entry)); + "lookup table entry)", + sizeof(struct lookup_table_entry)); return NULL; } - lte->file_on_disk = NULL; - lte->other_wim_fp = NULL; - lte->next = NULL; lte->part_number = 1; lte->refcnt = 1; - lte->staging_num_times_opened = 0; return lte; } @@ -82,7 +80,7 @@ void lookup_table_insert(struct lookup_table *table, struct lookup_table_entry *lte) { size_t pos; - pos = *(size_t*)lte->hash % table->capacity; + pos = lte->hash_short % table->capacity; lte->next = table->array[pos]; table->array[pos] = lte; /* XXX Make the table grow when too many entries have been inserted. */ @@ -97,7 +95,7 @@ void lookup_table_unlink(struct lookup_table *table, size_t pos; struct lookup_table_entry *prev, *cur_entry, *next; - pos = *(size_t*)lte->hash % table->capacity; + pos = lte->hash_short % table->capacity; prev = NULL; cur_entry = table->array[pos]; @@ -120,7 +118,8 @@ void lookup_table_unlink(struct lookup_table *table, /* Decrement the reference count for the dentry having hash value @hash in the * lookup table. The lookup table entry is unlinked and freed if there are no * references to in remaining. */ -void lookup_table_decrement_refcnt(struct lookup_table* table, const u8 hash[]) +struct lookup_table_entry * +lookup_table_decrement_refcnt(struct lookup_table* table, const u8 hash[]) { size_t pos = *(size_t*)hash % table->capacity; struct lookup_table_entry *prev = NULL; @@ -131,43 +130,31 @@ void lookup_table_decrement_refcnt(struct lookup_table* table, const u8 hash[]) if (memcmp(hash, entry->hash, WIM_HASH_SIZE) == 0) { wimlib_assert(entry->refcnt != 0); if (--entry->refcnt == 0) { - free_lookup_table_entry(entry); + if (entry->num_opened_fds == 0) { + free_lookup_table_entry(entry); + entry = NULL; + } if (prev) prev->next = next; else table->array[pos] = next; + break; } } prev = entry; entry = next; } + return entry; } -/* - * Looks up an entry in the lookup table. - */ -struct lookup_table_entry *lookup_resource(const struct lookup_table *lookup_table, - const u8 hash[]) -{ - size_t pos; - struct lookup_table_entry *lte; - - pos = *(size_t*)hash % lookup_table->capacity; - lte = lookup_table->array[pos]; - while (lte) { - if (memcmp(hash, lte->hash, WIM_HASH_SIZE) == 0) - return lte; - lte = lte->next; - } - return NULL; -} /* * Calls a function on all the entries in the lookup table. Stop early and * return nonzero if any call to the function returns nonzero. */ int for_lookup_table_entry(struct lookup_table *table, - int (*visitor)(struct lookup_table_entry *, void *), void *arg) + int (*visitor)(struct lookup_table_entry *, void *), + void *arg) { struct lookup_table_entry *entry, *next; size_t i; @@ -207,12 +194,12 @@ int read_lookup_table(FILE *fp, u64 offset, u64 size, const u8 *p; struct lookup_table_entry *cur_entry; - DEBUG("Reading lookup table: offset %"PRIu64", size %"PRIu64"\n", - offset, size); + DEBUG("Reading lookup table: offset %"PRIu64", size %"PRIu64"", + offset, size); if (fseeko(fp, offset, SEEK_SET) != 0) { - ERROR("Failed to seek to byte %"PRIu64" to read lookup table: " - "%m\n", offset); + ERROR_WITH_ERRNO("Failed to seek to byte %"PRIu64" to read " + "lookup table", offset); return WIMLIB_ERR_READ; } @@ -224,30 +211,30 @@ int read_lookup_table(FILE *fp, u64 offset, u64 size, while (num_entries--) { if (fread(buf, 1, sizeof(buf), fp) != sizeof(buf)) { if (feof(fp)) { - ERROR("Unexpected EOF in lookup table!\n"); + ERROR("Unexpected EOF in WIM lookup table!"); } else { - ERROR("Stream read error while reading " - "lookup table!\n"); + ERROR_WITH_ERRNO("Error reading WIM lookup " + "table"); } ret = WIMLIB_ERR_READ; - goto err; + goto out; } cur_entry = new_lookup_table_entry(); if (!cur_entry) { ret = WIMLIB_ERR_NOMEM; - goto err; + goto out; } p = get_resource_entry(buf, &cur_entry->resource_entry); p = get_u16(p, &cur_entry->part_number); p = get_u32(p, &cur_entry->refcnt); - p = get_bytes(p, sizeof(cur_entry->hash), cur_entry->hash); + p = get_bytes(p, WIM_HASH_SIZE, cur_entry->hash); lookup_table_insert(table, cur_entry); } - DEBUG("Done reading lookup table.\n"); + DEBUG("Done reading lookup table."); *table_ret = table; return 0; -err: +out: free_lookup_table(table); return ret; } @@ -274,20 +261,22 @@ int write_lookup_table_entry(struct lookup_table_entry *lte, void *__out) return 0; if (lte->output_resource_entry.flags & WIM_RESHDR_FLAG_METADATA) - DEBUG("Writing metadata entry at %lu\n", ftello(out)); + DEBUG("Writing metadata entry at %lu (orig size = %zu)", + ftello(out), lte->output_resource_entry.original_size); p = put_resource_entry(buf, <e->output_resource_entry); p = put_u16(p, lte->part_number); p = put_u32(p, lte->out_refcnt); p = put_bytes(p, WIM_HASH_SIZE, lte->hash); if (fwrite(buf, 1, sizeof(buf), out) != sizeof(buf)) { - ERROR("Failed to write lookup table entry: %m\n"); + ERROR_WITH_ERRNO("Failed to write lookup table entry"); return WIMLIB_ERR_WRITE; } return 0; } -static int do_free_lookup_table_entry(struct lookup_table_entry *entry, void *ignore) +static int do_free_lookup_table_entry(struct lookup_table_entry *entry, + void *ignore) { free_lookup_table_entry(entry); return 0; @@ -295,15 +284,13 @@ static int do_free_lookup_table_entry(struct lookup_table_entry *entry, void *ig void free_lookup_table(struct lookup_table *table) { - if (table) { - if (table->array) { - for_lookup_table_entry(table, - do_free_lookup_table_entry, - NULL); - FREE(table->array); - } - FREE(table); + if (!table) + return; + if (table->array) { + for_lookup_table_entry(table, do_free_lookup_table_entry, NULL); + FREE(table->array); } + FREE(table); } int zero_out_refcnts(struct lookup_table_entry *entry, void *ignore) @@ -315,11 +302,11 @@ int zero_out_refcnts(struct lookup_table_entry *entry, void *ignore) int print_lookup_table_entry(struct lookup_table_entry *entry, void *ignore) { printf("Offset = %"PRIu64" bytes\n", - entry->resource_entry.offset); + entry->resource_entry.offset); printf("Size = %"PRIu64" bytes\n", - (u64)entry->resource_entry.size); + (u64)entry->resource_entry.size); printf("Original size = %"PRIu64" bytes\n", - entry->resource_entry.original_size); + entry->resource_entry.original_size); printf("Part Number = %hu\n", entry->part_number); printf("Reference Count = %u\n", entry->refcnt); printf("Hash = "); @@ -337,7 +324,7 @@ int print_lookup_table_entry(struct lookup_table_entry *entry, void *ignore) fputs("WIM_RESHDR_FLAG_SPANNED, ", stdout); putchar('\n'); if (entry->file_on_disk) - printf("File on Disk = \"%s\"\n", entry->file_on_disk); + printf("File on Disk = `%s'\n", entry->file_on_disk); putchar('\n'); return 0; } @@ -350,3 +337,64 @@ WIMLIBAPI void wimlib_print_lookup_table(WIMStruct *w) for_lookup_table_entry(w->lookup_table, print_lookup_table_entry, NULL); } + +/* + * Looks up an entry in the lookup table. + */ +struct lookup_table_entry * +__lookup_resource(const struct lookup_table *lookup_table, const u8 hash[]) +{ + size_t pos; + struct lookup_table_entry *lte; + + pos = *(size_t*)hash % lookup_table->capacity; + lte = lookup_table->array[pos]; + while (lte) { + if (memcmp(hash, lte->hash, WIM_HASH_SIZE) == 0) + return lte; + lte = lte->next; + } + return NULL; +} + +int lookup_resource(WIMStruct *w, const char *path, + int lookup_flags, + struct dentry **dentry_ret, + struct lookup_table_entry **lte_ret, + u8 **hash_ret) +{ + struct dentry *dentry = get_dentry(w, path); + struct lookup_table_entry *lte; + u8 *hash; + if (!dentry) + return -ENOENT; + if (!(lookup_flags & LOOKUP_FLAG_DIRECTORY_OK) + && dentry_is_directory(dentry)) + return -EISDIR; + if (lookup_flags & LOOKUP_FLAG_ADS_OK) { + const char *stream_name = path_stream_name(path); + if (stream_name) { + size_t stream_name_len = strlen(stream_name); + for (u16 i = 0; i < dentry->num_ads; i++) { + if (ads_entry_has_name(&dentry->ads_entries[i], + stream_name, + stream_name_len)) + { + hash = dentry->ads_entries[i].hash; + goto do_lookup; + } + } + return -ENOENT; + } + } + hash = dentry->hash; +do_lookup: + lte = __lookup_resource(w->lookup_table, hash); + if (dentry_ret) + *dentry_ret = dentry; + if (lte_ret) + *lte_ret = lte; + if (hash_ret) + *hash_ret = hash; + return 0; +}