X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fdentry.c;h=ea21e07b57e90540adfccd65fb0485adeab3e39e;hp=1c93792fd9ed0556f9d0914336c4b386dac2e795;hb=2a7e6a7d014689899c90a926a095a53753488967;hpb=bd25d812eaf391fea72f4a7970bc67fddf80ac6f diff --git a/src/dentry.c b/src/dentry.c index 1c93792f..ea21e07b 100644 --- a/src/dentry.c +++ b/src/dentry.c @@ -39,45 +39,84 @@ #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 + 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)) - dentry->attributes = WIM_FILE_ATTRIBUTE_DIRECTORY; + 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 { + dentry->attributes = FILE_ATTRIBUTE_NORMAL; + } + if (sizeof(ino_t) >= 8) + dentry->hard_link = (u64)stbuf->st_ino; else - dentry->attributes = WIM_FILE_ATTRIBUTE_NORMAL; + dentry->hard_link = (u64)stbuf->st_ino | + ((u64)stbuf->st_dev << (sizeof(ino_t) * 8)); } /* 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) +int dentry_to_stbuf(const struct dentry *dentry, struct stat *stbuf, + const struct lookup_table *table) { struct lookup_table_entry *lte; - if (dentry_is_directory(dentry)) + if (dentry_is_symlink(dentry)) + stbuf->st_mode = S_IFLNK | 0777; + else if (dentry_is_directory(dentry)) stbuf->st_mode = S_IFDIR | 0755; else stbuf->st_mode = S_IFREG | 0644; - if (table) - lte = lookup_resource(table, dentry->hash); - else - lte = NULL; + stbuf->st_ino = (ino_t)dentry->hard_link; - if (lte) { - stbuf->st_nlink = lte->refcnt; - stbuf->st_size = lte->resource_entry.original_size; + stbuf->st_nlink = dentry_link_group_size(dentry); + stbuf->st_uid = getuid(); + stbuf->st_gid = getgid(); + + /* Use the size of the unnamed (default) file stream. */ + if (table && (lte = __lookup_resource(table, dentry_hash(dentry)))) { + if (lte->staging_file_name) { + struct stat native_stat; + if (stat(lte->staging_file_name, &native_stat) != 0) + return -errno; + stbuf->st_size = native_stat.st_size; + } else { + stbuf->st_size = lte->resource_entry.original_size; + } } else { - stbuf->st_nlink = 1; stbuf->st_size = 0; } - 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; + return 0; } /* Makes all timestamp fields for the dentry be the current time. */ @@ -89,6 +128,55 @@ void dentry_update_all_timestamps(struct dentry *dentry) dentry->last_write_time = now; } +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; +} + +/* 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 = dentry->num_ads + 1; + struct ads_entry *ads_entries; + struct ads_entry *new_entry; + if (num_ads == 0xffff) + return NULL; + ads_entries = MALLOC(num_ads * sizeof(struct ads_entry)); + if (!ads_entries) + return NULL; + + new_entry = &ads_entries[num_ads - 1]; + if (change_ads_name(new_entry, stream_name) != 0) { + FREE(ads_entries); + return NULL; + } + + memcpy(ads_entries, dentry->ads_entries, + (num_ads - 1) * sizeof(struct ads_entry)); + FREE(dentry->ads_entries); + dentry->ads_entries = ads_entries; + dentry->num_ads = num_ads; + return memset(new_entry, 0, sizeof(struct ads_entry)); +} + +void dentry_remove_ads(struct dentry *dentry, struct ads_entry *sentry) +{ + destroy_ads_entry(sentry); + memcpy(sentry, sentry + 1, + (dentry->num_ads - (sentry - dentry->ads_entries + 1)) + * sizeof(struct ads_entry)); + dentry->num_ads--; +} + /* * Calls a function on all directory entries in a directory tree. It is called * on a parent before its children. @@ -210,7 +298,7 @@ void calculate_subdir_offsets(struct dentry *dentry, u64 *subdir_offset_p) /* Advance the subdir offset by the amount of space the children * of this dentry take up. */ do { - *subdir_offset_p += child->length; + *subdir_offset_p += dentry_total_length(child); child = child->next; } while (child != dentry->children); @@ -314,21 +402,21 @@ struct file_attr_flag { const char *name; }; struct file_attr_flag file_attr_flags[] = { - {WIM_FILE_ATTRIBUTE_READONLY, "READONLY"}, - {WIM_FILE_ATTRIBUTE_HIDDEN, "HIDDEN"}, - {WIM_FILE_ATTRIBUTE_SYSTEM, "SYSTEM"}, - {WIM_FILE_ATTRIBUTE_DIRECTORY, "DIRECTORY"}, - {WIM_FILE_ATTRIBUTE_ARCHIVE, "ARCHIVE"}, - {WIM_FILE_ATTRIBUTE_DEVICE, "DEVICE"}, - {WIM_FILE_ATTRIBUTE_NORMAL, "NORMAL"}, - {WIM_FILE_ATTRIBUTE_TEMPORARY, "TEMPORARY"}, - {WIM_FILE_ATTRIBUTE_SPARSE_FILE, "SPARSE_FILE"}, - {WIM_FILE_ATTRIBUTE_REPARSE_POINT, "REPARSE_POINT"}, - {WIM_FILE_ATTRIBUTE_COMPRESSED, "COMPRESSED"}, - {WIM_FILE_ATTRIBUTE_OFFLINE, "OFFLINE"}, - {WIM_FILE_ATTRIBUTE_NOT_CONTENT_INDEXED,"NOT_CONTENT_INDEXED"}, - {WIM_FILE_ATTRIBUTE_ENCRYPTED, "ENCRYPTED"}, - {WIM_FILE_ATTRIBUTE_VIRTUAL, "VIRTUAL"}, + {FILE_ATTRIBUTE_READONLY, "READONLY"}, + {FILE_ATTRIBUTE_HIDDEN, "HIDDEN"}, + {FILE_ATTRIBUTE_SYSTEM, "SYSTEM"}, + {FILE_ATTRIBUTE_DIRECTORY, "DIRECTORY"}, + {FILE_ATTRIBUTE_ARCHIVE, "ARCHIVE"}, + {FILE_ATTRIBUTE_DEVICE, "DEVICE"}, + {FILE_ATTRIBUTE_NORMAL, "NORMAL"}, + {FILE_ATTRIBUTE_TEMPORARY, "TEMPORARY"}, + {FILE_ATTRIBUTE_SPARSE_FILE, "SPARSE_FILE"}, + {FILE_ATTRIBUTE_REPARSE_POINT, "REPARSE_POINT"}, + {FILE_ATTRIBUTE_COMPRESSED, "COMPRESSED"}, + {FILE_ATTRIBUTE_OFFLINE, "OFFLINE"}, + {FILE_ATTRIBUTE_NOT_CONTENT_INDEXED,"NOT_CONTENT_INDEXED"}, + {FILE_ATTRIBUTE_ENCRYPTED, "ENCRYPTED"}, + {FILE_ATTRIBUTE_VIRTUAL, "VIRTUAL"}, }; /* Prints a directory entry. @lookup_table is a pointer to the lookup table, or @@ -343,24 +431,21 @@ int print_dentry(struct dentry *dentry, void *lookup_table) printf("Attributes = 0x%x\n", dentry->attributes); for (i = 0; i < ARRAY_LEN(file_attr_flags); i++) if (file_attr_flags[i].flag & dentry->attributes) - printf(" WIM_FILE_ATTRIBUTE_%s is set\n", + printf(" FILE_ATTRIBUTE_%s is set\n", file_attr_flags[i].name); -#ifdef ENABLE_SECURITY_DATA printf("Security ID = %d\n", dentry->security_id); -#endif printf("Subdir offset = %"PRIu64"\n", dentry->subdir_offset); - /*printf("Unused1 = %"PRIu64"\n", dentry->unused1);*/ + /*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 = "); + printf("Last Access Time = 0x%"PRIx64"\n", dentry->last_access_time); + printf("Last Write Time = 0x%"PRIx64"\n", dentry->last_write_time); + printf("Hash = 0x"); print_hash(dentry->hash); putchar('\n'); - /*printf("Reparse Tag = %u\n", dentry->reparse_tag);*/ - printf("Hard Link Group = %"PRIu64"\n", dentry->hard_link); - /*printf("Number of Streams = %hu\n", dentry->streams);*/ + 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); printf("Filename = \""); print_string(dentry->file_name, dentry->file_name_len); puts("\""); @@ -372,14 +457,25 @@ 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) + if (lookup_table && (lte = __lookup_resource(lookup_table, dentry->hash))) + print_lookup_table_entry(lte, NULL); + else + putchar('\n'); + 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); + printf("Name Length (UTF-16) = %u\n", + dentry->ads_entries[i].stream_name_len); + printf("Hash = 0x"); + print_hash(dentry->ads_entries[i].hash); + if (lookup_table && + (lte = __lookup_resource(lookup_table, + dentry->ads_entries[i].hash))) + { print_lookup_table_entry(lte, NULL); - else + } else { putchar('\n'); - } else { - putchar('\n'); + } } return 0; } @@ -388,6 +484,8 @@ static inline void dentry_common_init(struct dentry *dentry) { memset(dentry, 0, sizeof(struct dentry)); dentry->refcnt = 1; + dentry->security_id = -1; + dentry->link_group_master_status = GROUP_SLAVE; } /* @@ -402,31 +500,148 @@ 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); +} + +void free_dentry(struct dentry *dentry) +{ + __destroy_dentry(dentry); + if (dentry->link_group_master_status != GROUP_SLAVE) + dentry_free_ads_entries(dentry); FREE(dentry); } +void put_dentry(struct dentry *dentry) +{ + if (dentry->link_group_master_status == GROUP_MASTER) { + struct dentry *new_master; + list_for_each_entry(new_master, &dentry->link_group_list, + link_group_list) + { + if (new_master->link_group_master_status == GROUP_SLAVE) { + new_master->link_group_master_status = GROUP_MASTER; + dentry->link_group_master_status = GROUP_SLAVE; + break; + } + } + } + struct list_head *next; + next = dentry->link_group_list.next; + list_del(&dentry->link_group_list); + /*if (next->next == next)*/ + /*container_of(next, struct dentry, link_group_list)->hard_link = 0;*/ + free_dentry(dentry); +} + +static bool dentries_have_same_ads(const struct dentry *d1, + const struct dentry *d2) +{ + /* Verify stream names and hashes are the same */ + for (u16 i = 0; i < d1->num_ads; i++) { + if (strcmp(d1->ads_entries[i].stream_name_utf8, + d2->ads_entries[i].stream_name_utf8) != 0) + return false; + if (memcmp(d1->ads_entries[i].hash, + d2->ads_entries[i].hash, + WIM_HASH_SIZE) != 0) + return false; + } + return true; +} + +/* Share the alternate stream entries between hard-linked dentries. */ +int share_dentry_ads(struct dentry *master, struct dentry *slave) +{ + const char *mismatch_type; + wimlib_assert(master->num_ads == 0 || + master->ads_entries != slave->ads_entries); + if (master->attributes != slave->attributes) { + mismatch_type = "attributes"; + goto mismatch; + } + if (master->attributes & FILE_ATTRIBUTE_DIRECTORY) { + ERROR("`%s' is hard-linked to `%s', which is a directory ", + slave->full_path_utf8, master->full_path_utf8); + return WIMLIB_ERR_INVALID_DENTRY; + } + if (master->security_id != slave->security_id) { + mismatch_type = "security ID"; + goto mismatch; + } + if (memcmp(master->hash, slave->hash, WIM_HASH_SIZE) != 0) { + mismatch_type = "main file resource"; + goto mismatch; + } + if (!dentries_have_same_ads(master, slave)) { + mismatch_type = "Alternate Stream Entries"; + goto mismatch; + } + dentry_free_ads_entries(slave); + slave->ads_entries = master->ads_entries; + slave->link_group_master_status = GROUP_SLAVE; + return 0; +mismatch: + ERROR("Dentries `%s' and `%s' in the same hard-link group but " + "do not share the same %s", + master->full_path_utf8, slave->full_path_utf8, + mismatch_type); + return WIMLIB_ERR_INVALID_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; +} + /* Arguments for do_free_dentry(). */ struct free_dentry_args { struct lookup_table *lookup_table; @@ -501,7 +716,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)) @@ -524,41 +745,62 @@ static inline void recalculate_dentry_size(struct dentry *dentry) dentry->length = WIM_DENTRY_DISK_SIZE + dentry->file_name_len + 2 + dentry->short_name_len; /* Must be multiple of 8. */ - dentry->length += (8 - dentry->length % 8) % 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) +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(name); - utf8_len = strlen(new_name); + name_utf16 = utf8_to_utf16(name, utf8_len, &utf16_len); - dentry->file_name = utf8_to_utf16(new_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; @@ -572,21 +814,31 @@ 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; + 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; } @@ -609,6 +861,86 @@ void calculate_dir_tree_statistics(struct dentry *root, struct lookup_table *tab for_dentry_in_tree(root, calculate_dentry_statistics, &stats); } +static int read_ads_entries(const u8 *p, struct dentry *dentry, + u64 remaining_size) +{ + u16 num_ads = dentry->num_ads; + struct ads_entry *ads_entries = CALLOC(num_ads, sizeof(struct ads_entry)); + int ret; + if (!ads_entries) { + ERROR("Could not allocate memory for %"PRIu16" " + "alternate data stream entries", num_ads); + return WIMLIB_ERR_NOMEM; + } + DEBUG2("Reading %"PRIu16" alternate data streams " + "(remaining size = %"PRIu64")", num_ads, remaining_size); + + for (u16 i = 0; i < num_ads; i++) { + 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; + + 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_u16(p, &cur_entry->stream_name_len); + + DEBUG2("Stream name length = %u", cur_entry->stream_name_len); + + cur_entry->stream_name = NULL; + cur_entry->stream_name_utf8 = NULL; + + 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; + } + remaining_size -= cur_entry->stream_name_len + 2; + + cur_entry->stream_name = MALLOC(cur_entry->stream_name_len); + if (!cur_entry->stream_name) { + ret = WIMLIB_ERR_NOMEM; + goto out_free_ads_entries; + } + 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_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; +out_free_ads_entries: + for (u16 i = 0; i < num_ads; i++) { + FREE(ads_entries[i].stream_name); + FREE(ads_entries[i].stream_name_utf8); + } + FREE(ads_entries); + return ret; +} + /* * Reads a directory entry from the metadata resource. */ @@ -623,6 +955,7 @@ int read_dentry(const u8 metadata_resource[], u64 metadata_resource_len, u16 short_name_len; u16 file_name_len; size_t file_name_utf8_len; + int ret; dentry_common_init(dentry); @@ -665,15 +998,13 @@ int read_dentry(const u8 metadata_resource[], u64 metadata_resource_len, } p = get_u32(p, &dentry->attributes); -#ifdef ENABLE_SECURITY_DATA p = get_u32(p, (u32*)&dentry->security_id); -#else - p += sizeof(u32); -#endif p = get_u64(p, &dentry->subdir_offset); /* 2 unused fields */ p += 2 * sizeof(u64); + /*p = get_u64(p, &dentry->unused1);*/ + /*p = get_u64(p, &dentry->unused2);*/ p = get_u64(p, &dentry->creation_time); p = get_u64(p, &dentry->last_access_time); @@ -681,15 +1012,27 @@ int read_dentry(const u8 metadata_resource[], u64 metadata_resource_len, p = get_bytes(p, WIM_HASH_SIZE, dentry->hash); - /* Currently ignoring reparse_tag. */ - p += sizeof(u32); + /* + * I don't know what's going on here. It seems like M$ screwed up the + * reparse points, then put the fields in the same place and didn't + * document it. The WIM_HDR_FLAG_RP_FIX flag in the WIM header might + * have something to do with this, but it's not documented. + */ + if (dentry->attributes & FILE_ATTRIBUTE_REPARSE_POINT) { + /* ??? */ + p += 4; + p = get_u32(p, &dentry->reparse_tag); + p += 4; + } else { + p = get_u32(p, &dentry->reparse_tag); + p = get_u64(p, &dentry->hard_link); + } - /* The reparse_reserved field does not actually exist. */ + /* By the way, the reparse_reserved field does not actually exist (at + * least when the file is not a reparse point) */ - p = get_u64(p, &dentry->hard_link); - /* Currently ignoring streams. */ - p += sizeof(u16); + p = get_u16(p, &dentry->num_ads); p = get_u16(p, &short_name_len); p = get_u16(p, &file_name_len); @@ -722,6 +1065,7 @@ int read_dentry(const u8 metadata_resource[], u64 metadata_resource_len, if (!file_name_utf8) { ERROR("Failed to allocate memory to convert UTF-16 " "filename (%hu bytes) to UTF-8", file_name_len); + ret = WIMLIB_ERR_NOMEM; goto out_free_file_name; } @@ -734,10 +1078,59 @@ int read_dentry(const u8 metadata_resource[], u64 metadata_resource_len, if (!short_name) { ERROR("Failed to allocate %hu bytes for short filename", short_name_len); + ret = WIMLIB_ERR_NOMEM; goto out_free_file_name_utf8; } - get_bytes(p, short_name_len, short_name); + p = get_bytes(p, short_name_len, short_name); + + /* Some directory entries inexplicibly have a little over 70 bytes of + * extra data. The exact amount of data seems to be 72 bytes, but it is + * aligned on the next 8-byte boundary. Here's an example of the + * aligned data: + * + * 01000000400000006c786bbac58ede11b0bb00261870892ab6adb76fe63a3 + * e468fca86530d2effa16c786bbac58ede11b0bb00261870892a0000000000 + * 0000000000000000000000 + * + * Here's one interpretation of how the data is laid out. + * + * struct unknown { + * u32 field1; (always 0x00000001) + * u32 field2; (always 0x40000000) + * u16 field3; + * u32 field4; + * u32 field5; + * u32 field6; + * u8 data[48]; (???) + * u64 reserved1; (always 0) + * u64 reserved2; (always 0) + * };*/ +#if 0 + if (dentry->length - calculated_size >= WIM_ADS_ENTRY_DISK_SIZE) { + printf("%s: %lu / %lu (", file_name_utf8, + calculated_size, dentry->length); + print_string(p + WIM_ADS_ENTRY_DISK_SIZE, dentry->length - calculated_size - WIM_ADS_ENTRY_DISK_SIZE); + puts(")"); + print_byte_field(p, dentry->length - calculated_size); + putchar('\n'); + } +#endif + + if (dentry->num_ads != 0) { + 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; + } dentry->file_name = file_name; dentry->file_name_utf8 = file_name_utf8; @@ -746,11 +1139,13 @@ int read_dentry(const u8 metadata_resource[], u64 metadata_resource_len, dentry->file_name_utf8_len = file_name_utf8_len; dentry->short_name_len = short_name_len; return 0; +out_free_short_name: + FREE(short_name); out_free_file_name_utf8: - FREE(dentry->file_name_utf8); + FREE(file_name_utf8); out_free_file_name: - FREE(dentry->file_name); - return WIMLIB_ERR_NOMEM; + FREE(file_name); + return ret; } /* @@ -758,39 +1153,60 @@ out_free_file_name: * * @dentry: The dentry structure. * @p: The memory location to write the data to. - * @return: True on success, false on failure. + * @return: Pointer to the byte after the last byte we wrote as part of the + * dentry. */ static u8 *write_dentry(const struct dentry *dentry, u8 *p) { u8 *orig_p = p; - memset(p, 0, dentry->length); + unsigned padding; + p = put_u64(p, dentry->length); p = put_u32(p, dentry->attributes); -#ifdef ENABLE_SECURITY_DATA p = put_u32(p, dentry->security_id); -#else - p = put_u32(p, (u32)(-1)); -#endif p = put_u64(p, dentry->subdir_offset); p = put_u64(p, 0); /* unused1 */ p = put_u64(p, 0); /* unused2 */ p = put_u64(p, dentry->creation_time); p = put_u64(p, dentry->last_access_time); p = put_u64(p, dentry->last_write_time); - if (!is_empty_file_hash(dentry->hash)) - memcpy(p, dentry->hash, WIM_HASH_SIZE); - else - DEBUG("zero hash for %s\n", dentry->file_name_utf8); - p += WIM_HASH_SIZE; - p = put_u32(p, 0); /* reparse_tag */ - p = put_u64(p, dentry->hard_link); - p = put_u16(p, 0); /*streams */ + p = put_bytes(p, WIM_HASH_SIZE, dentry->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); - return orig_p + dentry->length; + + 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); + 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 p; } /* Recursive function that writes a dentry tree rooted at @tree, not including @@ -806,8 +1222,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; } @@ -907,7 +1323,7 @@ int read_dentry_tree(const u8 metadata_resource[], u64 metadata_resource_len, } /* Advance to the offset of the next child. */ - cur_offset += child->length; + cur_offset += dentry_total_length(child); } /* Link last child to first one, and set parent's