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
/* 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,
{
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;
}
}
/* 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
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 *
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;
}
/* 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,
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 *
/* 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 (;;) {
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
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 */
-
/* Creates an unlinked directory entry. */
int
new_dentry(const tchar *name, struct wim_dentry **dentry_ret)
return ret;
}
}
- dentry->parent = dentry;
+ dentry->d_parent = dentry;
*dentry_ret = dentry;
return 0;
}
}
}
-/* 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;
+ free_dentry(dentry);
+ return 0;
+}
- if (lookup_table)
- inode_unref_streams(dentry->d_inode, 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;
}
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.
} else {
INIT_LIST_HEAD(&child->d_ci_conflict_list);
}
- child->parent = parent;
+ child->d_parent = parent;
return NULL;
}
if (dentry_is_root(dentry))
return;
- dir = dentry->parent->d_inode;
+ dir = dentry->d_parent->d_inode;
dir_unindex_child(dir, 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;
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);
if (ret)
return ret;
- dentry->length = length;
inode = dentry->d_inode;
/* Read more fields: some into the dentry, and some into the inode. */
* 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;
}
/* 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
* 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;
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)
{
/* 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 "
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;
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 "
/* 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;
}
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;
{
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))) {
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)
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);
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) {
git://wimlib.net / wimlib / blobdiff