X-Git-Url: https://wimlib.net/git/?a=blobdiff_plain;f=src%2Fdentry.c;h=68a5d925627a5ae925c2d0db40898657b4fdd80c;hb=028300650d936240c6d3a4da4fb30da62dd44692;hp=15dfcdfc9a67db3ad821f861a1470d6dcc60b28f;hpb=66886005209df72f53d0921cb32be6b13500e287;p=wimlib diff --git a/src/dentry.c b/src/dentry.c index 15dfcdfc..68a5d925 100644 --- a/src/dentry.c +++ b/src/dentry.c @@ -84,7 +84,6 @@ struct wim_dentry_on_disk { le64 unused_1; le64 unused_2; - /* Creation time, last access time, and last write time, in * 100-nanosecond intervals since 12:00 a.m UTC January 1, 1601. They * should correspond to the times gotten by calling GetFileTime() on @@ -184,90 +183,79 @@ struct wim_dentry_on_disk { /* Followed by variable length short name, in UTF16-LE, if * short_name_nbytes != 0. Includes null terminator. */ /*utf16lechar short_name[];*/ + + /* And optionally followed by a variable-length series of tagged items; + * see tagged_items.c. */ } _packed_attribute; /* Calculates the unaligned length, in bytes, of an on-disk WIM dentry that has * a file name and short name that take the specified numbers of bytes. This - * excludes any alternate data stream entries that may follow the dentry. */ + * excludes tagged items as well as any alternate data stream entries that may + * follow the dentry. */ static u64 -dentry_correct_length_unaligned(u16 file_name_nbytes, u16 short_name_nbytes) +dentry_min_len_with_names(u16 file_name_nbytes, u16 short_name_nbytes) { u64 length = sizeof(struct wim_dentry_on_disk); if (file_name_nbytes) - length += file_name_nbytes + 2; + length += (u32)file_name_nbytes + 2; if (short_name_nbytes) - length += short_name_nbytes + 2; + length += (u32)short_name_nbytes + 2; return length; } -/* Calculates the unaligned length, in bytes, of an on-disk WIM dentry, based on - * the file name length and short name length. Note that dentry->length is - * ignored; also, this excludes any alternate data stream entries that may - * follow the dentry. */ -static u64 -dentry_correct_length_aligned(const struct wim_dentry *dentry) +static void +do_dentry_set_name(struct wim_dentry *dentry, utf16lechar *file_name, + size_t file_name_nbytes) { - u64 len; - - len = dentry_correct_length_unaligned(dentry->file_name_nbytes, - dentry->short_name_nbytes); - return (len + 7) & ~7; -} + FREE(dentry->file_name); + dentry->file_name = file_name; + dentry->file_name_nbytes = file_name_nbytes; -static int -dentry_clear_short_name(struct wim_dentry *dentry) -{ if (dentry_has_short_name(dentry)) { FREE(dentry->short_name); dentry->short_name = NULL; dentry->short_name_nbytes = 0; } - return 0; } -/* Sets the name of a WIM dentry from a multibyte string. +/* Sets the name of a WIM dentry from a UTF-16LE string. * Only use this on dentries not inserted into the tree. Use rename_wim_path() * to do a real rename. */ int -dentry_set_name(struct wim_dentry *dentry, const tchar *new_name) +dentry_set_name_utf16le(struct wim_dentry *dentry, const utf16lechar *name, + size_t name_nbytes) { - int ret; - - ret = get_utf16le_string(new_name, &dentry->file_name, - &dentry->file_name_nbytes); - if (ret) - return ret; + utf16lechar *dup = NULL; - return dentry_clear_short_name(dentry); + if (name_nbytes) { + dup = utf16le_dupz(name, name_nbytes); + if (!dup) + return WIMLIB_ERR_NOMEM; + } + do_dentry_set_name(dentry, dup, name_nbytes); + return 0; } -/* Sets the name of a WIM dentry from a UTF-16LE string. + +/* Sets the name of a WIM dentry from a multibyte string. * Only use this on dentries not inserted into the tree. Use rename_wim_path() * to do a real rename. */ int -dentry_set_name_utf16le(struct wim_dentry *dentry, const utf16lechar *new_name) +dentry_set_name(struct wim_dentry *dentry, const tchar *name) { - utf16lechar *name = NULL; - size_t name_nbytes = 0; - - if (new_name && *new_name) { - const utf16lechar *tmp; - - tmp = new_name; - do { - name_nbytes += sizeof(utf16lechar); - } while (*++tmp); + utf16lechar *name_utf16le = NULL; + size_t name_utf16le_nbytes = 0; + int ret; - name = memdup(new_name, name_nbytes + sizeof(utf16lechar)); - if (!name) - return WIMLIB_ERR_NOMEM; + if (name && *name) { + ret = tstr_to_utf16le(name, tstrlen(name) * sizeof(tchar), + &name_utf16le, &name_utf16le_nbytes); + if (ret) + return ret; } - FREE(dentry->file_name); - dentry->file_name = name; - dentry->file_name_nbytes = name_nbytes; - - return dentry_clear_short_name(dentry); + do_dentry_set_name(dentry, name_utf16le, name_utf16le_nbytes); + return 0; } /* Returns the total length of a WIM alternate data stream entry on-disk, @@ -278,7 +266,7 @@ ads_entry_total_length(const struct wim_ads_entry *entry) { u64 len = sizeof(struct wim_ads_entry_on_disk); if (entry->stream_name_nbytes) - len += entry->stream_name_nbytes + 2; + len += (u32)entry->stream_name_nbytes + 2; return (len + 7) & ~7; } @@ -308,33 +296,33 @@ inode_needs_dummy_stream(const struct wim_inode *inode) } /* Calculate the total number of bytes that will be consumed when a WIM dentry - * is written. This includes base dentry and name fields as well as all - * alternate data stream entries and alignment bytes. */ + * is written. This includes the base dentry, the name fields, any tagged items, + * and any alternate data stream entries. Also includes all alignment bytes + * between these parts. */ u64 dentry_out_total_length(const struct wim_dentry *dentry) { - u64 length = dentry_correct_length_aligned(dentry); const struct wim_inode *inode = dentry->d_inode; + u64 len; - if (inode_needs_dummy_stream(inode)) - length += ads_entry_total_length(&(struct wim_ads_entry){}); + len = dentry_min_len_with_names(dentry->file_name_nbytes, + dentry->short_name_nbytes); + len = (len + 7) & ~7; - for (u16 i = 0; i < inode->i_num_ads; i++) - length += ads_entry_total_length(&inode->i_ads_entries[i]); + if (inode->i_extra_size) { + len += inode->i_extra_size; + len = (len + 7) & ~7; + } - return length; -} + if (unlikely(inode->i_num_ads)) { + if (inode_needs_dummy_stream(inode)) + len += ads_entry_total_length(&(struct wim_ads_entry){}); -/* Calculate the aligned, total length of a dentry, including all alternate data - * stream entries. Uses dentry->length. */ -static u64 -dentry_in_total_length(const struct wim_dentry *dentry) -{ - u64 length = dentry->length; - const struct wim_inode *inode = dentry->d_inode; - for (u16 i = 0; i < inode->i_num_ads; i++) - length += ads_entry_total_length(&inode->i_ads_entries[i]); - return (length + 7) & ~7; + for (u16 i = 0; i < inode->i_num_ads; i++) + len += ads_entry_total_length(&inode->i_ads_entries[i]); + } + + return len; } static int @@ -400,74 +388,36 @@ for_dentry_in_tree_depth(struct wim_dentry *root, int calculate_dentry_full_path(struct wim_dentry *dentry) { - tchar *full_path; - u32 full_path_nbytes; - int ret; + size_t ulen; + size_t dummy; + const struct wim_dentry *d; if (dentry->_full_path) return 0; - if (dentry_is_root(dentry)) { - static const tchar _root_path[] = {WIM_PATH_SEPARATOR, T('\0')}; - full_path = TSTRDUP(_root_path); - if (full_path == NULL) - return WIMLIB_ERR_NOMEM; - full_path_nbytes = 1 * sizeof(tchar); - } else { - struct wim_dentry *parent; - tchar *parent_full_path; - u32 parent_full_path_nbytes; - size_t filename_nbytes; - - parent = dentry->parent; - if (dentry_is_root(parent)) { - parent_full_path = T(""); - parent_full_path_nbytes = 0; - } else { - if (parent->_full_path == NULL) { - ret = calculate_dentry_full_path(parent); - if (ret) - return ret; - } - parent_full_path = parent->_full_path; - parent_full_path_nbytes = parent->full_path_nbytes; - } + ulen = 0; + d = dentry; + do { + ulen += d->file_name_nbytes / sizeof(utf16lechar); + ulen++; + d = d->d_parent; /* assumes d == d->d_parent for root */ + } while (!dentry_is_root(d)); - /* Append this dentry's name as a tchar string to the full path - * of the parent followed by the path separator */ - #if TCHAR_IS_UTF16LE - filename_nbytes = dentry->file_name_nbytes; - #else - { - int ret = utf16le_to_tstr_nbytes(dentry->file_name, - dentry->file_name_nbytes, - &filename_nbytes); - if (ret) - return ret; - } - #endif + utf16lechar ubuf[ulen]; + utf16lechar *p = &ubuf[ulen]; - full_path_nbytes = parent_full_path_nbytes + sizeof(tchar) + - filename_nbytes; - full_path = MALLOC(full_path_nbytes + sizeof(tchar)); - if (full_path == NULL) - return WIMLIB_ERR_NOMEM; - memcpy(full_path, parent_full_path, parent_full_path_nbytes); - full_path[parent_full_path_nbytes / sizeof(tchar)] = WIM_PATH_SEPARATOR; - #if TCHAR_IS_UTF16LE - memcpy(&full_path[parent_full_path_nbytes / sizeof(tchar) + 1], - dentry->file_name, - filename_nbytes + sizeof(tchar)); - #else - utf16le_to_tstr_buf(dentry->file_name, - dentry->file_name_nbytes, - &full_path[parent_full_path_nbytes / - sizeof(tchar) + 1]); - #endif - } - dentry->_full_path = full_path; - dentry->full_path_nbytes= full_path_nbytes; - return 0; + d = dentry; + do { + p -= d->file_name_nbytes / sizeof(utf16lechar); + memcpy(p, d->file_name, d->file_name_nbytes); + *--p = cpu_to_le16(WIM_PATH_SEPARATOR); + d = d->d_parent; /* assumes d == d->d_parent for root */ + } while (!dentry_is_root(d)); + + wimlib_assert(p == ubuf); + + return utf16le_to_tstr(ubuf, ulen * sizeof(utf16lechar), + &dentry->_full_path, &dummy); } tchar * @@ -480,7 +430,6 @@ dentry_full_path(struct wim_dentry *dentry) static int dentry_calculate_subdir_offset(struct wim_dentry *dentry, void *_subdir_offset_p) { - if (dentry_is_directory(dentry)) { u64 *subdir_offset_p = _subdir_offset_p; struct wim_dentry *child; @@ -598,8 +547,8 @@ dir_lookup_ci(const struct wim_inode *dir, const struct wim_dentry *dummy) } /* Given a UTF-16LE filename and a directory, look up the dentry for the file. - * Return it if found, otherwise NULL. This is case-sensitive on UNIX and - * case-insensitive on Windows. */ + * Return it if found, otherwise NULL. This has configurable case sensitivity, + * and @name need not be null-terminated. */ struct wim_dentry * get_dentry_child_with_utf16le_name(const struct wim_dentry *dentry, const utf16lechar *name, @@ -660,29 +609,22 @@ struct wim_dentry * get_dentry_child_with_name(const struct wim_dentry *dentry, const tchar *name, CASE_SENSITIVITY_TYPE case_type) { -#if TCHAR_IS_UTF16LE - return get_dentry_child_with_utf16le_name(dentry, name, - tstrlen(name) * sizeof(tchar), - case_type); -#else - utf16lechar *utf16le_name; - size_t utf16le_name_nbytes; int ret; + const utf16lechar *name_utf16le; + size_t name_utf16le_nbytes; struct wim_dentry *child; - ret = tstr_to_utf16le(name, tstrlen(name) * sizeof(tchar), - &utf16le_name, &utf16le_name_nbytes); - if (ret) { - child = NULL; - } else { - child = get_dentry_child_with_utf16le_name(dentry, - utf16le_name, - utf16le_name_nbytes, - case_type); - FREE(utf16le_name); - } + ret = tstr_get_utf16le_and_len(name, &name_utf16le, + &name_utf16le_nbytes); + if (ret) + return NULL; + + child = get_dentry_child_with_utf16le_name(dentry, + name_utf16le, + name_utf16le_nbytes, + case_type); + tstr_put_utf16le(name_utf16le); return child; -#endif } static struct wim_dentry * @@ -695,7 +637,7 @@ get_dentry_utf16le(WIMStruct *wim, const utf16lechar *path, /* Start with the root directory of the image. Note: this will be NULL * if an image has been added directly with wimlib_add_empty_image() but * no files have been added yet; in that case we fail with ENOENT. */ - cur_dentry = wim_root_dentry(wim); + cur_dentry = wim_get_current_root_dentry(wim); name_start = path; for (;;) { @@ -789,22 +731,16 @@ get_dentry_utf16le(WIMStruct *wim, const utf16lechar *path, struct wim_dentry * get_dentry(WIMStruct *wim, const tchar *path, CASE_SENSITIVITY_TYPE case_type) { -#if TCHAR_IS_UTF16LE - return get_dentry_utf16le(wim, path, case_type); -#else - utf16lechar *path_utf16le; - size_t path_utf16le_nbytes; int ret; + const utf16lechar *path_utf16le; struct wim_dentry *dentry; - ret = tstr_to_utf16le(path, tstrlen(path) * sizeof(tchar), - &path_utf16le, &path_utf16le_nbytes); + ret = tstr_get_utf16le(path, &path_utf16le); if (ret) return NULL; dentry = get_dentry_utf16le(wim, path_utf16le, case_type); - FREE(path_utf16le); + tstr_put_utf16le(path_utf16le); return dentry; -#endif } /* Takes in a path of length @len in @buf, and transforms it into a string for @@ -838,81 +774,6 @@ get_parent_dentry(WIMStruct *wim, const tchar *path, return get_dentry(wim, buf, case_type); } -#ifdef WITH_FUSE -/* Finds the dentry, lookup table entry, and stream index for a WIM file stream, - * given a path name. - * - * Currently, lookups of this type are only needed if FUSE is enabled. */ -int -wim_pathname_to_stream(WIMStruct *wim, - const tchar *path, - int lookup_flags, - struct wim_dentry **dentry_ret, - struct wim_lookup_table_entry **lte_ret, - u16 *stream_idx_ret) -{ - struct wim_dentry *dentry; - struct wim_lookup_table_entry *lte; - u16 stream_idx; - const tchar *stream_name = NULL; - struct wim_inode *inode; - tchar *p = NULL; - - if (lookup_flags & LOOKUP_FLAG_ADS_OK) { - stream_name = path_stream_name(path); - if (stream_name) { - p = (tchar*)stream_name - 1; - *p = T('\0'); - } - } - - dentry = get_dentry(wim, path, WIMLIB_CASE_SENSITIVE); - if (p) - *p = T(':'); - if (!dentry) - return -errno; - - inode = dentry->d_inode; - - if (!inode->i_resolved) - if (inode_resolve_streams(inode, wim->lookup_table, false)) - return -EIO; - - if (!(lookup_flags & LOOKUP_FLAG_DIRECTORY_OK) - && inode_is_directory(inode)) - return -EISDIR; - - if (stream_name) { - struct wim_ads_entry *ads_entry; - u16 ads_idx; - ads_entry = inode_get_ads_entry(inode, stream_name, - &ads_idx); - if (ads_entry) { - stream_idx = ads_idx + 1; - lte = ads_entry->lte; - } else { - return -ENOENT; - } - } else { - lte = inode_unnamed_stream_resolved(inode, &stream_idx); - } - if (dentry_ret) - *dentry_ret = dentry; - if (lte_ret) - *lte_ret = lte; - if (stream_idx_ret) - *stream_idx_ret = stream_idx; - return 0; -} -#endif /* WITH_FUSE */ - -/* Initializations done on every `struct wim_dentry'. */ -static void -dentry_common_init(struct wim_dentry *dentry) -{ - memset(dentry, 0, sizeof(struct wim_dentry)); -} - /* Creates an unlinked directory entry. */ int new_dentry(const tchar *name, struct wim_dentry **dentry_ret) @@ -920,11 +781,10 @@ new_dentry(const tchar *name, struct wim_dentry **dentry_ret) struct wim_dentry *dentry; int ret; - dentry = MALLOC(sizeof(struct wim_dentry)); - if (dentry == NULL) + dentry = CALLOC(1, sizeof(struct wim_dentry)); + if (!dentry) return WIMLIB_ERR_NOMEM; - dentry_common_init(dentry); if (*name) { ret = dentry_set_name(dentry, name); if (ret) { @@ -934,7 +794,7 @@ new_dentry(const tchar *name, struct wim_dentry **dentry_ret) return ret; } } - dentry->parent = dentry; + dentry->d_parent = dentry; *dentry_ret = dentry; return 0; } @@ -977,13 +837,12 @@ new_dentry_with_inode(const tchar *name, struct wim_dentry **dentry_ret) } int -new_filler_directory(const tchar *name, struct wim_dentry **dentry_ret) +new_filler_directory(struct wim_dentry **dentry_ret) { int ret; struct wim_dentry *dentry; - DEBUG("Creating filler directory \"%"TS"\"", name); - ret = new_dentry_with_inode(name, &dentry); + ret = new_dentry_with_inode(T(""), &dentry); if (ret) return ret; /* Leave the inode number as 0; this is allowed for non @@ -1007,10 +866,13 @@ dentry_tree_clear_inode_visited(struct wim_dentry *root) for_dentry_in_tree(root, dentry_clear_inode_visited, NULL); } -/* Frees a WIM dentry. +/* + * Free a WIM dentry. * - * The corresponding inode (if any) is freed only if its link count is - * decremented to 0. */ + * In addition to freeing the dentry itself, this decrements the link count of + * the corresponding inode (if any). If the inode's link count reaches 0, the + * inode is freed as well. + */ void free_dentry(struct wim_dentry *dentry) { @@ -1024,23 +886,17 @@ free_dentry(struct wim_dentry *dentry) } } -/* This function is passed as an argument to for_dentry_in_tree_depth() in order - * to free a directory tree. */ static int -do_free_dentry(struct wim_dentry *dentry, void *_lookup_table) +do_free_dentry(struct wim_dentry *dentry, void *_ignore) { - struct wim_lookup_table *lookup_table = _lookup_table; - - if (lookup_table) { - struct wim_inode *inode = dentry->d_inode; - for (unsigned i = 0; i <= inode->i_num_ads; i++) { - struct wim_lookup_table_entry *lte; + free_dentry(dentry); + return 0; +} - lte = inode_stream_lte(inode, i, lookup_table); - if (lte) - lte_decrement_refcnt(lte, lookup_table); - } - } +static int +do_free_dentry_and_unref_streams(struct wim_dentry *dentry, void *lookup_table) +{ + inode_unref_streams(dentry->d_inode, lookup_table); free_dentry(dentry); return 0; } @@ -1063,7 +919,14 @@ do_free_dentry(struct wim_dentry *dentry, void *_lookup_table) void free_dentry_tree(struct wim_dentry *root, struct wim_lookup_table *lookup_table) { - for_dentry_in_tree_depth(root, do_free_dentry, lookup_table); + int (*f)(struct wim_dentry *, void *); + + if (lookup_table) + f = do_free_dentry_and_unref_streams; + else + f = do_free_dentry; + + for_dentry_in_tree_depth(root, f, lookup_table); } /* Insert the @child dentry into the case sensitive index of the @dir directory. @@ -1153,7 +1016,7 @@ dentry_add_child(struct wim_dentry *parent, struct wim_dentry *child) } else { INIT_LIST_HEAD(&child->d_ci_conflict_list); } - child->parent = parent; + child->d_parent = parent; return NULL; } @@ -1166,7 +1029,7 @@ unlink_dentry(struct wim_dentry *dentry) if (dentry_is_root(dentry)) return; - dir = dentry->parent->d_inode; + dir = dentry->d_parent->d_inode; dir_unindex_child(dir, dentry); @@ -1190,12 +1053,28 @@ unlink_dentry(struct wim_dentry *dentry) list_del(&dentry->d_ci_conflict_list); } +static int +read_extra_data(const u8 *p, const u8 *end, struct wim_inode *inode) +{ + while (((uintptr_t)p & 7) && p < end) + p++; + + if (unlikely(p < end)) { + inode->i_extra = memdup(p, end - p); + if (!inode->i_extra) + return WIMLIB_ERR_NOMEM; + inode->i_extra_size = end - p; + } + return 0; +} + /* Reads a WIM directory entry, including all alternate data stream entries that * follow it, from the WIM image's metadata resource. */ static int read_dentry(const u8 * restrict buf, size_t buf_len, - u64 offset, struct wim_dentry **dentry_ret) + u64 *offset_p, struct wim_dentry **dentry_ret) { + u64 offset = *offset_p; u64 length; const u8 *p; const struct wim_dentry_on_disk *disk_dentry; @@ -1226,9 +1105,6 @@ read_dentry(const u8 * restrict buf, size_t buf_len, p = &buf[offset]; disk_dentry = (const struct wim_dentry_on_disk*)p; - if (unlikely((uintptr_t)p & 7)) - WARNING("WIM dentry is not 8-byte aligned"); - /* Get dentry length. */ length = le64_to_cpu(disk_dentry->length); @@ -1260,7 +1136,6 @@ read_dentry(const u8 * restrict buf, size_t buf_len, if (ret) return ret; - dentry->length = length; inode = dentry->d_inode; /* Read more fields: some into the dentry, and some into the inode. */ @@ -1307,15 +1182,15 @@ read_dentry(const u8 * restrict buf, size_t buf_len, * the length of the dentry is large enough to actually hold them. * * The calculated length here is unaligned to allow for the possibility - * that the dentry->length names an unaligned length, although this - * would be unexpected. */ - calculated_size = dentry_correct_length_unaligned(file_name_nbytes, - short_name_nbytes); + * that the dentry's length is unaligned, although this would be + * unexpected. */ + calculated_size = dentry_min_len_with_names(file_name_nbytes, + short_name_nbytes); - if (unlikely(dentry->length < calculated_size)) { + if (unlikely(length < calculated_size)) { ERROR("Unexpected end of directory entry! (Expected " "at least %"PRIu64" bytes, got %"PRIu64" bytes.)", - calculated_size, dentry->length); + calculated_size, length); ret = WIMLIB_ERR_INVALID_METADATA_RESOURCE; goto err_free_dentry; } @@ -1326,33 +1201,39 @@ read_dentry(const u8 * restrict buf, size_t buf_len, /* Read the filename if present. Note: if the filename is empty, there * is no null terminator following it. */ if (file_name_nbytes) { - dentry->file_name = MALLOC(file_name_nbytes + 2); + dentry->file_name = utf16le_dupz((const utf16lechar *)p, + file_name_nbytes); if (dentry->file_name == NULL) { ret = WIMLIB_ERR_NOMEM; goto err_free_dentry; } dentry->file_name_nbytes = file_name_nbytes; - memcpy(dentry->file_name, p, file_name_nbytes); - p += file_name_nbytes + 2; - dentry->file_name[file_name_nbytes / 2] = cpu_to_le16(0); + p += (u32)file_name_nbytes + 2; } /* Read the short filename if present. Note: if there is no short * filename, there is no null terminator following it. */ if (short_name_nbytes) { - dentry->short_name = MALLOC(short_name_nbytes + 2); + dentry->short_name = utf16le_dupz((const utf16lechar *)p, + short_name_nbytes); if (dentry->short_name == NULL) { ret = WIMLIB_ERR_NOMEM; goto err_free_dentry; } dentry->short_name_nbytes = short_name_nbytes; - memcpy(dentry->short_name, p, short_name_nbytes); - p += short_name_nbytes + 2; - dentry->short_name[short_name_nbytes / 2] = cpu_to_le16(0); + p += (u32)short_name_nbytes + 2; } + /* Read extra data at end of dentry (but before alternate data stream + * entries). This may contain tagged items. */ + ret = read_extra_data(p, &buf[offset + length], inode); + if (ret) + goto err_free_dentry; + /* Align the dentry length. */ - dentry->length = (dentry->length + 7) & ~7; + length = (length + 7) & ~7; + + offset += length; /* Read the alternate data streams, if present. inode->i_num_ads tells * us how many they are, and they will directly follow the dentry in the @@ -1362,19 +1243,22 @@ read_dentry(const u8 * restrict buf, size_t buf_len, * aligned boundary, and the alternate data stream entries seem to NOT * be included in the dentry->length field for some reason. */ if (unlikely(inode->i_num_ads != 0)) { - ret = WIMLIB_ERR_INVALID_METADATA_RESOURCE; - if (offset + dentry->length > buf_len || - (ret = read_ads_entries(&buf[offset + dentry->length], - inode, - buf_len - offset - dentry->length))) - { - ERROR("Failed to read alternate data stream " - "entries of WIM dentry \"%"WS"\"", - dentry->file_name); + size_t orig_bytes_remaining; + size_t bytes_remaining; + + if (offset > buf_len) { + ret = WIMLIB_ERR_INVALID_METADATA_RESOURCE; goto err_free_dentry; } + bytes_remaining = buf_len - offset; + orig_bytes_remaining = bytes_remaining; + ret = read_ads_entries(&buf[offset], inode, &bytes_remaining); + if (ret) + goto err_free_dentry; + offset += (orig_bytes_remaining - bytes_remaining); } + *offset_p = offset; /* Sets offset of next dentry in directory */ *dentry_ret = dentry; return 0; @@ -1383,18 +1267,6 @@ err_free_dentry: return ret; } -static const tchar * -dentry_get_file_type_string(const struct wim_dentry *dentry) -{ - const struct wim_inode *inode = dentry->d_inode; - if (inode_is_directory(inode)) - return T("directory"); - else if (inode_is_symlink(inode)) - return T("symbolic link"); - else - return T("file"); -} - static bool dentry_is_dot_or_dotdot(const struct wim_dentry *dentry) { @@ -1419,8 +1291,8 @@ read_dentry_tree_recursive(const u8 * restrict buf, size_t buf_len, /* Check for cyclic directory structure, which would cause infinite * recursion if not handled. */ - for (struct wim_dentry *d = dir->parent; - !dentry_is_root(d); d = d->parent) + for (struct wim_dentry *d = dir->d_parent; + !dentry_is_root(d); d = d->d_parent) { if (unlikely(d->subdir_offset == cur_offset)) { ERROR("Cyclic directory structure detected: children " @@ -1436,7 +1308,7 @@ read_dentry_tree_recursive(const u8 * restrict buf, size_t buf_len, int ret; /* Read next child of @dir. */ - ret = read_dentry(buf, buf_len, cur_offset, &child); + ret = read_dentry(buf, buf_len, &cur_offset, &child); if (ret) return ret; @@ -1444,13 +1316,6 @@ read_dentry_tree_recursive(const u8 * restrict buf, size_t buf_len, if (child == NULL) return 0; - /* Advance to the offset of the next child. Note: We need to - * advance by the TOTAL length of the dentry, not by the length - * child->length, which although it does take into account the - * padding, it DOES NOT take into account alternate stream - * entries. */ - cur_offset += dentry_in_total_length(child); - /* All dentries except the root should be named. */ if (unlikely(!dentry_has_long_name(child))) { WARNING("Ignoring unnamed dentry in " @@ -1473,14 +1338,10 @@ read_dentry_tree_recursive(const u8 * restrict buf, size_t buf_len, /* We already found a dentry with this same * case-sensitive long name. Only keep the first one. */ - const tchar *child_type, *duplicate_type; - child_type = dentry_get_file_type_string(child); - duplicate_type = dentry_get_file_type_string(duplicate); - WARNING("Ignoring duplicate %"TS" \"%"TS"\" " - "(the WIM image already contains a %"TS" " + WARNING("Ignoring duplicate file \"%"TS"\" " + "(the WIM image already contains a file " "at that path with the exact same name)", - child_type, dentry_full_path(duplicate), - duplicate_type); + dentry_full_path(duplicate)); free_dentry(child); continue; } @@ -1534,7 +1395,7 @@ read_dentry_tree(const u8 *buf, size_t buf_len, DEBUG("Reading dentry tree (root_offset=%"PRIu64")", root_offset); - ret = read_dentry(buf, buf_len, root_offset, &root); + ret = read_dentry(buf, buf_len, &root_offset, &root); if (ret) return ret; @@ -1544,12 +1405,7 @@ read_dentry_tree(const u8 *buf, size_t buf_len, { WARNING("The root directory has a nonempty name; " "removing it."); - FREE(root->file_name); - FREE(root->short_name); - root->file_name = NULL; - root->short_name = NULL; - root->file_name_nbytes = 0; - root->short_name_nbytes = 0; + dentry_set_name(root, NULL); } if (unlikely(!dentry_is_directory(root))) { @@ -1598,7 +1454,7 @@ write_ads_entry(const struct wim_ads_entry *ads_entry, p += sizeof(struct wim_ads_entry_on_disk); if (ads_entry->stream_name_nbytes) { p = mempcpy(p, ads_entry->stream_name, - ads_entry->stream_name_nbytes + 2); + (u32)ads_entry->stream_name_nbytes + 2); } /* Align to 8-byte boundary */ while ((uintptr_t)p & 7) @@ -1636,8 +1492,12 @@ write_dentry(const struct wim_dentry * restrict dentry, u8 * restrict p) disk_dentry->attributes = cpu_to_le32(inode->i_attributes); disk_dentry->security_id = cpu_to_le32(inode->i_security_id); disk_dentry->subdir_offset = cpu_to_le64(dentry->subdir_offset); + + /* UNIX data uses the two 8-byte reserved fields. So if no UNIX data + * exists, they get set to 0, just as we would do anyway. */ disk_dentry->unused_1 = cpu_to_le64(0); disk_dentry->unused_2 = cpu_to_le64(0); + disk_dentry->creation_time = cpu_to_le64(inode->i_creation_time); disk_dentry->last_access_time = cpu_to_le64(inode->i_last_access_time); disk_dentry->last_write_time = cpu_to_le64(inode->i_last_write_time); @@ -1667,20 +1527,22 @@ write_dentry(const struct wim_dentry * restrict dentry, u8 * restrict p) wimlib_assert(dentry_is_root(dentry) != dentry_has_long_name(dentry)); if (dentry_has_long_name(dentry)) - p = mempcpy(p, dentry->file_name, dentry->file_name_nbytes + 2); + p = mempcpy(p, dentry->file_name, (u32)dentry->file_name_nbytes + 2); if (dentry_has_short_name(dentry)) - p = mempcpy(p, dentry->short_name, dentry->short_name_nbytes + 2); + p = mempcpy(p, dentry->short_name, (u32)dentry->short_name_nbytes + 2); /* Align to 8-byte boundary */ while ((uintptr_t)p & 7) *p++ = 0; - /* We calculate the correct length of the dentry ourselves because the - * dentry->length field may been set to an unexpected value from when we - * read the dentry in (for example, there may have been unknown data - * appended to the end of the dentry...). Furthermore, the dentry may - * have been renamed, thus changing its needed length. */ + if (inode->i_extra_size) { + /* Extra tagged items --- not usually present. */ + p = mempcpy(p, inode->i_extra, inode->i_extra_size); + while ((uintptr_t)p & 7) + *p++ = 0; + } + disk_dentry->length = cpu_to_le64(p - orig_p); if (use_dummy_stream) {