X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fntfs-capture.c;h=9896cdcca70292aa10081d0f9457e4d6cfb9d264;hp=7c04e9b85b2410797212fb2aad119acce296eea1;hb=48c05c63f94c294d4b9982a228682c27e8d41dd2;hpb=16176f3b7ce78da85646e814bd2f3ffe5babb82b

diff --git a/src/ntfs-capture.c b/src/ntfs-capture.c
index 7c04e9b8..9896cdcc 100644
--- a/src/ntfs-capture.c
+++ b/src/ntfs-capture.c
@@ -58,79 +58,126 @@ attr_record_name(ATTR_RECORD *ar)
 	return (ntfschar*)((u8*)ar + le16_to_cpu(ar->name_offset));
 }
 
-/* Calculates the SHA1 message digest of a NTFS attribute.
- *
- * @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],
-		  bool is_reparse_point,
-		  u32 *reparse_tag_ret)
+static ntfs_attr *
+open_ntfs_attr(ntfs_inode *ni, struct ntfs_location *loc)
 {
-	s64 pos = 0;
-	s64 bytes_remaining;
-	char buf[BUFFER_SIZE];
 	ntfs_attr *na;
-	SHA_CTX ctx;
 
-	na = ntfs_attr_open(ni, ar->type, attr_record_name(ar),
-			    ar->name_length);
+	na = ntfs_attr_open(ni,
+			    loc->is_reparse_point ? AT_REPARSE_POINT : AT_DATA,
+			    loc->stream_name,
+			    loc->stream_name_nchars);
 	if (!na) {
-		ERROR_WITH_ERRNO("Failed to open NTFS attribute");
-		return WIMLIB_ERR_NTFS_3G;
+		ERROR_WITH_ERRNO("Failed to open attribute of \"%"TS"\" in "
+				 "NTFS volume", loc->path);
 	}
+	return na;
+}
 
-	bytes_remaining = na->data_size;
+int
+read_ntfs_file_prefix(const struct wim_lookup_table_entry *lte,
+		      u64 size,
+		      consume_data_callback_t cb,
+		      void *ctx_or_buf,
+		      int _ignored_flags)
+{
+	struct ntfs_location *loc = lte->ntfs_loc;
+	ntfs_volume *vol = loc->ntfs_vol;
+	ntfs_inode *ni;
+	ntfs_attr *na;
+	s64 pos;
+	s64 bytes_remaining;
+	void *out_buf;
+	int ret;
+
+ 	ni = ntfs_pathname_to_inode(vol, NULL, loc->path);
+	if (!ni) {
+		ERROR_WITH_ERRNO("Can't find NTFS inode for \"%"TS"\"", loc->path);
+		ret = WIMLIB_ERR_NTFS_3G;
+		goto out;
+	}
 
-	if (is_reparse_point) {
-		if (ntfs_attr_pread(na, 0, 8, buf) != 8)
-			goto out_error;
-		*reparse_tag_ret = le32_to_cpu(*(u32*)buf);
-		DEBUG("ReparseTag = %#x", *reparse_tag_ret);
-		pos = 8;
-		bytes_remaining -= 8;
+	na = open_ntfs_attr(ni, loc);
+	if (!na) {
+		ret = WIMLIB_ERR_NTFS_3G;
+		goto out_close_ntfs_inode;
 	}
 
-	sha1_init(&ctx);
+	if (cb)
+		out_buf = alloca(WIM_CHUNK_SIZE);
+	else
+		out_buf = ctx_or_buf;
+	pos = (loc->is_reparse_point) ? 8 : 0;
+	bytes_remaining = size;
 	while (bytes_remaining) {
-		s64 to_read = min(bytes_remaining, sizeof(buf));
-		if (ntfs_attr_pread(na, pos, to_read, buf) != to_read)
-			goto out_error;
-		sha1_update(&ctx, buf, to_read);
+		s64 to_read = min(bytes_remaining, WIM_CHUNK_SIZE);
+		if (ntfs_attr_pread(na, pos, to_read, out_buf) != to_read) {
+			ERROR_WITH_ERRNO("Error reading \"%"TS"\"", loc->path);
+			ret = WIMLIB_ERR_NTFS_3G;
+			goto out_close_ntfs_attr;
+		}
 		pos += to_read;
 		bytes_remaining -= to_read;
+		if (cb) {
+			ret = cb(out_buf, to_read, ctx_or_buf);
+			if (ret)
+				goto out_close_ntfs_attr;
+		} else {
+			out_buf += to_read;
+		}
 	}
-	sha1_final(md, &ctx);
+	ret = 0;
+out_close_ntfs_attr:
 	ntfs_attr_close(na);
-	return 0;
-out_error:
-	ERROR_WITH_ERRNO("Error reading NTFS attribute");
-	return WIMLIB_ERR_NTFS_3G;
+out_close_ntfs_inode:
+	ntfs_inode_close(ni);
+out:
+	return ret;
+}
+
+static int
+read_reparse_tag(ntfs_inode *ni, struct ntfs_location *loc,
+		 u32 *reparse_tag_ret)
+{
+	int ret;
+	u8 buf[8];
+	ntfs_attr *na;
+
+	na = open_ntfs_attr(ni, loc);
+	if (!na) {
+		ret = WIMLIB_ERR_NTFS_3G;
+		goto out;
+	}
+
+	if (ntfs_attr_pread(na, 0, 8, buf) != 8) {
+		ERROR_WITH_ERRNO("Error reading reparse data");
+		ret = WIMLIB_ERR_NTFS_3G;
+		goto out_close_ntfs_attr;
+	}
+	*reparse_tag_ret = le32_to_cpu(*(u32*)buf);
+	DEBUG("ReparseTag = %#x", *reparse_tag_ret);
+	ret = 0;
+out_close_ntfs_attr:
+	ntfs_attr_close(na);
+out:
+	return ret;
+
 }
 
 /* Load the streams from a file or reparse point in the NTFS volume into the WIM
  * lookup table */
 static int
-capture_ntfs_streams(struct wim_dentry *dentry,
+capture_ntfs_streams(struct wim_inode *inode,
 		     ntfs_inode *ni,
-		     mbchar *path,
+		     char *path,
 		     size_t path_len,
 		     struct wim_lookup_table *lookup_table,
-		     ntfs_volume **ntfs_vol_p,
+		     ntfs_volume *vol,
 		     ATTR_TYPES type)
 {
 	ntfs_attr_search_ctx *actx;
-	u8 attr_hash[SHA1_HASH_SIZE];
-	struct ntfs_location *ntfs_loc = NULL;
-	int ret = 0;
+	struct ntfs_location *ntfs_loc;
+	int ret;
 	struct wim_lookup_table_entry *lte;
 
 	DEBUG2("Capturing NTFS data streams from `%s'", path);
@@ -147,103 +194,104 @@ capture_ntfs_streams(struct wim_dentry *dentry,
 	while (!ntfs_attr_lookup(type, NULL, 0,
 				 CASE_SENSITIVE, 0, NULL, 0, actx))
 	{
-		u32 reparse_tag;
 		u64 data_size = ntfs_get_attribute_value_length(actx->attr);
 		u64 name_length = actx->attr->name_length;
+		u32 stream_id;
+
 		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;
+			ntfs_loc = NULL;
 		} else {
-			if (type == AT_REPARSE_POINT && data_size < 8) {
-				ERROR("`%s': reparse point buffer too small",
-				      path);
-				ret = WIMLIB_ERR_NTFS_3G;
+			ntfs_loc = CALLOC(1, sizeof(*ntfs_loc));
+			if (!ntfs_loc) {
+				ret = WIMLIB_ERR_NOMEM;
 				goto out_put_actx;
 			}
-			/* Checksum the stream. */
-			ret = ntfs_attr_sha1sum(ni, actx->attr, attr_hash,
-						type == AT_REPARSE_POINT, &reparse_tag);
-			if (ret != 0)
-				goto out_put_actx;
-
-			if (type == AT_REPARSE_POINT)
-				dentry->d_inode->i_reparse_tag = reparse_tag;
-
-			/* 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 = MALLOC(path_len + 1);
-				if (!ntfs_loc->path)
+			ntfs_loc->ntfs_vol = vol;
+			ntfs_loc->path = MALLOC(path_len + 1);
+			if (!ntfs_loc->path) {
+				ret = WIMLIB_ERR_NOMEM;
+				goto out_free_ntfs_loc;
+			}
+			memcpy(ntfs_loc->path, path, path_len + 1);
+			if (name_length) {
+				ntfs_loc->stream_name = MALLOC(name_length * 2);
+				if (!ntfs_loc->stream_name) {
+					ret = WIMLIB_ERR_NOMEM;
 					goto out_free_ntfs_loc;
-				memcpy(ntfs_loc->path, path, path_len + 1);
-				if (name_length) {
-					ntfs_loc->stream_name = MALLOC(name_length * 2);
-					if (!ntfs_loc->stream_name)
-						goto out_free_ntfs_loc;
-					memcpy(ntfs_loc->stream_name,
-					       attr_record_name(actx->attr),
-					       actx->attr->name_length * 2);
-					ntfs_loc->stream_name_nchars = name_length;
 				}
+				memcpy(ntfs_loc->stream_name,
+				       attr_record_name(actx->attr),
+				       actx->attr->name_length * 2);
+				ntfs_loc->stream_name_nchars = 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) {
-					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;
+			lte = new_lookup_table_entry();
+			if (!lte) {
+				ret = WIMLIB_ERR_NOMEM;
+				goto out_free_ntfs_loc;
+			}
+			lte->resource_location = RESOURCE_IN_NTFS_VOLUME;
+			lte->ntfs_loc = ntfs_loc;
+			ntfs_loc = NULL;
+			if (type == AT_REPARSE_POINT) {
+				if (data_size < 8) {
+					ERROR("Invalid reparse data (only %u bytes)!",
+					      (unsigned)data_size);
+					ret = WIMLIB_ERR_NTFS_3G;
+					goto out_free_lte;
 				}
-				ntfs_loc = NULL;
-				copy_hash(lte->hash, attr_hash);
-				lookup_table_insert(lookup_table, lte);
+				lte->ntfs_loc->is_reparse_point = true;
+				lte->resource_entry.original_size = data_size - 8;
+				ret = read_reparse_tag(ni, lte->ntfs_loc,
+						       &inode->i_reparse_tag);
+				if (ret)
+					goto out_free_lte;
+			} else {
+				lte->ntfs_loc->is_reparse_point = false;
+				lte->resource_entry.original_size = data_size;
 			}
 		}
 		if (name_length == 0) {
 			/* Unnamed data stream.  Put the reference to it in the
 			 * dentry's inode. */
-			if (dentry->d_inode->i_lte) {
-				WARNING("Found two un-named data streams for "
-					"`%s'", path);
-				free_lookup_table_entry(lte);
-			} else {
-				dentry->d_inode->i_lte = lte;
+			if (inode->i_lte) {
+				ERROR("Found two un-named data streams for `%s'",
+				      path);
+				ret = WIMLIB_ERR_NTFS_3G;
+				goto out_free_lte;
 			}
+			stream_id = 0;
+			inode->i_lte = lte;
 		} else {
 			/* Named data stream.  Put the reference to it in the
 			 * alternate data stream entries */
 			struct wim_ads_entry *new_ads_entry;
 
-			new_ads_entry = inode_add_ads_utf16le(dentry->d_inode,
+			new_ads_entry = inode_add_ads_utf16le(inode,
 							      attr_record_name(actx->attr),
 							      name_length * 2);
-			if (!new_ads_entry)
+			if (!new_ads_entry) {
+				ret = WIMLIB_ERR_NOMEM;
 				goto out_free_lte;
+			}
 			wimlib_assert(new_ads_entry->stream_name_nbytes == name_length * 2);
+			stream_id = new_ads_entry->stream_id;
 			new_ads_entry->lte = lte;
 		}
+		if (lte) {
+			lookup_table_insert_unhashed(lookup_table, lte,
+						     inode, stream_id);
+		}
+	}
+	if (errno == ENOENT) {
+		ret = 0;
+	} else {
+		ERROR_WITH_ERRNO("Error listing NTFS attributes from `%s'",
+				 path);
+		ret = WIMLIB_ERR_NTFS_3G;
 	}
-	ret = 0;
 	goto out_put_actx;
 out_free_lte:
 	free_lookup_table_entry(lte);
@@ -258,7 +306,7 @@ out_put_actx:
 	if (ret == 0)
 		DEBUG2("Successfully captured NTFS streams from `%s'", path);
 	else
-		ERROR("Failed to capture NTFS streams from `%s", path);
+		ERROR("Failed to capture NTFS streams from `%s'", path);
 	return ret;
 }
 
@@ -382,7 +430,7 @@ free_dos_name_tree(struct rb_node *node) {
 	}
 }
 
-static void 
+static void
 destroy_dos_name_map(struct dos_name_map *map)
 {
 	free_dos_name_tree(map->rb_root.rb_node);
@@ -391,27 +439,22 @@ destroy_dos_name_map(struct dos_name_map *map)
 struct readdir_ctx {
 	struct wim_dentry *parent;
 	ntfs_inode *dir_ni;
-	mbchar *path;
+	char *path;
 	size_t path_len;
-	struct wim_lookup_table	*lookup_table;
-	struct sd_set *sd_set;
 	struct dos_name_map *dos_name_map;
-	const struct capture_config *config;
-	ntfs_volume **ntfs_vol_p;
-	int add_image_flags;
-	wimlib_progress_func_t progress_func;
+	ntfs_volume *vol;
+	struct add_image_params *params;
 };
 
 static int
-build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p, ntfs_inode *dir_ni,
-				 ntfs_inode *ni, char path[], size_t path_len,
+build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p,
+				 ntfs_inode *dir_ni,
+				 ntfs_inode *ni,
+				 char *path,
+				 size_t path_len,
 				 int name_type,
-				 struct wim_lookup_table *lookup_table,
-				 struct sd_set *sd_set,
-				 const struct capture_config *config,
-				 ntfs_volume **ntfs_vol_p,
-				 int add_image_flags,
-				 wimlib_progress_func_t progress_func);
+				 ntfs_volume *ntfs_vol,
+				 struct add_image_params *params);
 
 static int
 wim_ntfs_capture_filldir(void *dirent, const ntfschar *name,
@@ -436,12 +479,12 @@ wim_ntfs_capture_filldir(void *dirent, const ntfschar *name,
 		/* Return now if an error occurred or if this is just a DOS name
 		 * and not a Win32+DOS name. */
 		if (ret != 0 || name_type == FILE_NAME_DOS)
-			return ret;
+			goto out;
 	}
-	ret = utf16le_to_mbs(name, name_nbytes,
-			     &mbs_name, &mbs_name_nbytes);
-	if (ret != 0)
-		return -1;
+	ret = utf16le_to_tstr(name, name_nbytes,
+			      &mbs_name, &mbs_name_nbytes);
+	if (ret)
+		goto out;
 
 	if (mbs_name[0] == '.' &&
 	     (mbs_name[1] == '\0' ||
@@ -459,6 +502,7 @@ wim_ntfs_capture_filldir(void *dirent, const ntfschar *name,
 	ntfs_inode *ni = ntfs_inode_open(ctx->dir_ni->vol, mref);
 	if (!ni) {
 		ERROR_WITH_ERRNO("Failed to open NTFS inode");
+		ret = -1;
 		goto out_free_mbs_name;
 	}
 	path_len = ctx->path_len;
@@ -469,15 +513,13 @@ wim_ntfs_capture_filldir(void *dirent, const ntfschar *name,
 	child = NULL;
 	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->add_image_flags,
-					       ctx->progress_func);
+					       ctx->vol, ctx->params);
 	if (child)
 		dentry_add_child(ctx->parent, child);
 	ntfs_inode_close(ni);
 out_free_mbs_name:
 	FREE(mbs_name);
+out:
 	return ret;
 }
 
@@ -486,42 +528,41 @@ out_free_mbs_name:
  * the NTFS streams, and build an array of security descriptors.
  */
 static int
-build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p,
+build_dentry_tree_ntfs_recursive(struct wim_dentry **root_ret,
 				 ntfs_inode *dir_ni,
 				 ntfs_inode *ni,
-				 mbchar *path,
+				 char *path,
 				 size_t path_len,
 				 int name_type,
-				 struct wim_lookup_table *lookup_table,
-				 struct sd_set *sd_set,
-				 const struct capture_config *config,
-				 ntfs_volume **ntfs_vol_p,
-				 int add_image_flags,
-				 wimlib_progress_func_t progress_func)
+				 ntfs_volume *vol,
+				 struct add_image_params *params)
 {
 	u32 attributes;
 	int ret;
 	struct wim_dentry *root;
+	struct wim_inode *inode;
+	ATTR_TYPES stream_type;
 
-	if (exclude_path(path, config, false)) {
+	if (exclude_path(path, path_len, params->config, false)) {
 		/* Exclude a file or directory tree based on the capture
 		 * configuration file */
-		if ((add_image_flags & WIMLIB_ADD_IMAGE_FLAG_VERBOSE)
-		    && progress_func)
+		if ((params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_EXCLUDE_VERBOSE)
+		    && params->progress_func)
 		{
 			union wimlib_progress_info info;
 			info.scan.cur_path = path;
 			info.scan.excluded = true;
-			progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info);
+			params->progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info);
 		}
-		*root_p = NULL;
-		return 0;
+		root = NULL;
+		ret = 0;
+		goto out;
 	}
 
 	/* Get file attributes */
 	struct SECURITY_CONTEXT ctx;
 	memset(&ctx, 0, sizeof(ctx));
-	ctx.vol = ni->vol;
+	ctx.vol = vol;
 	ret = ntfs_xattr_system_getxattr(&ctx, XATTR_NTFS_ATTRIB,
 					 ni, dir_ni, (char *)&attributes,
 					 sizeof(u32));
@@ -531,39 +572,55 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p,
 		return WIMLIB_ERR_NTFS_3G;
 	}
 
-	if ((add_image_flags & WIMLIB_ADD_IMAGE_FLAG_VERBOSE)
-	    && progress_func)
+	if ((params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_VERBOSE)
+	    && params->progress_func)
 	{
 		union wimlib_progress_info info;
 		info.scan.cur_path = path;
 		info.scan.excluded = false;
-		progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info);
+		params->progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info);
 	}
 
-	/* Create the new WIM dentry */
-	ret = new_dentry_with_timeless_inode(path_basename(path), &root);
+	/* Create a WIM dentry with an associated inode, which may be shared */
+	ret = inode_table_new_dentry(params->inode_table,
+				     path_basename_with_len(path, path_len),
+				     ni->mft_no, 0, false, &root);
 	if (ret)
 		return ret;
 
-	*root_p = root;
+	inode = root->d_inode;
+
+	if (inode->i_nlink > 1) /* Shared inode; nothing more to do */
+		goto out;
 
-	if (name_type & FILE_NAME_WIN32) /* Win32 or Win32+DOS name */
+	if (name_type & FILE_NAME_WIN32) /* Win32 or Win32+DOS name (rather than POSIX) */
 		root->is_win32_name = 1;
-	root->d_inode->i_creation_time    = le64_to_cpu(ni->creation_time);
-	root->d_inode->i_last_write_time  = le64_to_cpu(ni->last_data_change_time);
-	root->d_inode->i_last_access_time = le64_to_cpu(ni->last_access_time);
-	root->d_inode->i_attributes       = le32_to_cpu(attributes);
-	root->d_inode->i_ino              = ni->mft_no;
-	root->d_inode->i_resolved         = 1;
-
-	if (attributes & FILE_ATTR_REPARSE_POINT) {
-		/* Junction point, symbolic link, or other reparse point */
-		ret = capture_ntfs_streams(root, ni, path, path_len,
-					   lookup_table, ntfs_vol_p,
-					   AT_REPARSE_POINT);
-	} else if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY) {
-
-		/* Normal directory */
+	inode->i_creation_time    = le64_to_cpu(ni->creation_time);
+	inode->i_last_write_time  = le64_to_cpu(ni->last_data_change_time);
+	inode->i_last_access_time = le64_to_cpu(ni->last_access_time);
+	inode->i_attributes       = le32_to_cpu(attributes);
+	inode->i_resolved         = 1;
+
+	if (attributes & FILE_ATTR_REPARSE_POINT)
+		stream_type = AT_REPARSE_POINT;
+	else
+		stream_type = AT_DATA;
+
+	/* Capture the file's streams; more specifically, this is supposed to:
+	 *
+	 * - Regular files: capture unnamed data stream and any named data
+	 *   streams
+	 * - Directories: capture any named data streams
+	 * - Reparse points: capture reparse data only
+	 */
+	ret = capture_ntfs_streams(inode, ni, path, path_len,
+				   params->lookup_table, vol, stream_type);
+	if (ret)
+		goto out;
+
+	if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY) {
+
+		/* Recurse to directory children */
 		s64 pos = 0;
 		struct dos_name_map dos_name_map = { .rb_root = {.rb_node = NULL} };
 		struct readdir_ctx ctx = {
@@ -571,13 +628,9 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p,
 			.dir_ni          = ni,
 			.path            = path,
 			.path_len        = path_len,
-			.lookup_table    = lookup_table,
-			.sd_set          = sd_set,
 			.dos_name_map    = &dos_name_map,
-			.config          = config,
-			.ntfs_vol_p      = ntfs_vol_p,
-			.add_image_flags = add_image_flags,
-			.progress_func   = progress_func,
+			.vol             = vol,
+			.params          = params,
 		};
 		ret = ntfs_readdir(ni, &pos, &ctx, wim_ntfs_capture_filldir);
 		if (ret) {
@@ -588,65 +641,70 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p,
 					       &dos_name_map);
 		}
 		destroy_dos_name_map(&dos_name_map);
-	} else {
-		/* Normal file */
-		ret = capture_ntfs_streams(root, ni, path, path_len,
-					   lookup_table, ntfs_vol_p,
-					   AT_DATA);
+		if (ret)
+			goto out;
 	}
-	if (ret != 0)
-		return ret;
 
-	/* Get security descriptor */
-	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);
+	if (!(params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_NO_ACLS)) {
+		/* Get security descriptor */
+		char _sd[1];
+		char *sd = _sd;
+		errno = 0;
 		ret = ntfs_xattr_system_getxattr(&ctx, XATTR_NTFS_ACL,
-						 ni, dir_ni, sd, ret);
-	}
-	if (ret > 0) {
-		root->d_inode->i_security_id = sd_set_add_sd(sd_set, sd, ret);
-		if (root->d_inode->i_security_id == -1) {
-			ERROR("Out of memory");
-			return WIMLIB_ERR_NOMEM;
+						 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) {
+			inode->i_security_id = sd_set_add_sd(params->sd_set,
+							     sd, ret);
+			if (inode->i_security_id == -1) {
+				ERROR("Out of memory");
+				ret = WIMLIB_ERR_NOMEM;
+				goto out;
+			}
+			DEBUG("Added security ID = %u for `%s'",
+			      inode->i_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 {
+			inode->i_security_id = -1;
+			DEBUG("No security ID for `%s'", path);
 		}
-		DEBUG("Added security ID = %u for `%s'",
-		      root->d_inode->i_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->d_inode->i_security_id = -1;
-		DEBUG("No security ID for `%s'", path);
 	}
+out:
+	if (ret == 0)
+		*root_ret = root;
+	else
+		free_dentry_tree(root, params->lookup_table);
 	return ret;
 }
 
+
+int
+do_ntfs_umount(struct _ntfs_volume *vol)
+{
+	DEBUG("Unmounting NTFS volume");
+	if (ntfs_umount(vol, FALSE))
+		return WIMLIB_ERR_NTFS_3G;
+	else
+		return 0;
+}
+
 int
 build_dentry_tree_ntfs(struct wim_dentry **root_p,
-		       const mbchar *device,
-		       struct wim_lookup_table *lookup_table,
-		       struct wim_security_data *sd,
-		       const struct capture_config *config,
-		       int add_image_flags,
-		       wimlib_progress_func_t progress_func,
-		       void *extra_arg)
+		       const char *device,
+		       struct add_image_params *params)
 {
 	ntfs_volume *vol;
 	ntfs_inode *root_ni;
 	int ret;
-	struct sd_set sd_set = {
-		.sd = sd,
-		.rb_root = {NULL},
-	};
-	ntfs_volume **ntfs_vol_p = extra_arg;
 
 	DEBUG("Mounting NTFS volume `%s' read-only", device);
 
@@ -680,7 +738,7 @@ build_dentry_tree_ntfs(struct wim_dentry **root_p,
 
 	/* Currently we assume that all the paths fit into this length and there
 	 * is no check for overflow. */
-	mbchar *path = MALLOC(32768);
+	char *path = MALLOC(32768);
 	if (!path) {
 		ERROR("Could not allocate memory for NTFS pathname");
 		ret = WIMLIB_ERR_NOMEM;
@@ -690,22 +748,17 @@ build_dentry_tree_ntfs(struct wim_dentry **root_p,
 	path[0] = '/';
 	path[1] = '\0';
 	ret = build_dentry_tree_ntfs_recursive(root_p, NULL, root_ni, path, 1,
-					       FILE_NAME_POSIX, lookup_table,
-					       &sd_set,
-					       config, ntfs_vol_p,
-					       add_image_flags,
-					       progress_func);
+					       FILE_NAME_POSIX, vol, params);
 out_cleanup:
 	FREE(path);
 	ntfs_inode_close(root_ni);
-	destroy_sd_set(&sd_set);
 out:
 	ntfs_index_ctx_put(vol->secure_xsii);
 	ntfs_index_ctx_put(vol->secure_xsdh);
 	ntfs_inode_close(vol->secure_ni);
 
 	if (ret) {
-		if (ntfs_umount(vol, FALSE) != 0) {
+		if (do_ntfs_umount(vol)) {
 			ERROR_WITH_ERRNO("Failed to unmount NTFS volume `%s'",
 					 device);
 			if (ret == 0)
@@ -714,7 +767,7 @@ out:
 	} 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;
+		*(ntfs_volume**)params->extra_arg = vol;
 	}
 	return ret;
 }