X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fntfs-capture.c;h=cd534a21cb507c8533a1f5e3d7c44d7011053a0a;hp=08868419b82dbf34b6c79cb60a6d49e331ea33fb;hb=20dac4a44f74de14a71c2445d23f79cf56728cfe;hpb=491079f27a268fb9e5bc7f54a7cbe3fbb9fa2d94 diff --git a/src/ntfs-capture.c b/src/ntfs-capture.c index 08868419..cd534a21 100644 --- a/src/ntfs-capture.c +++ b/src/ntfs-capture.c @@ -2,8 +2,7 @@ * ntfs-capture.c * * Capture a WIM image from a NTFS volume. We capture everything we can, - * including security data and alternate data streams. There should be no loss - * of information. + * including security data and alternate data streams. */ /* @@ -12,16 +11,16 @@ * This file is part of wimlib, a library for working with WIM files. * * wimlib is free software; you can redistribute it and/or modify it under the - * terms of the GNU Lesser General Public License as published by the Free - * Software Foundation; either version 2.1 of the License, or (at your option) + * terms of the GNU General Public License as published by the Free + * Software Foundation; either version 3 of the License, or (at your option) * any later version. * * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR - * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + * A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * - * You should have received a copy of the GNU Lesser General Public License + * You should have received a copy of the GNU General Public License * along with wimlib; if not, see http://www.gnu.org/licenses/. */ @@ -38,15 +37,19 @@ #include #include #include -#include +#include /* security.h before xattrs.h */ +#include #include #include #include +#include -extern int ntfs_inode_get_security(ntfs_inode *ni, u32 selection, char *buf, +#if 0 +extern int ntfs_get_inode_security(ntfs_inode *ni, u32 selection, char *buf, u32 buflen, u32 *psize); -extern int ntfs_inode_get_attributes(ntfs_inode *ni); +extern u32 ntfs_get_inode_attributes(ntfs_inode *ni); +#endif /* Structure that allows searching the security descriptors by SHA1 message * digest. */ @@ -63,15 +66,19 @@ struct sd_node { struct sd_node *right; }; -/* Frees a security descriptor index tree. */ -static void free_sd_set(struct sd_node *root) +static void free_sd_tree(struct sd_node *root) { if (root) { - free_sd_set(root->left); - free_sd_set(root->right); + free_sd_tree(root->left); + free_sd_tree(root->right); FREE(root); } } +/* Frees a security descriptor index set. */ +static void destroy_sd_set(struct sd_set *sd_set) +{ + free_sd_tree(sd_set->root); +} /* Inserts a a new node into the security descriptor index tree. */ static void insert_sd_node(struct sd_node *new, struct sd_node *root) @@ -117,7 +124,7 @@ static int lookup_sd(const u8 hash[SHA1_HASH_SIZE], struct sd_node *root) * the security ID for it. If a new security descriptor cannot be allocated, * return -1. */ -static int sd_set_add_sd(struct sd_set *sd_set, const u8 *descriptor, +static int sd_set_add_sd(struct sd_set *sd_set, const char descriptor[], size_t size) { u8 hash[SHA1_HASH_SIZE]; @@ -127,7 +134,8 @@ static int sd_set_add_sd(struct sd_set *sd_set, const u8 *descriptor, u64 *sizes; u8 *descr_copy; struct wim_security_data *sd; - sha1_buffer(descriptor, size, hash); + + sha1_buffer((const u8*)descriptor, size, hash); security_id = lookup_sd(hash, sd_set->root); if (security_id >= 0) @@ -162,10 +170,11 @@ static int sd_set_add_sd(struct sd_set *sd_set, const u8 *descriptor, sd->descriptors[sd->num_entries] = descr_copy; sd->sizes[sd->num_entries] = size; sd->num_entries++; + DEBUG("There are now %d security descriptors", sd->num_entries); sd->total_length += size + sizeof(sd->sizes[0]); if (sd_set->root) - insert_sd_node(sd_set->root, new); + insert_sd_node(new, sd_set->root); else sd_set->root = new; return new->security_id; @@ -187,11 +196,15 @@ static inline ntfschar *attr_record_name(ATTR_RECORD *ar) * @ni: The NTFS inode containing the attribute. * @ar: The ATTR_RECORD describing the attribute. * @md: If successful, the returned SHA1 message digest. + * @reparse_tag_ret: Optional pointer into which the first 4 bytes of the + * attribute will be written (to get the reparse + * point ID) * * Return 0 on success or nonzero on error. */ static int ntfs_attr_sha1sum(ntfs_inode *ni, ATTR_RECORD *ar, - u8 md[SHA1_HASH_SIZE]) + u8 md[SHA1_HASH_SIZE], + u32 *reparse_tag_ret) { s64 pos = 0; s64 bytes_remaining; @@ -209,12 +222,17 @@ static int ntfs_attr_sha1sum(ntfs_inode *ni, ATTR_RECORD *ar, bytes_remaining = na->data_size; sha1_init(&ctx); + DEBUG2("Calculating SHA1 message digest (%"PRIu64" bytes)", + bytes_remaining); + while (bytes_remaining) { s64 to_read = min(bytes_remaining, sizeof(buf)); if (ntfs_attr_pread(na, pos, to_read, buf) != to_read) { ERROR_WITH_ERRNO("Error reading NTFS attribute"); return WIMLIB_ERR_NTFS_3G; } + if (bytes_remaining == na->data_size && reparse_tag_ret) + *reparse_tag_ret = le32_to_cpu(*(u32*)buf); sha1_update(&ctx, buf, to_read); pos += to_read; bytes_remaining -= to_read; @@ -235,14 +253,16 @@ static int capture_ntfs_streams(struct dentry *dentry, ntfs_inode *ni, ntfs_attr_search_ctx *actx; u8 attr_hash[SHA1_HASH_SIZE]; - struct ntfs_location *ntfs_loc; - struct lookup_table_entry *lte; + struct ntfs_location *ntfs_loc = NULL; int ret = 0; + struct lookup_table_entry *lte; + + DEBUG2("Capturing NTFS data streams from `%s'", path); /* Get context to search the streams of the NTFS file. */ actx = ntfs_attr_get_search_ctx(ni, NULL); if (!actx) { - ERROR_WITH_ERRNO("Cannot get attribute search " + ERROR_WITH_ERRNO("Cannot get NTFS attribute search " "context"); return WIMLIB_ERR_NTFS_3G; } @@ -253,62 +273,104 @@ static int capture_ntfs_streams(struct dentry *dentry, ntfs_inode *ni, { char *stream_name_utf8; size_t stream_name_utf16_len; - - /* Checksum the stream. */ - ret = ntfs_attr_sha1sum(ni, actx->attr, attr_hash); - if (ret != 0) - goto out_put_actx; - - /* Make a lookup table entry for the stream, or use an existing - * one if there's already an identical stream. */ - lte = __lookup_resource(lookup_table, attr_hash); - ret = WIMLIB_ERR_NOMEM; - if (lte) { - lte->refcnt++; + u32 reparse_tag; + u64 data_size = ntfs_get_attribute_value_length(actx->attr); + u64 name_length = actx->attr->name_length; + + if (data_size == 0) { + if (errno != 0) { + ERROR_WITH_ERRNO("Failed to get size of attribute of " + "`%s'", path); + ret = WIMLIB_ERR_NTFS_3G; + goto out_put_actx; + } + /* Empty stream. No lookup table entry is needed. */ + lte = NULL; } else { - struct ntfs_location *ntfs_loc; - - - ntfs_loc = CALLOC(1, sizeof(*ntfs_loc)); - if (!ntfs_loc) + if (type == AT_REPARSE_POINT && data_size < 8) { + ERROR("`%s': reparse point buffer too small"); + ret = WIMLIB_ERR_NTFS_3G; goto out_put_actx; - ntfs_loc->ntfs_vol_p = ntfs_vol_p; - ntfs_loc->path_utf8 = MALLOC(path_len + 1); - if (!ntfs_loc->path_utf8) - goto out_free_ntfs_loc; - memcpy(ntfs_loc->path_utf8, path, path_len + 1); - ntfs_loc->stream_name_utf16 = MALLOC(actx->attr->name_length * 2); - if (!ntfs_loc->stream_name_utf16) - goto out_free_ntfs_loc; - memcpy(ntfs_loc->stream_name_utf16, - attr_record_name(actx->attr), - actx->attr->name_length * 2); - - ntfs_loc->stream_name_utf16_num_chars = actx->attr->name_length; - lte = new_lookup_table_entry(); - if (!lte) - goto out_free_ntfs_loc; - lte->ntfs_loc = ntfs_loc; - lte->resource_location = RESOURCE_IN_NTFS_VOLUME; - lte->resource_entry.original_size = actx->attr->data_size; - lte->resource_entry.size = actx->attr->data_size; - copy_hash(lte->hash, attr_hash); - lookup_table_insert(lookup_table, lte); + } + /* Checksum the stream. */ + ret = ntfs_attr_sha1sum(ni, actx->attr, attr_hash, &reparse_tag); + if (ret != 0) + goto out_put_actx; + + /* Make a lookup table entry for the stream, or use an existing + * one if there's already an identical stream. */ + lte = __lookup_resource(lookup_table, attr_hash); + ret = WIMLIB_ERR_NOMEM; + if (lte) { + lte->refcnt++; + } else { + ntfs_loc = CALLOC(1, sizeof(*ntfs_loc)); + if (!ntfs_loc) + goto out_put_actx; + ntfs_loc->ntfs_vol_p = ntfs_vol_p; + ntfs_loc->path_utf8 = MALLOC(path_len + 1); + if (!ntfs_loc->path_utf8) + goto out_free_ntfs_loc; + memcpy(ntfs_loc->path_utf8, path, path_len + 1); + if (name_length) { + ntfs_loc->stream_name_utf16 = MALLOC(name_length * 2); + if (!ntfs_loc->stream_name_utf16) + goto out_free_ntfs_loc; + memcpy(ntfs_loc->stream_name_utf16, + attr_record_name(actx->attr), + actx->attr->name_length * 2); + ntfs_loc->stream_name_utf16_num_chars = name_length; + } + + lte = new_lookup_table_entry(); + if (!lte) + goto out_free_ntfs_loc; + lte->ntfs_loc = ntfs_loc; + lte->resource_location = RESOURCE_IN_NTFS_VOLUME; + if (type == AT_REPARSE_POINT) { + dentry->reparse_tag = reparse_tag; + ntfs_loc->is_reparse_point = true; + lte->resource_entry.original_size = data_size - 8; + lte->resource_entry.size = data_size - 8; + } else { + ntfs_loc->is_reparse_point = false; + lte->resource_entry.original_size = data_size; + lte->resource_entry.size = data_size; + } + ntfs_loc = NULL; + DEBUG("Add resource for `%s' (size = %zu)", + dentry->file_name_utf8, + lte->resource_entry.original_size); + copy_hash(lte->hash, attr_hash); + lookup_table_insert(lookup_table, lte); + } } - if (actx->attr->name_length == 0) { - wimlib_assert(!dentry->lte); + if (name_length == 0) { + /* Unnamed data stream. Put the reference to it in the + * dentry. */ + if (dentry->lte) { + ERROR("Found two un-named data streams for " + "`%s'", path); + ret = WIMLIB_ERR_NTFS_3G; + goto out_free_lte; + } dentry->lte = lte; } else { + /* Named data stream. Put the reference to it in the + * alternate data stream entries */ struct ads_entry *new_ads_entry; - stream_name_utf8 = utf16_to_utf8((const u8*)attr_record_name(actx->attr), - actx->attr->name_length, - &stream_name_utf16_len); + size_t stream_name_utf8_len; + stream_name_utf8 = utf16_to_utf8((const char*)attr_record_name(actx->attr), + name_length * 2, + &stream_name_utf8_len); if (!stream_name_utf8) goto out_free_lte; - FREE(stream_name_utf8); new_ads_entry = dentry_add_ads(dentry, stream_name_utf8); + FREE(stream_name_utf8); if (!new_ads_entry) goto out_free_lte; + + wimlib_assert(new_ads_entry->stream_name_len == name_length * 2); new_ads_entry->lte = lte; } @@ -325,44 +387,64 @@ out_free_ntfs_loc: } out_put_actx: ntfs_attr_put_search_ctx(actx); + if (ret == 0) + DEBUG2("Successfully captured NTFS streams from `%s'", path); + else + ERROR("Failed to capture NTFS streams from `%s", path); return ret; } struct readdir_ctx { - struct dentry *dentry; + struct dentry *parent; ntfs_inode *dir_ni; char *path; size_t path_len; struct lookup_table *lookup_table; struct sd_set *sd_set; + const struct capture_config *config; ntfs_volume **ntfs_vol_p; + int flags; }; -static int __build_dentry_tree_ntfs(struct dentry *dentry, ntfs_inode *ni, - char path[], size_t path_len, - struct lookup_table *lookup_table, - struct sd_set *sd_set, - ntfs_volume **ntfs_vol_p); - - -static int filldir(void *dirent, const ntfschar *name, - const int name_len, const int name_type, const s64 pos, - const MFT_REF mref, const unsigned dt_type) +static int +build_dentry_tree_ntfs_recursive(struct dentry **root_p, ntfs_inode *dir_ni, + ntfs_inode *ni, char path[], size_t path_len, + int name_type, + struct lookup_table *lookup_table, + struct sd_set *sd_set, + const struct capture_config *config, + ntfs_volume **ntfs_vol_p, + int flags); + +static int wim_ntfs_capture_filldir(void *dirent, const ntfschar *name, + const int name_len, const int name_type, + const s64 pos, const MFT_REF mref, + const unsigned dt_type) { struct readdir_ctx *ctx; size_t utf8_name_len; char *utf8_name; - struct dentry *child; + struct dentry *child = NULL; int ret; size_t path_len; + if (name_type == FILE_NAME_DOS) + return 0; + ret = -1; - utf8_name = utf16_to_utf8((const u8*)name, name_len * 2, + utf8_name = utf16_to_utf8((const char*)name, name_len * 2, &utf8_name_len); if (!utf8_name) goto out; + if (utf8_name[0] == '.' && + (utf8_name[1] == '\0' || + (utf8_name[1] == '.' && utf8_name[2] == '\0'))) { + ret = 0; + goto out_free_utf8_name; + } + ctx = dirent; ntfs_inode *ni = ntfs_inode_open(ctx->dir_ni->vol, mref); @@ -370,17 +452,20 @@ static int filldir(void *dirent, const ntfschar *name, ERROR_WITH_ERRNO("Failed to open NTFS inode"); ret = 1; } - child = new_dentry(utf8_name); - if (!child) - goto out_close_ni; - - memcpy(ctx->path + ctx->path_len, utf8_name, utf8_name_len + 1); - path_len = ctx->path_len + utf8_name_len; - ret = __build_dentry_tree_ntfs(child, ni, ctx->path, path_len, - ctx->lookup_table, ctx->sd_set, - ctx->ntfs_vol_p); - link_dentry(child, ctx->dentry); -out_close_ni: + path_len = ctx->path_len; + if (path_len != 1) + ctx->path[path_len++] = '/'; + memcpy(ctx->path + path_len, utf8_name, utf8_name_len + 1); + path_len += utf8_name_len; + ret = build_dentry_tree_ntfs_recursive(&child, ctx->dir_ni, + ni, ctx->path, path_len, name_type, + ctx->lookup_table, ctx->sd_set, + ctx->config, ctx->ntfs_vol_p, + ctx->flags); + + if (child) + link_dentry(child, ctx->parent); + ntfs_inode_close(ni); out_free_utf8_name: FREE(utf8_name); @@ -388,92 +473,233 @@ out: return ret; } +static int change_dentry_short_name(struct dentry *dentry, + const char short_name_utf8[], + int short_name_utf8_len) +{ + size_t short_name_utf16_len; + char *short_name_utf16; + short_name_utf16 = utf8_to_utf16(short_name_utf8, short_name_utf8_len, + &short_name_utf16_len); + if (!short_name_utf16) { + ERROR_WITH_ERRNO("Failed to convert short name to UTF-16"); + return WIMLIB_ERR_NOMEM; + } + dentry->short_name = short_name_utf16; + dentry->short_name_len = short_name_utf16_len; + return 0; +} + +/*#define HAVE_NTFS_INODE_FUNCTIONS*/ + /* Recursively build a WIM dentry tree corresponding to a NTFS volume. * At the same time, update the WIM lookup table with lookup table entries for * the NTFS streams, and build an array of security descriptors. */ -static int __build_dentry_tree_ntfs(struct dentry *dentry, ntfs_inode *ni, - char path[], size_t path_len, - struct lookup_table *lookup_table, - struct sd_set *sd_set, - ntfs_volume **ntfs_vol_p) +static int build_dentry_tree_ntfs_recursive(struct dentry **root_p, + ntfs_inode *dir_ni, + ntfs_inode *ni, + char path[], + size_t path_len, + int name_type, + struct lookup_table *lookup_table, + struct sd_set *sd_set, + const struct capture_config *config, + ntfs_volume **ntfs_vol_p, + int flags) { - u32 attributes = ntfs_inode_get_attributes(ni); - int mrec_flags = ni->mrec->flags; - u32 sd_size; - int ret = 0; + u32 attributes; + int mrec_flags; + u32 sd_size = 0; + int ret; + char dos_name_utf8[64]; + struct dentry *root; + + mrec_flags = ni->mrec->flags; +#ifdef HAVE_NTFS_INODE_FUNCTIONS + attributes = ntfs_get_inode_attributes(ni); +#else + struct SECURITY_CONTEXT ctx; + memset(&ctx, 0, sizeof(ctx)); + ctx.vol = ni->vol; + ret = ntfs_xattr_system_getxattr(&ctx, XATTR_NTFS_ATTRIB, + ni, dir_ni, (char *)&attributes, + sizeof(u32)); + if (ret != 4) { + ERROR_WITH_ERRNO("Failed to get NTFS attributes from `%s'", + path); + return WIMLIB_ERR_NTFS_3G; + } +#endif + + if (exclude_path(path, config, false)) { + if (flags & WIMLIB_ADD_IMAGE_FLAG_VERBOSE) { + const char *file_type; + if (attributes & MFT_RECORD_IS_DIRECTORY) + file_type = "directory"; + else + file_type = "file"; + printf("Excluding %s `%s' from capture\n", + file_type, path); + } + *root_p = NULL; + return 0; + } - dentry->creation_time = le64_to_cpu(ni->creation_time); - dentry->last_write_time = le64_to_cpu(ni->last_data_change_time); - dentry->last_access_time = le64_to_cpu(ni->last_access_time); - dentry->security_id = le32_to_cpu(ni->security_id); - dentry->attributes = le32_to_cpu(attributes); - dentry->hard_link = ni->mft_no; - dentry->resolved = true; + if (flags & WIMLIB_ADD_IMAGE_FLAG_VERBOSE) + printf("Scanning `%s'\n", path); + + root = new_dentry(path_basename(path)); + if (!root) + return WIMLIB_ERR_NOMEM; + *root_p = root; + + if (dir_ni && (name_type == FILE_NAME_WIN32_AND_DOS + || name_type == FILE_NAME_WIN32)) + { + ret = ntfs_get_ntfs_dos_name(ni, dir_ni, dos_name_utf8, + sizeof(dos_name_utf8)); + if (ret > 0) { + DEBUG("Changing short name of `%s'", path); + ret = change_dentry_short_name(root, dos_name_utf8, + ret); + if (ret != 0) + return ret; + } else { + if (errno != ENODATA) { + ERROR_WITH_ERRNO("Error getting DOS name " + "of `%s'", path); + return WIMLIB_ERR_NTFS_3G; + } + } + } + + root->creation_time = le64_to_cpu(ni->creation_time); + root->last_write_time = le64_to_cpu(ni->last_data_change_time); + root->last_access_time = le64_to_cpu(ni->last_access_time); + root->attributes = le32_to_cpu(attributes); + root->link_group_id = ni->mft_no; + root->resolved = true; if (attributes & FILE_ATTR_REPARSE_POINT) { /* Junction point, symbolic link, or other reparse point */ - ret = capture_ntfs_streams(dentry, ni, path, path_len, + ret = capture_ntfs_streams(root, ni, path, path_len, lookup_table, ntfs_vol_p, AT_REPARSE_POINT); } else if (mrec_flags & MFT_RECORD_IS_DIRECTORY) { + /* Normal directory */ s64 pos = 0; struct readdir_ctx ctx = { - .dentry = dentry, + .parent = root, .dir_ni = ni, .path = path, .path_len = path_len, .lookup_table = lookup_table, .sd_set = sd_set, + .config = config, .ntfs_vol_p = ntfs_vol_p, + .flags = flags, }; - ret = ntfs_readdir(ni, &pos, &ctx, filldir); - if (ret != 0) + ret = ntfs_readdir(ni, &pos, &ctx, wim_ntfs_capture_filldir); + if (ret != 0) { + ERROR_WITH_ERRNO("ntfs_readdir()"); ret = WIMLIB_ERR_NTFS_3G; + } } else { /* Normal file */ - ret = capture_ntfs_streams(dentry, ni, path, path_len, + ret = capture_ntfs_streams(root, ni, path, path_len, lookup_table, ntfs_vol_p, AT_DATA); } if (ret != 0) return ret; - ret = ntfs_inode_get_security(ni, + +#ifdef HAVE_NTFS_INODE_FUNCTIONS + ret = ntfs_get_inode_security(ni, OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION, NULL, 0, &sd_size); - u8 sd[sd_size]; - ret = ntfs_inode_get_security(ni, + char sd[sd_size]; + ret = ntfs_get_inode_security(ni, OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION, sd, sd_size, &sd_size); - dentry->security_id = sd_set_add_sd(sd_set, sd, sd_size); - if (dentry->security_id == -1) { - ERROR("Could not allocate security ID"); - ret = WIMLIB_ERR_NOMEM; + if (ret == 0) { + ERROR_WITH_ERRNO("Failed to get security information from " + "`%s'", path); + ret = WIMLIB_ERR_NTFS_3G; + } else { + if (ret > 0) { + /*print_security_descriptor(sd, sd_size);*/ + root->security_id = sd_set_add_sd(sd_set, sd, ret); + if (root->security_id == -1) { + ERROR("Out of memory"); + return WIMLIB_ERR_NOMEM; + } + DEBUG("Added security ID = %u for `%s'", + root->security_id, path); + } else { + root->security_id = -1; + DEBUG("No security ID for `%s'", path); + } + ret = 0; } +#else + char _sd[1]; + char *sd = _sd; + errno = 0; + ret = ntfs_xattr_system_getxattr(&ctx, XATTR_NTFS_ACL, + ni, dir_ni, sd, + sizeof(sd)); + if (ret > sizeof(sd)) { + sd = alloca(ret); + ret = ntfs_xattr_system_getxattr(&ctx, XATTR_NTFS_ACL, + ni, dir_ni, sd, ret); + } + if (ret > 0) { + root->security_id = sd_set_add_sd(sd_set, sd, ret); + if (root->security_id == -1) { + ERROR("Out of memory"); + return WIMLIB_ERR_NOMEM; + } + DEBUG("Added security ID = %u for `%s'", + root->security_id, path); + ret = 0; + } else if (ret < 0) { + ERROR_WITH_ERRNO("Failed to get security information from " + "`%s'", path); + ret = WIMLIB_ERR_NTFS_3G; + } else { + root->security_id = -1; + DEBUG("No security ID for `%s'", path); + } +#endif return ret; } -static int build_dentry_tree_ntfs(struct dentry *root_dentry, +static int build_dentry_tree_ntfs(struct dentry **root_p, const char *device, struct lookup_table *lookup_table, struct wim_security_data *sd, + const struct capture_config *config, int flags, void *extra_arg) { ntfs_volume *vol; ntfs_inode *root_ni; int ret = 0; - struct sd_set tree; - tree.sd = sd; - tree.root = NULL; + struct sd_set sd_set = { + .sd = sd, + .root = NULL, + }; ntfs_volume **ntfs_vol_p = extra_arg; + + DEBUG("Mounting NTFS volume `%s' read-only", device); vol = ntfs_mount(device, MS_RDONLY); if (!vol) { @@ -481,6 +707,14 @@ static int build_dentry_tree_ntfs(struct dentry *root_dentry, device); return WIMLIB_ERR_NTFS_3G; } + ntfs_open_secure(vol); + + /* We don't want to capture the special NTFS files such as $Bitmap. Not + * to be confused with "hidden" or "system" files which are real files + * that we do need to capture. */ + NVolClearShowSysFiles(vol); + + DEBUG("Opening root NTFS dentry"); root_ni = ntfs_inode_open(vol, FILE_root); if (!root_ni) { ERROR_WITH_ERRNO("Failed to open root inode of NTFS volume " @@ -488,44 +722,65 @@ static int build_dentry_tree_ntfs(struct dentry *root_dentry, ret = WIMLIB_ERR_NTFS_3G; goto out; } - char path[4096]; + + /* Currently we assume that all the UTF-8 paths fit into this length and + * there is no check for overflow. */ + char *path = MALLOC(32768); + if (!path) { + ERROR("Could not allocate memory for NTFS pathname"); + goto out_cleanup; + } + path[0] = '/'; path[1] = '\0'; - ret = __build_dentry_tree_ntfs(root_dentry, root_ni, path, 1, - lookup_table, &tree, ntfs_vol_p); + ret = build_dentry_tree_ntfs_recursive(root_p, NULL, root_ni, path, 1, + FILE_NAME_POSIX, lookup_table, + &sd_set, config, ntfs_vol_p, + flags); +out_cleanup: + FREE(path); ntfs_inode_close(root_ni); + destroy_sd_set(&sd_set); out: - if (ntfs_umount(vol, FALSE) != 0) { - ERROR_WITH_ERRNO("Failed to unmount NTFS volume `%s'", device); - if (ret == 0) - ret = WIMLIB_ERR_NTFS_3G; + if (ret) { + if (ntfs_umount(vol, FALSE) != 0) { + ERROR_WITH_ERRNO("Failed to unmount NTFS volume `%s'", + device); + if (ret == 0) + ret = WIMLIB_ERR_NTFS_3G; + } + } else { + /* We need to leave the NTFS volume mounted so that we can read + * the NTFS files again when we are actually writing the WIM */ + *ntfs_vol_p = vol; } return ret; } + + WIMLIBAPI int wimlib_add_image_from_ntfs_volume(WIMStruct *w, const char *device, const char *name, - const char *description, - const char *flags_element, + const char *config_str, + size_t config_len, int flags) { if (flags & (WIMLIB_ADD_IMAGE_FLAG_DEREFERENCE)) { ERROR("Cannot dereference files when capturing directly from NTFS"); return WIMLIB_ERR_INVALID_PARAM; } - return do_add_image(w, device, name, description, flags_element, flags, - build_dentry_tree_ntfs, - &w->ntfs_vol); + return do_add_image(w, device, name, config_str, config_len, flags, + build_dentry_tree_ntfs, &w->ntfs_vol); } #else /* WITH_NTFS_3G */ WIMLIBAPI int wimlib_add_image_from_ntfs_volume(WIMStruct *w, const char *device, const char *name, - const char *description, - const char *flags_element, + const char *config_str, + size_t config_len, int flags) { ERROR("wimlib was compiled without support for NTFS-3g, so");