* 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,
+static bool dentry_has_name(const struct dentry *dentry, const char *name,
size_t name_len)
{
if (dentry->file_name_utf8_len != name_len)
}
#ifdef WITH_FUSE
-/* Transfers file attributes from a struct inode to a `stat' buffer.
+/* Transfers file attributes from a struct inode to a `stat' buffer.
*
* The lookup table entry tells us which stream in the inode we are statting.
* For a named data stream, everything returned is the same as the unnamed data
}
#endif
-/*
+/*
* Calls a function on all directory entries in a directory tree. It is called
* on a parent before its children.
*/
-int for_dentry_in_tree(struct dentry *root,
+int for_dentry_in_tree(struct dentry *root,
int (*visitor)(struct dentry*, void*), void *arg)
{
int ret;
return 0;
}
-/*
+/*
* Like for_dentry_in_tree(), but the visitor function is always called on a
* dentry's children before on itself.
*/
-int for_dentry_in_tree_depth(struct dentry *root,
+int for_dentry_in_tree_depth(struct dentry *root,
int (*visitor)(struct dentry*, void*), void *arg)
{
int ret;
return visitor(root, arg);
}
-/*
+/*
* Calculate the full path of @dentry, based on its parent's full path and on
- * its UTF-8 file name.
+ * its UTF-8 file name.
*/
int calculate_dentry_full_path(struct dentry *dentry, void *ignore)
{
return WIMLIB_ERR_NOMEM;
}
-/*
- * Recursively calculates the subdir offsets for a directory tree.
+/*
+ * Recursively calculates the subdir offsets for a directory tree.
*
* @dentry: The root of the directory tree.
* @subdir_offset_p: The current subdirectory offset; i.e., the subdirectory
- * offset for @dentry.
+ * offset for @dentry.
*/
void calculate_subdir_offsets(struct dentry *dentry, u64 *subdir_offset_p)
{
}
}
-/* Returns the child of @dentry that has the file name @name.
+/* Returns the child of @dentry that has the file name @name.
* Returns NULL if no child has the name. */
-struct dentry *get_dentry_child_with_name(const struct dentry *dentry,
+struct dentry *get_dentry_child_with_name(const struct dentry *dentry,
const char *name)
{
struct dentry *child;
size_t name_len;
-
+
child = dentry->d_inode->children;
if (child) {
name_len = strlen(name);
} else {
hash = inode_stream_hash(inode, 0);
if (hash) {
- printf("Hash = 0x");
+ printf("Hash = 0x");
print_hash(hash);
putchar('\n');
putchar('\n');
inode->ads_entries[i].stream_name_len);
hash = inode_stream_hash(inode, i + 1);
if (hash) {
- printf("Hash = 0x");
+ printf("Hash = 0x");
print_hash(hash);
putchar('\n');
}
return inode;
}
-/*
+/*
* Creates an unlinked directory entry.
*
* @name: The UTF-8 filename of the new dentry.
struct dentry *new_dentry(const char *name)
{
struct dentry *dentry;
-
+
dentry = MALLOC(sizeof(struct dentry));
if (!dentry)
goto err;
}
}
-/* Frees a WIM dentry.
+/* Frees a WIM dentry.
*
* The inode is freed only if its link count is decremented to 0.
*/
free_dentry(dentry);
}
-/*
+/*
* This function is passed as an argument to for_dentry_in_tree_depth() in order
* to free a directory tree. __args is a pointer to a `struct free_dentry_args'.
*/
return 0;
}
-/*
+/*
* Unlinks and frees a dentry tree.
*
* @root: The root of the tree.
return 0;
}
-/*
+/*
* Links a dentry into the directory tree.
*
* @dentry: The dentry to link.
#ifdef WITH_FUSE
-/*
- * 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.
*/
num_unnamed_streams++;
}
if (num_unnamed_streams > 1) {
- ERROR("Dentry `%s' has multiple (%u) un-named streams",
+ ERROR("Dentry `%s' has multiple (%u) un-named streams",
first_dentry->full_path_utf8, num_unnamed_streams);
goto out;
}
#endif
#if defined(WITH_FUSE) || defined(WITH_NTFS_3G)
-/*
+/*
* Add an alternate stream entry to an inode and return a pointer to it, or NULL
* if memory could not be allocated.
*/
-/*
+/*
* Reads the alternate data stream entries for a dentry.
*
* @p: Pointer to buffer that starts with the first alternate stream entry.
*
* struct ads_entry_on_disk {
* u64 length; // Length of the entry, in bytes. This includes
- * all fields (including the stream name and
+ * all fields (including the stream name and
* null terminator if present, AND the padding!).
* u64 reserved; // Seems to be unused
* u8 hash[20]; // SHA1 message digest of the uncompressed stream
return ret;
}
-/*
+/*
* Reads a directory entry, including all alternate data stream entries that
* follow it, from the WIM image's metadata resource.
*
* special "end of directory" dentry and not a real dentry. If nonzero, this
* was a real dentry.
*/
-int read_dentry(const u8 metadata_resource[], u64 metadata_resource_len,
+int read_dentry(const u8 metadata_resource[], u64 metadata_resource_len,
u64 offset, struct dentry *dentry)
{
const u8 *p;
p = get_u64(p, &inode->last_write_time);
p = get_bytes(p, SHA1_HASH_SIZE, inode->hash);
-
+
/*
* 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
/* By the way, the reparse_reserved field does not actually exist (at
* least when the file is not a reparse point) */
-
+
p = get_u16(p, &inode->num_ads);
p = get_u16(p, &short_name_len);
p = get_u16(p, &file_name_len);
/* We now know the length of the file name and short name. Make sure
- * the length of the dentry is large enough to actually hold them.
+ * 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
if (dentry->length < calculated_size) {
ERROR("Unexpected end of directory entry! (Expected "
"at least %"PRIu64" bytes, got %"PRIu64" bytes. "
- "short_name_len = %hu, file_name_len = %hu)",
+ "short_name_len = %hu, file_name_len = %hu)",
calculated_size, dentry->length,
short_name_len, file_name_len);
return WIMLIB_ERR_INVALID_DENTRY;
p = get_bytes(p, file_name_len, file_name);
/* Convert filename to UTF-8. */
- file_name_utf8 = utf16_to_utf8(file_name, file_name_len,
+ file_name_utf8 = utf16_to_utf8(file_name, file_name_len,
&file_name_utf8_len);
if (!file_name_utf8) {
p += 2;
}
- /*
+ /*
* Read the alternate data streams, if present. dentry->num_ads tells
* us how many they are, and they will directly follow the dentry
* on-disk.
struct dentry cur_child;
int ret;
- /*
+ /*
* If @dentry has no child dentries, nothing more needs to be done for
* this branch. This is the case for regular files, symbolic links, and
* *possibly* empty directories (although an empty directory may also
while (1) {
/* Read next child of @dentry into @cur_child. */
- ret = read_dentry(metadata_resource, metadata_resource_len,
+ ret = read_dentry(metadata_resource, metadata_resource_len,
cur_offset, &cur_child);
if (ret != 0)
break;
/* If there are children of this child, call this procedure
* recursively. */
if (child->subdir_offset != 0) {
- ret = read_dentry_tree(metadata_resource,
+ ret = read_dentry_tree(metadata_resource,
metadata_resource_len, child);
if (ret != 0)
break;
return ret;
}
-/*
+/*
* Writes a WIM dentry to an output buffer.
*
* @dentry: The dentry structure.
if (parent->subdir_offset == 0)
return p;
- /* Write child dentries and end-of-directory entry.
+ /* Write child dentries and end-of-directory entry.
*
* Note: we need to write all of this dentry's children before
* recursively writing the directory trees rooted at each of the child
git://wimlib.net / wimlib / blobdiff