X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fntfs-capture.c;h=3c9067079c2b8e2bf21d8a09ddb305a7a4ab4547;hp=94e74cee4f360cb68a2f3c78e47642d7edf7b533;hb=ca8727cf22a445adc20eb1f8b7a12b8eededc32d;hpb=c6a1140e085f633273fcf47a6462bd9382ce118a

diff --git a/src/ntfs-capture.c b/src/ntfs-capture.c
index 94e74cee..3c906707 100644
--- a/src/ntfs-capture.c
+++ b/src/ntfs-capture.c
@@ -58,62 +58,110 @@ 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;
+}
+
+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;
 
-	bytes_remaining = na->data_size;
+ 	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
@@ -124,13 +172,12 @@ capture_ntfs_streams(struct wim_inode *inode,
 		     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,88 +194,76 @@ capture_ntfs_streams(struct wim_inode *inode,
 	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)
-				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 (inode->i_lte) {
-				WARNING("Found two un-named data streams for "
-					"`%s'", path);
-				free_lookup_table_entry(lte);
-			} else {
-				inode->i_lte = 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 */
@@ -237,13 +272,26 @@ capture_ntfs_streams(struct wim_inode *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;
 }
 
@@ -393,14 +441,9 @@ struct readdir_ctx {
 	ntfs_inode *dir_ni;
 	char *path;
 	size_t path_len;
-	struct wim_lookup_table	*lookup_table;
-	struct wim_inode_table *inode_table;
-	struct sd_set *sd_set;
 	struct dos_name_map *dos_name_map;
-	const struct wimlib_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
@@ -410,13 +453,8 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p,
 				 char *path,
 				 size_t path_len,
 				 int name_type,
-				 struct wim_lookup_table *lookup_table,
-				 struct wim_inode_table *inode_table,
-				 struct sd_set *sd_set,
-				 const struct wimlib_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,
@@ -475,12 +513,7 @@ 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->inode_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);
@@ -501,29 +534,25 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_ret,
 				 char *path,
 				 size_t path_len,
 				 int name_type,
-				 struct wim_lookup_table *lookup_table,
-				 struct wim_inode_table *inode_table,
-				 struct sd_set *sd_set,
-				 const struct wimlib_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, path_len, 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_EXCLUDE_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 = NULL;
 		ret = 0;
@@ -533,7 +562,7 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_ret,
 	/* 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));
@@ -543,17 +572,17 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_ret,
 		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 a WIM dentry with an associated inode, which may be shared */
-	ret = inode_table_new_dentry(inode_table,
+	ret = inode_table_new_dentry(params->inode_table,
 				     path_basename_with_len(path, path_len),
 				     ni->mft_no,
 				     0,
@@ -566,7 +595,7 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_ret,
 	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;
 	inode->i_creation_time    = le64_to_cpu(ni->creation_time);
 	inode->i_last_write_time  = le64_to_cpu(ni->last_data_change_time);
@@ -574,14 +603,26 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_ret,
 	inode->i_attributes       = le32_to_cpu(attributes);
 	inode->i_resolved         = 1;
 
-	if (attributes & FILE_ATTR_REPARSE_POINT) {
-		/* Junction point, symbolic link, or other reparse point */
-		ret = capture_ntfs_streams(inode, ni, path,
-					   path_len, lookup_table,
-					   ntfs_vol_p, AT_REPARSE_POINT);
-	} else if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY) {
+	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) {
 
-		/* Normal directory */
+		/* Recurse to directory children */
 		s64 pos = 0;
 		struct dos_name_map dos_name_map = { .rb_root = {.rb_node = NULL} };
 		struct readdir_ctx ctx = {
@@ -589,14 +630,9 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_ret,
 			.dir_ni          = ni,
 			.path            = path,
 			.path_len        = path_len,
-			.lookup_table    = lookup_table,
-			.inode_table     = inode_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) {
@@ -607,16 +643,11 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_ret,
 					       &dos_name_map);
 		}
 		destroy_dos_name_map(&dos_name_map);
-	} else {
-		/* Normal file */
-		ret = capture_ntfs_streams(inode, ni, path,
-					   path_len, lookup_table,
-					   ntfs_vol_p, AT_DATA);
+		if (ret)
+			goto out;
 	}
-	if (ret)
-		goto out;
 
-	if (!(add_image_flags & WIMLIB_ADD_IMAGE_FLAG_NO_ACLS)) {
+	if (!(params->add_image_flags & WIMLIB_ADD_IMAGE_FLAG_NO_ACLS)) {
 		/* Get security descriptor */
 		char _sd[1];
 		char *sd = _sd;
@@ -630,7 +661,8 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_ret,
 							 ni, dir_ni, sd, ret);
 		}
 		if (ret > 0) {
-			inode->i_security_id = sd_set_add_sd(sd_set, sd, ret);
+			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;
@@ -652,25 +684,29 @@ out:
 	if (ret == 0)
 		*root_ret = root;
 	else
-		free_dentry_tree(root, lookup_table);
+		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 char *device,
-		       struct wim_lookup_table *lookup_table,
-		       struct wim_inode_table *inode_table,
-		       struct sd_set *sd_set,
-		       const struct wimlib_capture_config *config,
-		       int add_image_flags,
-		       wimlib_progress_func_t progress_func,
-		       void *extra_arg)
+		       struct add_image_params *params)
 {
 	ntfs_volume *vol;
 	ntfs_inode *root_ni;
 	int ret;
-	ntfs_volume **ntfs_vol_p = extra_arg;
 
 	DEBUG("Mounting NTFS volume `%s' read-only", device);
 
@@ -714,12 +750,7 @@ 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,
-					       inode_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);
@@ -729,7 +760,7 @@ out:
 	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)
@@ -738,7 +769,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;
 }