X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fdentry.c;h=b62f53ae6d73e4dc46092e3170061e6a48ca390c;hp=85512990dafb4e52e9e5c9a03a8429bb1e3f42e5;hb=14c65f15f708c27dc434db1f0d112fad2a0b007c;hpb=91525408b4c14f6defd5c4d304515f564e0b3b01 diff --git a/src/dentry.c b/src/dentry.c index 85512990..b62f53ae 100644 --- a/src/dentry.c +++ b/src/dentry.c @@ -30,82 +30,146 @@ * along with wimlib; if not, see http://www.gnu.org/licenses/. */ +#include +#include +#include +#include + #include "wimlib_internal.h" #include "dentry.h" #include "io.h" #include "timestamp.h" #include "lookup_table.h" #include "sha1.h" -#include -#include + +/* + * Returns true if @dentry has the UTF-8 file name @name that has length + * @name_len. + */ +static bool dentry_has_name(const struct dentry *dentry, const char *name, + size_t name_len) +{ + if (dentry->file_name_utf8_len != name_len) + return false; + return memcmp(dentry->file_name_utf8, name, name_len) == 0; +} /* Real length of a dentry, including the alternate data stream entries, which * are not included in the dentry->length field... */ u64 dentry_total_length(const struct dentry *dentry) { - u64 length = dentry->length; - if (dentry->num_ads) { - u16 i = 0; - do { - length += WIM_ADS_ENTRY_DISK_SIZE + - dentry->ads_entries[i].stream_name_len; - } while (++i != dentry->num_ads); - /* If there are Alternate Stream Entries, we apparently need to - * round up to the NEXT 8-byte boundary, even if we are already - * aligned on one... */ - length++; - } - /* Round to 8 byte boundary. */ - return (length + 7) & ~7; + u64 length = (dentry->length + 7) & ~7; + for (u16 i = 0 ; i < dentry->num_ads; i++) + length += ads_entry_length(&dentry->ads_entries[i]); + return length; } /* Transfers file attributes from a `stat' buffer to a struct dentry. */ void stbuf_to_dentry(const struct stat *stbuf, struct dentry *dentry) { - if (S_ISDIR(stbuf->st_mode)) + if (S_ISLNK(stbuf->st_mode)) { + dentry->attributes = FILE_ATTRIBUTE_REPARSE_POINT; + dentry->reparse_tag = WIM_IO_REPARSE_TAG_SYMLINK; + } else if (S_ISDIR(stbuf->st_mode)) { dentry->attributes = FILE_ATTRIBUTE_DIRECTORY; - else + } else { dentry->attributes = FILE_ATTRIBUTE_NORMAL; + } + if (sizeof(ino_t) >= 8) + dentry->hard_link = (u64)stbuf->st_ino; + else + dentry->hard_link = (u64)stbuf->st_ino | + ((u64)stbuf->st_dev << (sizeof(ino_t) * 8)); + /* Set timestamps */ + dentry->creation_time = timespec_to_wim_timestamp(&stbuf->st_mtim); + dentry->last_write_time = timespec_to_wim_timestamp(&stbuf->st_mtim); + dentry->last_access_time = timespec_to_wim_timestamp(&stbuf->st_atim); } -/* Transfers file attributes from a struct dentry to a `stat' buffer. */ -void dentry_to_stbuf(const struct dentry *dentry, struct stat *stbuf, - const struct lookup_table *table) + +/* Makes all timestamp fields for the dentry be the current time. */ +void dentry_update_all_timestamps(struct dentry *dentry) { - struct lookup_table_entry *lte; + u64 now = get_wim_timestamp(); + dentry->creation_time = now; + dentry->last_access_time = now; + dentry->last_write_time = now; +} - if (dentry_is_directory(dentry)) - stbuf->st_mode = S_IFDIR | 0755; - else - stbuf->st_mode = S_IFREG | 0644; +struct ads_entry *dentry_get_ads_entry(struct dentry *dentry, + const char *stream_name) +{ + size_t stream_name_len = strlen(stream_name); + if (!stream_name) + return NULL; + for (u16 i = 0; i < dentry->num_ads; i++) + if (ads_entry_has_name(&dentry->ads_entries[i], + stream_name, stream_name_len)) + return &dentry->ads_entries[i]; + return NULL; +} - if (table) - lte = lookup_resource(table, dentry->hash); - else - lte = NULL; +static void ads_entry_init(struct ads_entry *ads_entry) +{ + memset(ads_entry, 0, sizeof(struct ads_entry)); + INIT_LIST_HEAD(&ads_entry->lte_group_list.list); + ads_entry->lte_group_list.type = STREAM_TYPE_ADS; +} - if (lte) { - stbuf->st_nlink = lte->refcnt; - stbuf->st_size = lte->resource_entry.original_size; - } else { - stbuf->st_nlink = 1; - stbuf->st_size = 0; +/* Add an alternate stream entry to a dentry and return a pointer to it, or NULL + * on failure. */ +struct ads_entry *dentry_add_ads(struct dentry *dentry, const char *stream_name) +{ + u16 num_ads; + struct ads_entry *ads_entries; + struct ads_entry *new_entry; + + if (dentry->num_ads == 0xffff) + return NULL; + num_ads = dentry->num_ads + 1; + ads_entries = REALLOC(dentry->ads_entries, + num_ads * sizeof(struct ads_entry)); + if (!ads_entries) + return NULL; + if (ads_entries != dentry->ads_entries) { + /* We moved the ADS entries. Adjust the stream lists. */ + for (u16 i = 0; i < dentry->num_ads; i++) { + struct list_head *cur = &ads_entries[i].lte_group_list.list; + cur->prev->next = cur; + cur->next->prev = cur; + } } - stbuf->st_uid = getuid(); - stbuf->st_gid = getgid(); - stbuf->st_atime = ms_timestamp_to_unix(dentry->last_access_time); - stbuf->st_mtime = ms_timestamp_to_unix(dentry->last_write_time); - stbuf->st_ctime = ms_timestamp_to_unix(dentry->creation_time); - stbuf->st_blocks = (stbuf->st_size + 511) / 512; + dentry->ads_entries = ads_entries; + + new_entry = &ads_entries[num_ads - 1]; + if (change_ads_name(new_entry, stream_name) != 0) + return NULL; + dentry->num_ads = num_ads; + ads_entry_init(new_entry); + return new_entry; } -/* Makes all timestamp fields for the dentry be the current time. */ -void dentry_update_all_timestamps(struct dentry *dentry) +void dentry_remove_ads(struct dentry *dentry, struct ads_entry *ads_entry) { - u64 now = get_timestamp(); - dentry->creation_time = now; - dentry->last_access_time = now; - dentry->last_write_time = now; + u16 idx; + u16 following; + + wimlib_assert(dentry->num_ads); + idx = ads_entry - dentry->ads_entries; + wimlib_assert(idx < dentry->num_ads); + following = dentry->num_ads - idx - 1; + + destroy_ads_entry(ads_entry); + memcpy(ads_entry, ads_entry + 1, following * sizeof(struct ads_entry)); + + /* We moved the ADS entries. Adjust the stream lists. */ + for (u16 i = 0; i < following; i++) { + struct list_head *cur = &ads_entry[i].lte_group_list.list; + cur->prev->next = cur; + cur->next->prev = cur; + } + + dentry->num_ads--; } /* @@ -354,27 +418,40 @@ struct file_attr_flag file_attr_flags[] = { * NULL if the resource entry for the dentry is not to be printed. */ int print_dentry(struct dentry *dentry, void *lookup_table) { - struct lookup_table_entry *lte; - unsigned i; + const u8 *hash; printf("[DENTRY]\n"); printf("Length = %"PRIu64"\n", dentry->length); printf("Attributes = 0x%x\n", dentry->attributes); - for (i = 0; i < ARRAY_LEN(file_attr_flags); i++) + for (unsigned i = 0; i < ARRAY_LEN(file_attr_flags); i++) if (file_attr_flags[i].flag & dentry->attributes) printf(" FILE_ATTRIBUTE_%s is set\n", file_attr_flags[i].name); printf("Security ID = %d\n", dentry->security_id); printf("Subdir offset = %"PRIu64"\n", dentry->subdir_offset); - /*printf("Unused1 = 0x%"PRIu64"\n", dentry->unused1);*/ - /*printf("Unused2 = %"PRIu64"\n", dentry->unused2);*/ - printf("Creation Time = %"PRIu64"\n", dentry->creation_time); - printf("Last Access Time = %"PRIu64"\n", dentry->last_access_time); - printf("Last Write Time = %"PRIu64"\n", dentry->last_write_time); - printf("Creation Time = 0x%"PRIx64"\n", dentry->creation_time); - printf("Hash = "); - print_hash(dentry->hash); - putchar('\n'); +#if 0 + printf("Unused1 = 0x%"PRIu64"\n", dentry->unused1); + printf("Unused2 = %"PRIu64"\n", dentry->unused2); +#endif +#if 0 + printf("Creation Time = 0x%"PRIx64"\n"); + printf("Last Access Time = 0x%"PRIx64"\n"); + printf("Last Write Time = 0x%"PRIx64"\n"); +#endif + + time_t creat_time = wim_timestamp_to_unix(dentry->creation_time); + time_t access_time = wim_timestamp_to_unix(dentry->last_access_time); + time_t mod_time = wim_timestamp_to_unix(dentry->last_write_time); + printf("Creation Time = %s", asctime(localtime(&creat_time))); + printf("Last Access Time = %s", asctime(localtime(&access_time))); + printf("Last Write Time = %s", asctime(localtime(&mod_time))); + + hash = dentry_stream_hash(dentry, 0); + if (hash) { + printf("Hash = 0x"); + print_hash(hash); + putchar('\n'); + } printf("Reparse Tag = 0x%"PRIx32"\n", dentry->reparse_tag); printf("Hard Link Group = 0x%"PRIx64"\n", dentry->hard_link); printf("Number of Alternate Data Streams = %hu\n", dentry->num_ads); @@ -389,23 +466,20 @@ int print_dentry(struct dentry *dentry, void *lookup_table) puts("\""); printf("Short Name Length = %hu\n", dentry->short_name_len); printf("Full Path (UTF-8) = \"%s\"\n", dentry->full_path_utf8); - if (lookup_table) { - lte = lookup_resource(lookup_table, dentry->hash); - if (lte) - print_lookup_table_entry(lte, NULL); - else - putchar('\n'); - } else { - putchar('\n'); - } + print_lookup_table_entry(dentry_stream_lte(dentry, 0, lookup_table)); for (u16 i = 0; i < dentry->num_ads; i++) { printf("[Alternate Stream Entry %u]\n", i); printf("Name = \"%s\"\n", dentry->ads_entries[i].stream_name_utf8); - lte = lookup_resource(lookup_table, dentry->ads_entries[i].hash); - if (lte) - print_lookup_table_entry(lte, NULL); - else + printf("Name Length (UTF-16) = %u\n", + dentry->ads_entries[i].stream_name_len); + hash = dentry_stream_hash(dentry, i + 1); + if (hash) { + printf("Hash = 0x"); + print_hash(hash); putchar('\n'); + } + print_lookup_table_entry(dentry_stream_lte(dentry, i + 1, + lookup_table)); } return 0; } @@ -415,6 +489,8 @@ static inline void dentry_common_init(struct dentry *dentry) memset(dentry, 0, sizeof(struct dentry)); dentry->refcnt = 1; dentry->security_id = -1; + dentry->ads_entries_status = ADS_ENTRIES_DEFAULT; + dentry->lte_group_list.type = STREAM_TYPE_NORMAL; } /* @@ -429,51 +505,112 @@ struct dentry *new_dentry(const char *name) dentry = MALLOC(sizeof(struct dentry)); if (!dentry) - return NULL; + goto err; dentry_common_init(dentry); - if (change_dentry_name(dentry, name) != 0) { - FREE(dentry); - return NULL; - } + if (change_dentry_name(dentry, name) != 0) + goto err; dentry_update_all_timestamps(dentry); dentry->next = dentry; dentry->prev = dentry; dentry->parent = dentry; + INIT_LIST_HEAD(&dentry->link_group_list); return dentry; +err: + FREE(dentry); + ERROR("Failed to allocate new dentry"); + return NULL; } +void dentry_free_ads_entries(struct dentry *dentry) +{ + for (u16 i = 0; i < dentry->num_ads; i++) + destroy_ads_entry(&dentry->ads_entries[i]); + FREE(dentry->ads_entries); + dentry->ads_entries = NULL; + dentry->num_ads = 0; +} -void free_dentry(struct dentry *dentry) +static void __destroy_dentry(struct dentry *dentry) { FREE(dentry->file_name); FREE(dentry->file_name_utf8); FREE(dentry->short_name); FREE(dentry->full_path_utf8); + FREE(dentry->extracted_file); +} + +void free_dentry(struct dentry *dentry) +{ + wimlib_assert(dentry); + __destroy_dentry(dentry); + if (dentry->ads_entries_status != ADS_ENTRIES_USER) + dentry_free_ads_entries(dentry); FREE(dentry); } -/* Arguments for do_free_dentry(). */ -struct free_dentry_args { - struct lookup_table *lookup_table; - bool lt_decrement_refcnt; -}; +/* Like free_dentry(), but assigns a new ADS entries owner if this dentry was + * the previous owner, and also deletes the dentry from its link_group_list */ +void put_dentry(struct dentry *dentry) +{ + if (dentry->ads_entries_status == ADS_ENTRIES_OWNER) { + struct dentry *new_owner; + list_for_each_entry(new_owner, &dentry->link_group_list, + link_group_list) + { + if (new_owner->ads_entries_status == ADS_ENTRIES_USER) { + new_owner->ads_entries_status = ADS_ENTRIES_OWNER; + break; + } + } + dentry->ads_entries_status = ADS_ENTRIES_USER; + } + struct list_head *next; + list_del(&dentry->link_group_list); + free_dentry(dentry); +} + + +/* clones a dentry. + * + * Beware: + * - memory for file names is not cloned + * - next, prev, and children pointers and not touched + * - stream entries are not cloned. + */ +struct dentry *clone_dentry(struct dentry *old) +{ + struct dentry *new = MALLOC(sizeof(struct dentry)); + if (!new) + return NULL; + memcpy(new, old, sizeof(struct dentry)); + new->file_name = NULL; + new->file_name_len = 0; + new->file_name_utf8 = NULL; + new->file_name_utf8_len = 0; + new->short_name = NULL; + new->short_name_len = 0; + return new; +} /* * This function is passed as an argument to for_dentry_in_tree_depth() in order * to free a directory tree. __args is a pointer to a `struct free_dentry_args'. */ -static int do_free_dentry(struct dentry *dentry, void *__args) +static int do_free_dentry(struct dentry *dentry, void *__lookup_table) { - struct free_dentry_args *args = (struct free_dentry_args*)__args; - - if (args->lt_decrement_refcnt && !dentry_is_directory(dentry)) { - lookup_table_decrement_refcnt(args->lookup_table, - dentry->hash); + struct lookup_table *lookup_table = __lookup_table; + if (lookup_table) { + struct lookup_table_entry *lte; + if (dentry->resolved) + lte = dentry->lte; + else + lte = __lookup_resource(lookup_table, dentry->hash); + lte_decrement_refcnt(lte, lookup_table); } - wimlib_assert(dentry->refcnt >= 1); + wimlib_assert(dentry->refcnt != 0); if (--dentry->refcnt == 0) free_dentry(dentry); return 0; @@ -483,20 +620,16 @@ static int do_free_dentry(struct dentry *dentry, void *__args) * Unlinks and frees a dentry tree. * * @root: The root of the tree. - * @lookup_table: The lookup table for dentries. - * @decrement_refcnt: True if the dentries in the tree are to have their - * reference counts in the lookup table decremented. + * @lookup_table: The lookup table for dentries. If non-NULL, the + * reference counts in the lookup table for the lookup + * table entries corresponding to the dentries will be + * decremented. */ -void free_dentry_tree(struct dentry *root, struct lookup_table *lookup_table, - bool lt_decrement_refcnt) +void free_dentry_tree(struct dentry *root, struct lookup_table *lookup_table) { if (!root || !root->parent) return; - - struct free_dentry_args args; - args.lookup_table = lookup_table; - args.lt_decrement_refcnt = lt_decrement_refcnt; - for_dentry_in_tree_depth(root, do_free_dentry, &args); + for_dentry_in_tree_depth(root, do_free_dentry, lookup_table); } int increment_dentry_refcnt(struct dentry *dentry, void *ignore) @@ -513,6 +646,7 @@ int increment_dentry_refcnt(struct dentry *dentry, void *ignore) */ void link_dentry(struct dentry *dentry, struct dentry *parent) { + wimlib_assert(dentry_is_directory(parent)); dentry->parent = parent; if (parent->children) { /* Not an only child; link to siblings. */ @@ -528,7 +662,13 @@ void link_dentry(struct dentry *dentry, struct dentry *parent) } } -/* Unlink a dentry from the directory tree. */ + +/* Unlink a dentry from the directory tree. + * + * Note: This merely removes it from the in-memory tree structure. See + * remove_dentry() in mount.c for a function implemented on top of this one that + * frees the dentry and implements reference counting for the lookup table + * entries. */ void unlink_dentry(struct dentry *dentry) { if (dentry_is_root(dentry)) @@ -550,44 +690,65 @@ static inline void recalculate_dentry_size(struct dentry *dentry) { dentry->length = WIM_DENTRY_DISK_SIZE + dentry->file_name_len + 2 + dentry->short_name_len; - for (u16 i = 0; i < dentry->num_ads; i++) - dentry->length += ads_entry_length(&dentry->ads_entries[i]); /* Must be multiple of 8. */ dentry->length = (dentry->length + 7) & ~7; } -/* Changes the name of a dentry to @new_name. Only changes the file_name and - * file_name_utf8 fields; does not change the short_name, short_name_utf8, or - * full_path_utf8 fields. Also recalculates its length. */ -int change_dentry_name(struct dentry *dentry, const char *new_name) +/* Duplicates a UTF-8 name into UTF-8 and UTF-16 strings and returns the strings + * and their lengths in the pointer arguments */ +int get_names(char **name_utf16_ret, char **name_utf8_ret, + u16 *name_utf16_len_ret, u16 *name_utf8_len_ret, + const char *name) { size_t utf8_len; size_t utf16_len; + char *name_utf16, *name_utf8; - FREE(dentry->file_name); - - utf8_len = strlen(new_name); + utf8_len = strlen(name); - dentry->file_name = utf8_to_utf16(new_name, utf8_len, &utf16_len); + name_utf16 = utf8_to_utf16(name, utf8_len, &utf16_len); - if (!dentry->file_name) + if (!name_utf16) return WIMLIB_ERR_NOMEM; - FREE(dentry->file_name_utf8); - dentry->file_name_utf8 = MALLOC(utf8_len + 1); - if (!dentry->file_name_utf8) { - FREE(dentry->file_name); - dentry->file_name = NULL; + name_utf8 = MALLOC(utf8_len + 1); + if (!name_utf8) { + FREE(name_utf8); return WIMLIB_ERR_NOMEM; } - - dentry->file_name_len = utf16_len; - dentry->file_name_utf8_len = utf8_len; - memcpy(dentry->file_name_utf8, new_name, utf8_len + 1); - recalculate_dentry_size(dentry); + memcpy(name_utf8, name, utf8_len + 1); + FREE(*name_utf8_ret); + FREE(*name_utf16_ret); + *name_utf8_ret = name_utf8; + *name_utf16_ret = name_utf16; + *name_utf8_len_ret = utf8_len; + *name_utf16_len_ret = utf16_len; return 0; } +/* Changes the name of a dentry to @new_name. Only changes the file_name and + * file_name_utf8 fields; does not change the short_name, short_name_utf8, or + * full_path_utf8 fields. Also recalculates its length. */ +int change_dentry_name(struct dentry *dentry, const char *new_name) +{ + int ret; + + ret = get_names(&dentry->file_name, &dentry->file_name_utf8, + &dentry->file_name_len, &dentry->file_name_utf8_len, + new_name); + if (ret == 0) + recalculate_dentry_size(dentry); + return ret; +} + +int change_ads_name(struct ads_entry *entry, const char *new_name) +{ + return get_names(&entry->stream_name, &entry->stream_name_utf8, + &entry->stream_name_len, + &entry->stream_name_utf8_len, + new_name); +} + /* Parameters for calculate_dentry_statistics(). */ struct image_statistics { struct lookup_table *lookup_table; @@ -601,21 +762,34 @@ static int calculate_dentry_statistics(struct dentry *dentry, void *arg) { struct image_statistics *stats; struct lookup_table_entry *lte; + u16 i; stats = arg; - lte = lookup_resource(stats->lookup_table, dentry->hash); if (dentry_is_directory(dentry) && !dentry_is_root(dentry)) ++*stats->dir_count; else ++*stats->file_count; - if (lte) { - u64 size = lte->resource_entry.original_size; - *stats->total_bytes += size; - if (++lte->out_refcnt == 1) - *stats->hard_link_bytes += size; + if (dentry->resolved) + lte = dentry->lte; + else + lte = __lookup_resource(stats->lookup_table, dentry->hash); + i = 0; + while (1) { + if (lte) { + u64 size = lte->resource_entry.original_size; + *stats->total_bytes += size; + if (++lte->out_refcnt == 1) + *stats->hard_link_bytes += size; + } + if (i == dentry->num_ads) + break; + lte = __lookup_resource(stats->lookup_table, + dentry->ads_entries[i].hash); + i++; } + return 0; } @@ -656,22 +830,22 @@ static int read_ads_entries(const u8 *p, struct dentry *dentry, struct ads_entry *cur_entry = &ads_entries[i]; u64 length; size_t utf8_len; + const char *p_save = p; /* Read the base stream entry, excluding the stream name. */ if (remaining_size < WIM_ADS_ENTRY_DISK_SIZE) { ERROR("Stream entries go past end of metadata resource"); + ERROR("(remaining_size = %"PRIu64")", remaining_size); ret = WIMLIB_ERR_INVALID_DENTRY; goto out_free_ads_entries; } remaining_size -= WIM_ADS_ENTRY_DISK_SIZE; - /*print_string(p + 40, 10);*/ - /*print_byte_field(p, 50);*/ p = get_u64(p, &length); /* ADS entry length */ DEBUG2("ADS length = %"PRIu64, length); p += 8; /* Unused */ - p = get_bytes(p, WIM_HASH_SIZE, (u8*)cur_entry->hash); + p = get_bytes(p, SHA1_HASH_SIZE, (u8*)cur_entry->hash); p = get_u16(p, &cur_entry->stream_name_len); DEBUG2("Stream name length = %u", cur_entry->stream_name_len); @@ -681,6 +855,9 @@ static int read_ads_entries(const u8 *p, struct dentry *dentry, if (remaining_size < cur_entry->stream_name_len + 2) { ERROR("Stream entries go past end of metadata resource"); + ERROR("(remaining_size = %"PRIu64" bytes, stream_name_len " + "= %"PRIu16" bytes", remaining_size, + cur_entry->stream_name_len); ret = WIMLIB_ERR_INVALID_DENTRY; goto out_free_ads_entries; } @@ -691,19 +868,18 @@ static int read_ads_entries(const u8 *p, struct dentry *dentry, ret = WIMLIB_ERR_NOMEM; goto out_free_ads_entries; } - p = get_bytes(p, cur_entry->stream_name_len, - (u8*)cur_entry->stream_name); - p += 2; /* NULL terminator of stream name */ + get_bytes(p, cur_entry->stream_name_len, + (u8*)cur_entry->stream_name); cur_entry->stream_name_utf8 = utf16_to_utf8(cur_entry->stream_name, cur_entry->stream_name_len, &utf8_len); - cur_entry->stream_name_len_utf8 = utf8_len; - print_byte_field(p, 16); + cur_entry->stream_name_utf8_len = utf8_len; if (!cur_entry->stream_name_utf8) { ret = WIMLIB_ERR_NOMEM; goto out_free_ads_entries; } + p = p_save + ads_entry_length(cur_entry); } dentry->ads_entries = ads_entries; return 0; @@ -747,7 +923,6 @@ int read_dentry(const u8 metadata_resource[], u64 metadata_resource_len, * terminates the list of sibling directory entries. */ p = get_u64(&metadata_resource[offset], &dentry->length); - DEBUG("length = %zu, %zu\n", dentry->length, *(u64*)(&metadata_resource[offset])); /* A zero length field (really a length of 8, since that's how big the * directory entry is...) indicates that this is the end of directory @@ -786,7 +961,7 @@ int read_dentry(const u8 metadata_resource[], u64 metadata_resource_len, p = get_u64(p, &dentry->last_access_time); p = get_u64(p, &dentry->last_write_time); - p = get_bytes(p, WIM_HASH_SIZE, dentry->hash); + p = get_bytes(p, SHA1_HASH_SIZE, dentry->hash); /* * I don't know what's going on here. It seems like M$ screwed up the @@ -796,13 +971,9 @@ int read_dentry(const u8 metadata_resource[], u64 metadata_resource_len, */ if (dentry->attributes & FILE_ATTRIBUTE_REPARSE_POINT) { /* ??? */ - u32 u1, u2; - p = get_u32(p, &u1); - /*p += 4;*/ + p += 4; p = get_u32(p, &dentry->reparse_tag); - p = get_u32(p, &u2); - /*p += 4;*/ - dentry->hard_link = (u64)(u1) | ((u64)(u2) << 32); + p += 4; } else { p = get_u32(p, &dentry->reparse_tag); p = get_u64(p, &dentry->hard_link); @@ -898,7 +1069,15 @@ int read_dentry(const u8 metadata_resource[], u64 metadata_resource_len, #endif if (dentry->num_ads != 0) { - ret = read_ads_entries(p, dentry, + calculated_size = (calculated_size + 7) & ~7; + if (calculated_size > metadata_resource_len - offset) { + ERROR("Not enough space in metadata resource for " + "alternate stream entries"); + ret = WIMLIB_ERR_INVALID_DENTRY; + goto out_free_short_name; + } + ret = read_ads_entries(&metadata_resource[offset + calculated_size], + dentry, metadata_resource_len - offset - calculated_size); if (ret != 0) goto out_free_short_name; @@ -931,7 +1110,9 @@ out_free_file_name: static u8 *write_dentry(const struct dentry *dentry, u8 *p) { u8 *orig_p = p; - memset(p, 0, dentry->length); + unsigned padding; + const u8 *hash; + p = put_u64(p, dentry->length); p = put_u32(p, dentry->attributes); p = put_u32(p, dentry->security_id); @@ -941,25 +1122,51 @@ static u8 *write_dentry(const struct dentry *dentry, u8 *p) p = put_u64(p, dentry->creation_time); p = put_u64(p, dentry->last_access_time); p = put_u64(p, dentry->last_write_time); - memcpy(p, dentry->hash, WIM_HASH_SIZE); - p += WIM_HASH_SIZE; - p = put_u32(p, dentry->reparse_tag); - p = put_u64(p, dentry->hard_link); - p = put_u16(p, dentry->num_ads); /*streams */ + if (dentry->resolved && dentry->lte) + hash = dentry->lte->hash; + else + hash = dentry->hash; + p = put_bytes(p, SHA1_HASH_SIZE, hash); + if (dentry->attributes & FILE_ATTRIBUTE_REPARSE_POINT) { + p = put_zeroes(p, 4); + p = put_u32(p, dentry->reparse_tag); + p = put_zeroes(p, 4); + } else { + u64 hard_link; + p = put_u32(p, dentry->reparse_tag); + if (dentry->link_group_list.next == &dentry->link_group_list) + hard_link = 0; + else + hard_link = dentry->hard_link; + p = put_u64(p, hard_link); + } + p = put_u16(p, dentry->num_ads); p = put_u16(p, dentry->short_name_len); p = put_u16(p, dentry->file_name_len); p = put_bytes(p, dentry->file_name_len, (u8*)dentry->file_name); p = put_u16(p, 0); /* filename padding, 2 bytes. */ p = put_bytes(p, dentry->short_name_len, (u8*)dentry->short_name); + + wimlib_assert(p - orig_p <= dentry->length); + if (p - orig_p < dentry->length) + p = put_zeroes(p, dentry->length - (p - orig_p)); + + p = put_zeroes(p, (8 - (p - orig_p) % 8) % 8); + for (u16 i = 0; i < dentry->num_ads; i++) { p = put_u64(p, ads_entry_length(&dentry->ads_entries[i])); p = put_u64(p, 0); /* Unused */ - p = put_bytes(p, WIM_HASH_SIZE, dentry->ads_entries[i].hash); + if (dentry->resolved && dentry->ads_entries[i].lte) + hash = dentry->ads_entries[i].lte->hash; + else + hash = dentry->ads_entries[i].hash; + p = put_bytes(p, SHA1_HASH_SIZE, hash); p = put_u16(p, dentry->ads_entries[i].stream_name_len); p = put_bytes(p, dentry->ads_entries[i].stream_name_len, (u8*)dentry->ads_entries[i].stream_name); + p = put_zeroes(p, (8 - (p - orig_p) % 8) % 8); } - return orig_p + dentry->length; + return p; } /* Recursive function that writes a dentry tree rooted at @tree, not including @@ -975,8 +1182,8 @@ u8 *write_dentry_tree(const struct dentry *tree, u8 *p) /* write end of directory entry */ p = put_u64(p, 0); } else { - /* Nothing to do for a regular file. */ - if (dentry_is_regular_file(tree)) + /* Nothing to do for non-directories */ + if (!dentry_is_directory(tree)) return p; }