le64 subdir_offset;
/* Reserved fields */
- /* As an extension, wimlib can store UNIX data here. */
- union {
- struct {
- le64 unused_1;
- le64 unused_2;
- };
- struct wimlib_unix_data_disk unix_data;
- };
+ 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
/* 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)
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)
-{
- u64 len;
-
- len = dentry_correct_length_unaligned(dentry->file_name_nbytes,
- dentry->short_name_nbytes);
- return (len + 7) & ~7;
-}
-
static void
do_dentry_set_name(struct wim_dentry *dentry, utf16lechar *file_name,
size_t file_name_nbytes)
}
/* 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,
+ * 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
do {
ulen += d->file_name_nbytes / sizeof(utf16lechar);
ulen++;
- d = d->parent; /* assumes d == d->parent for root */
+ d = d->d_parent; /* assumes d == d->d_parent for root */
} while (!dentry_is_root(d));
utf16lechar ubuf[ulen];
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->parent; /* assumes d == d->parent for root */
+ d = d->d_parent; /* assumes d == d->d_parent for root */
} while (!dentry_is_root(d));
wimlib_assert(p == ubuf);
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;
- }
+
+ ads_entry = inode_get_ads_entry(inode, stream_name);
+ if (!ads_entry)
+ return -errno;
+
+ stream_idx = ads_entry - inode->i_ads_entries + 1;
+ lte = ads_entry->lte;
} else {
lte = inode_unnamed_stream_resolved(inode, &stream_idx);
}
return ret;
}
}
- dentry->parent = dentry;
+ dentry->d_parent = dentry;
*dentry_ret = dentry;
return 0;
}
} 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;
if (ret)
return ret;
- dentry->length = length;
inode = dentry->d_inode;
/* Read more fields: some into the dentry, and some into the inode. */
inode->i_attributes = le32_to_cpu(disk_dentry->attributes);
inode->i_security_id = le32_to_cpu(disk_dentry->security_id);
dentry->subdir_offset = le64_to_cpu(disk_dentry->subdir_offset);
-
- inode->i_unix_data.uid = le32_to_cpu(disk_dentry->unix_data.uid);
- inode->i_unix_data.gid = le32_to_cpu(disk_dentry->unix_data.gid);
- inode->i_unix_data.mode = le32_to_cpu(disk_dentry->unix_data.mode);
- inode->i_unix_data.reserved = le32_to_cpu(disk_dentry->unix_data.reserved);
-
inode->i_creation_time = le64_to_cpu(disk_dentry->creation_time);
inode->i_last_access_time = le64_to_cpu(disk_dentry->last_access_time);
inode->i_last_write_time = le64_to_cpu(disk_dentry->last_write_time);
* 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;
}
p += 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)))
- {
+ 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;
/* 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 "
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;
/* 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->unix_data.uid = cpu_to_le32(inode->i_unix_data.uid);
- disk_dentry->unix_data.gid = cpu_to_le32(inode->i_unix_data.gid);
- disk_dentry->unix_data.mode = cpu_to_le32(inode->i_unix_data.mode);
- disk_dentry->unix_data.reserved = cpu_to_le32(inode->i_unix_data.reserved);
+ 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);
while ((uintptr_t)p & 7)
*p++ = 0;
+ 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