return (len + 7) & ~7;
}
+static void
+do_dentry_set_name(struct wim_dentry *dentry, utf16lechar *file_name,
+ size_t file_name_nbytes)
+{
+ FREE(dentry->file_name);
+ dentry->file_name = file_name;
+ dentry->file_name_nbytes = file_name_nbytes;
+
+ if (dentry_has_short_name(dentry)) {
+ FREE(dentry->short_name);
+ dentry->short_name = NULL;
+ dentry->short_name_nbytes = 0;
+ }
+}
+
+/* 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_utf16le(struct wim_dentry *dentry, const utf16lechar *name,
+ size_t name_nbytes)
+{
+ utf16lechar *dup = NULL;
+
+ 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 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(struct wim_dentry *dentry, const tchar *new_name)
+dentry_set_name(struct wim_dentry *dentry, const tchar *name)
{
+ utf16lechar *name_utf16le = NULL;
+ size_t name_utf16le_nbytes = 0;
int ret;
- ret = get_utf16le_string(new_name, &dentry->file_name,
- &dentry->file_name_nbytes);
- if (ret == 0) {
- /* Clear the short name and recalculate the dentry length */
- if (dentry_has_short_name(dentry)) {
- FREE(dentry->short_name);
- dentry->short_name = NULL;
- dentry->short_name_nbytes = 0;
- }
+
+ if (name && *name) {
+ ret = tstr_to_utf16le(name, tstrlen(name) * sizeof(tchar),
+ &name_utf16le, &name_utf16le_nbytes);
+ if (ret)
+ return ret;
}
- return ret;
+
+ 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,
return do_for_dentry_in_tree_depth(root, visitor, arg);
}
-/* Calculate the full path of @dentry. The full path of its parent must have
- * already been calculated, or it must be the root dentry. */
+/* Calculate the full path of @dentry. */
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->parent; /* assumes 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->parent; /* assumes d == d->parent for root */
+ } while (!dentry_is_root(d));
-static int
-do_calculate_dentry_full_path(struct wim_dentry *dentry, void *_ignore)
-{
- return calculate_dentry_full_path(dentry);
-}
+ wimlib_assert(p == ubuf);
-int
-calculate_dentry_tree_full_paths(struct wim_dentry *root)
-{
- return for_dentry_in_tree(root, do_calculate_dentry_full_path, NULL);
+ return utf16le_to_tstr(ubuf, ulen * sizeof(utf16lechar),
+ &dentry->_full_path, &dummy);
}
tchar *
}
/* 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 *
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
if (ads_entry) {
stream_idx = ads_idx + 1;
lte = ads_entry->lte;
- goto out;
} else {
return -ENOENT;
}
} else {
lte = inode_unnamed_stream_resolved(inode, &stream_idx);
}
-out:
if (dentry_ret)
*dentry_ret = dentry;
if (lte_ret)
}
#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)
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) {
}
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
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)
{
}
}
-/* 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;
}
/*
- * Unlinks and frees a dentry tree.
+ * Recursively frees all directory entries in the specified tree.
*
* @root:
* The root of the tree.
* 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.
+ *
+ * This also puts references to the corresponding inodes.
+ *
+ * This does *not* unlink @root from its parent directory (if it has one).
*/
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.
list_del(&dentry->d_ci_conflict_list);
}
-static int
-free_dentry_full_path(struct wim_dentry *dentry, void *_ignore)
-{
- FREE(dentry->_full_path);
- dentry->_full_path = NULL;
- return 0;
-}
-
-/* Rename a file or directory in the WIM. */
-int
-rename_wim_path(WIMStruct *wim, const tchar *from, const tchar *to,
- CASE_SENSITIVITY_TYPE case_type)
-{
- struct wim_dentry *src;
- struct wim_dentry *dst;
- struct wim_dentry *parent_of_dst;
- int ret;
-
- /* This rename() implementation currently only supports actual files
- * (not alternate data streams) */
-
- src = get_dentry(wim, from, case_type);
- if (!src)
- return -errno;
-
- dst = get_dentry(wim, to, case_type);
-
- if (dst) {
- /* Destination file exists */
-
- if (src == dst) /* Same file */
- return 0;
-
- if (!dentry_is_directory(src)) {
- /* Cannot rename non-directory to directory. */
- if (dentry_is_directory(dst))
- return -EISDIR;
- } else {
- /* Cannot rename directory to a non-directory or a non-empty
- * directory */
- if (!dentry_is_directory(dst))
- return -ENOTDIR;
- if (dentry_has_children(dst))
- return -ENOTEMPTY;
- }
- parent_of_dst = dst->parent;
- } else {
- /* Destination does not exist */
- parent_of_dst = get_parent_dentry(wim, to, case_type);
- if (!parent_of_dst)
- return -errno;
-
- if (!dentry_is_directory(parent_of_dst))
- return -ENOTDIR;
- }
-
- ret = dentry_set_name(src, path_basename(to));
- if (ret)
- return -ENOMEM;
- if (dst) {
- unlink_dentry(dst);
- free_dentry_tree(dst, wim->lookup_table);
- }
- unlink_dentry(src);
- dentry_add_child(parent_of_dst, src);
- if (src->_full_path)
- for_dentry_in_tree(src, free_dentry_full_path, NULL);
- 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
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);
/* 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);
}
/* 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);
}
/* Align the dentry length. */
inode,
buf_len - offset - dentry->length)))
{
- ERROR("Failed to read alternate data stream "
- "entries of WIM dentry \"%"WS"\"",
- dentry->file_name);
goto 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)
{
/* 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;
}
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. */
disk_dentry->length = cpu_to_le64(p - orig_p);
if (use_dummy_stream) {