struct blob_descriptor *
new_blob_descriptor(void)
{
- struct blob_descriptor *blob;
-
- blob = CALLOC(1, sizeof(struct blob_descriptor));
- if (blob == NULL)
- return NULL;
-
- /* blob->refcnt = 0 */
- /* blob->blob_location = BLOB_NONEXISTENT */
BUILD_BUG_ON(BLOB_NONEXISTENT != 0);
-
- return blob;
+ return CALLOC(1, sizeof(struct blob_descriptor));
}
struct blob_descriptor *
break;
#ifdef WITH_NTFS_3G
case BLOB_IN_NTFS_VOLUME:
- if (old->ntfs_loc) {
- new->ntfs_loc = memdup(old->ntfs_loc,
- sizeof(struct ntfs_location));
- if (new->ntfs_loc == NULL)
- goto out_free;
- new->ntfs_loc->path = STRDUP(old->ntfs_loc->path);
- new->ntfs_loc->attr_name = NULL;
- if (new->ntfs_loc->path == NULL)
- goto out_free;
- if (new->ntfs_loc->attr_name_nchars != 0) {
- new->ntfs_loc->attr_name =
- utf16le_dup(old->ntfs_loc->attr_name);
- if (new->ntfs_loc->attr_name == NULL)
- goto out_free;
- }
- }
+ new->ntfs_loc = clone_ntfs_location(old->ntfs_loc);
+ if (!new->ntfs_loc)
+ goto out_free;
break;
#endif
- default:
- break;
}
return new;
break;
#ifdef WITH_NTFS_3G
case BLOB_IN_NTFS_VOLUME:
- if (blob->ntfs_loc) {
- FREE(blob->ntfs_loc->path);
- FREE(blob->ntfs_loc->attr_name);
- FREE(blob->ntfs_loc);
- }
+ if (blob->ntfs_loc)
+ free_ntfs_location(blob->ntfs_loc);
break;
#endif
- default:
- break;
}
}
size_t old_capacity, new_capacity;
struct hlist_head *old_array, *new_array;
struct blob_descriptor *blob;
- struct hlist_node *cur, *tmp;
+ struct hlist_node *tmp;
size_t i;
old_capacity = table->capacity;
table->capacity = new_capacity;
for (i = 0; i < old_capacity; i++) {
- hlist_for_each_entry_safe(blob, cur, tmp, &old_array[i], hash_list) {
+ hlist_for_each_entry_safe(blob, tmp, &old_array[i], hash_list) {
hlist_del(&blob->hash_list);
blob_table_insert_raw(table, blob);
}
{
size_t i;
struct blob_descriptor *blob;
- struct hlist_node *pos;
i = load_size_t_unaligned(hash) % table->capacity;
- hlist_for_each_entry(blob, pos, &table->array[i], hash_list)
+ hlist_for_each_entry(blob, &table->array[i], hash_list)
if (hashes_equal(hash, blob->hash))
return blob;
return NULL;
int (*visitor)(struct blob_descriptor *, void *), void *arg)
{
struct blob_descriptor *blob;
- struct hlist_node *pos, *tmp;
+ struct hlist_node *tmp;
int ret;
for (size_t i = 0; i < table->capacity; i++) {
- hlist_for_each_entry_safe(blob, pos, tmp, &table->array[i],
+ hlist_for_each_entry_safe(blob, tmp, &table->array[i],
hash_list)
{
ret = visitor(blob, arg);
v = (int)blob1->blob_location - (int)blob2->blob_location;
- /* Different resource locations? */
+ /* Different locations? */
if (v)
return v;
/* Different (possibly split) WIMs? */
if (wim1 != wim2) {
- v = memcmp(wim1->hdr.guid, wim2->hdr.guid, WIM_GUID_LEN);
+ v = cmp_guids(wim1->hdr.guid, wim2->hdr.guid);
if (v)
return v;
}
#ifdef __WIN32__
case BLOB_IN_WINNT_FILE_ON_DISK:
case BLOB_WIN32_ENCRYPTED:
+ /* Windows: compare by starting LCN (logical cluster number) */
+ v = cmp_u64(blob1->sort_key, blob2->sort_key);
+ if (v)
+ return v;
#endif
/* Compare files by path: just a heuristic that will place files
* in the same directory next to each other. */
return tstrcmp(blob1->file_on_disk, blob2->file_on_disk);
#ifdef WITH_NTFS_3G
case BLOB_IN_NTFS_VOLUME:
- return tstrcmp(blob1->ntfs_loc->path, blob2->ntfs_loc->path);
+ return cmp_ntfs_locations(blob1->ntfs_loc, blob2->ntfs_loc);
#endif
default:
/* No additional sorting order defined for this resource
rdesc = rdescs[i];
- wim_res_hdr_to_desc(&reshdr, wim, rdesc);
+ wim_reshdr_to_desc(&reshdr, wim, rdesc);
/* For solid resources, the uncompressed size, compression type,
* and chunk size are stored in the resource itself, not in the
struct blob_table *table = NULL;
struct blob_descriptor *cur_blob = NULL;
size_t num_duplicate_blobs = 0;
+ size_t num_empty_blobs = 0;
size_t num_wrong_part_blobs = 0;
u32 image_index = 0;
struct wim_resource_descriptor **cur_solid_rdescs = NULL;
goto out;
}
- /* How to handle an uncompressed resource with its
- * uncompressed size different from its compressed size?
- *
- * Based on a simple test, WIMGAPI seems to handle this
- * as follows:
- *
- * if (size_in_wim > uncompressed_size) {
- * Ignore uncompressed_size; use size_in_wim
- * instead.
- * } else {
- * Honor uncompressed_size, but treat the part of
- * the file data above size_in_wim as all zeros.
- * }
- *
- * So we will do the same. */
- if (unlikely(!(reshdr.flags &
- WIM_RESHDR_FLAG_COMPRESSED) &&
- (reshdr.size_in_wim >
- reshdr.uncompressed_size)))
+ if (unlikely(!(reshdr.flags & WIM_RESHDR_FLAG_COMPRESSED) &&
+ (reshdr.size_in_wim != reshdr.uncompressed_size)))
{
- reshdr.uncompressed_size = reshdr.size_in_wim;
+ ERROR("Uncompressed resource has "
+ "size_in_wim != uncompressed_size");
+ ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
+ goto out;
}
/* Set up a resource descriptor for this blob. */
if (!rdesc)
goto oom;
- wim_res_hdr_to_desc(&reshdr, wim, rdesc);
-
- blob_set_is_located_in_nonsolid_wim_resource(cur_blob, rdesc);
+ wim_reshdr_to_desc_and_blob(&reshdr, wim, rdesc, cur_blob);
}
/* cur_blob is now a blob bound to a resource. */
/* Ignore entries with all zeroes in the hash field. */
- if (is_zero_hash(cur_blob->hash))
+ if (unlikely(is_zero_hash(cur_blob->hash)))
goto free_cur_blob_and_continue;
+ /* Verify that the blob has nonzero size. */
+ if (unlikely(cur_blob->size == 0)) {
+ num_empty_blobs++;
+ goto free_cur_blob_and_continue;
+ }
+
/* Verify that the part number matches that of the underlying
* WIM file. */
- if (part_number != wim->hdr.part_number) {
+ if (unlikely(part_number != wim->hdr.part_number)) {
num_wrong_part_blobs++;
goto free_cur_blob_and_continue;
}
goto out;
}
+ if (reshdr.flags & WIM_RESHDR_FLAG_SOLID) {
+ ERROR("Image metadata in solid resources "
+ "is unsupported.");
+ ret = WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY;
+ goto out;
+ }
+
if (wim->hdr.part_number != 1) {
WARNING("Ignoring metadata resource found in a "
"non-first part of the split WIM");
if (num_duplicate_blobs > 0)
WARNING("Ignoring %zu duplicate blobs", num_duplicate_blobs);
+ if (num_empty_blobs > 0)
+ WARNING("Ignoring %zu empty blobs", num_empty_blobs);
+
if (num_wrong_part_blobs > 0) {
WARNING("Ignoring %zu blobs with wrong part number",
num_wrong_part_blobs);
struct blob_table *blob_table)
{
u8 hash[SHA1_HASH_SIZE];
- struct blob_descriptor *blob, *existing_blob;
+ struct blob_descriptor *blob;
+ void *buffer_copy;
sha1_buffer(buffer, size, hash);
- existing_blob = lookup_blob(blob_table, hash);
- if (existing_blob) {
- wimlib_assert(existing_blob->size == size);
- blob = existing_blob;
- } else {
- void *buffer_copy;
- blob = new_blob_descriptor();
- if (blob == NULL)
- return NULL;
- buffer_copy = memdup(buffer, size);
- if (buffer_copy == NULL) {
- free_blob_descriptor(blob);
- return NULL;
- }
- blob_set_is_located_in_attached_buffer(blob, buffer_copy, size);
- copy_hash(blob->hash, hash);
- blob_table_insert(blob_table, blob);
+
+ blob = lookup_blob(blob_table, hash);
+ if (blob)
+ return blob;
+
+ blob = new_blob_descriptor();
+ if (!blob)
+ return NULL;
+
+ buffer_copy = memdup(buffer, size);
+ if (!buffer_copy) {
+ free_blob_descriptor(blob);
+ return NULL;
}
+ blob_set_is_located_in_attached_buffer(blob, buffer_copy, size);
+ copy_hash(blob->hash, hash);
+ blob_table_insert(blob_table, blob);
return blob;
}
wentry->is_spanned = (res_flags & WIM_RESHDR_FLAG_SPANNED) != 0;
wentry->packed = (res_flags & WIM_RESHDR_FLAG_SOLID) != 0;
}
- copy_hash(wentry->sha1_hash, blob->hash);
+ if (!blob->unhashed)
+ copy_hash(wentry->sha1_hash, blob->hash);
wentry->reference_count = blob->refcnt;
wentry->is_metadata = blob->is_metadata;
}
if (wim_has_metadata(wim)) {
int ret;
for (int i = 0; i < wim->hdr.image_count; i++) {
- ret = do_iterate_blob(wim->image_metadata[i]->metadata_blob,
- &ctx);
+ struct blob_descriptor *blob;
+ struct wim_image_metadata *imd = wim->image_metadata[i];
+
+ ret = do_iterate_blob(imd->metadata_blob, &ctx);
if (ret)
return ret;
+ image_for_each_unhashed_blob(blob, imd) {
+ ret = do_iterate_blob(blob, &ctx);
+ if (ret)
+ return ret;
+ }
}
}
return for_blob_in_table(wim->blob_table, do_iterate_blob, &ctx);
git://wimlib.net / wimlib / blobdiff