X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fntfs-capture.c;h=2656d1dd7f44afc40c57e782737d891232cabb71;hp=2647e2173851cd6e1360b3861b56af9abc2323f8;hb=3f9b53a4a214a254bb27ed30994faf2a0fd12375;hpb=7e7aeb2b91b492886ebdc28e5bac0b25462c154b

diff --git a/src/ntfs-capture.c b/src/ntfs-capture.c
index 2647e217..2656d1dd 100644
--- a/src/ntfs-capture.c
+++ b/src/ntfs-capture.c
@@ -58,77 +58,124 @@ 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
  * lookup table */
 static int
-capture_ntfs_streams(struct wim_dentry *dentry,
+capture_ntfs_streams(struct wim_inode *inode,
 		     ntfs_inode *ni,
 		     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 wim_lookup_table_entry *lte;
@@ -147,9 +194,10 @@ 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 "
@@ -160,88 +208,77 @@ capture_ntfs_streams(struct wim_dentry *dentry,
 			/* Empty stream.  No lookup table entry is needed. */
 			lte = NULL;
 		} else {
-			if (type == AT_REPARSE_POINT && data_size < 8) {
-				ERROR("`%s': reparse point buffer too small",
-				      path);
-				ret = WIMLIB_ERR_NTFS_3G;
-				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)
+			ntfs_loc = CALLOC(1, sizeof(*ntfs_loc));
+			if (!ntfs_loc)
 				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)
+				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->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)
+				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)
 				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);
+		}
 	}
 	ret = 0;
 	goto out_put_actx;
@@ -394,10 +431,11 @@ struct readdir_ctx {
 	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;
+	ntfs_volume *vol;
 	int add_image_flags;
 	wimlib_progress_func_t progress_func;
 };
@@ -410,9 +448,10 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p,
 				 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,
+				 ntfs_volume *ntfs_vol,
 				 int add_image_flags,
 				 wimlib_progress_func_t progress_func);
 
@@ -473,8 +512,10 @@ 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->lookup_table,
+					       ctx->inode_table,
+					       ctx->sd_set,
+					       ctx->config, ctx->vol,
 					       ctx->add_image_flags,
 					       ctx->progress_func);
 	if (child)
@@ -491,22 +532,24 @@ out:
  * 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,
 				 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,
+				 ntfs_volume *vol,
 				 int add_image_flags,
 				 wimlib_progress_func_t progress_func)
 {
 	u32 attributes;
 	int ret;
 	struct wim_dentry *root;
+	struct wim_inode *inode;
 
 	if (exclude_path(path, path_len, config, false)) {
 		/* Exclude a file or directory tree based on the capture
@@ -519,14 +562,15 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p,
 			info.scan.excluded = true;
 			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));
@@ -545,28 +589,33 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p,
 		progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info);
 	}
 
-	/* Create the new WIM dentry */
-	ret = new_dentry_with_timeless_inode(path_basename_with_len(path, path_len),
-					     &root);
+	/* Create a WIM dentry with an associated inode, which may be shared */
+	ret = inode_table_new_dentry(inode_table,
+				     path_basename_with_len(path, path_len),
+				     ni->mft_no,
+				     0,
+				     &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 */
 		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;
+	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) {
 		/* 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);
+		ret = capture_ntfs_streams(inode, ni, path,
+					   path_len, lookup_table,
+					   vol, AT_REPARSE_POINT);
 	} else if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY) {
 
 		/* Normal directory */
@@ -578,10 +627,11 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p,
 			.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,
+			.vol             = vol,
 			.add_image_flags = add_image_flags,
 			.progress_func   = progress_func,
 		};
@@ -596,12 +646,12 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p,
 		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);
+		ret = capture_ntfs_streams(inode, ni, path,
+					   path_len, lookup_table,
+					   vol, AT_DATA);
 	}
-	if (ret != 0)
-		return ret;
+	if (ret)
+		goto out;
 
 	if (!(add_image_flags & WIMLIB_ADD_IMAGE_FLAG_NO_ACLS)) {
 		/* Get security descriptor */
@@ -617,30 +667,48 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_p,
 							 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) {
+			inode->i_security_id = sd_set_add_sd(sd_set, sd, ret);
+			if (inode->i_security_id == -1) {
 				ERROR("Out of memory");
-				return WIMLIB_ERR_NOMEM;
+				ret = WIMLIB_ERR_NOMEM;
+				goto out;
 			}
 			DEBUG("Added security ID = %u for `%s'",
-			      root->d_inode->i_security_id, path);
+			      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;
+			inode->i_security_id = -1;
 			DEBUG("No security ID for `%s'", path);
 		}
 	}
+out:
+	if (ret == 0)
+		*root_ret = root;
+	else
+		free_dentry_tree(root, 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,
@@ -650,7 +718,6 @@ build_dentry_tree_ntfs(struct wim_dentry **root_p,
 	ntfs_volume *vol;
 	ntfs_inode *root_ni;
 	int ret;
-	ntfs_volume **ntfs_vol_p = extra_arg;
 
 	DEBUG("Mounting NTFS volume `%s' read-only", device);
 
@@ -695,8 +762,9 @@ build_dentry_tree_ntfs(struct wim_dentry **root_p,
 	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,
+					       config, vol,
 					       add_image_flags,
 					       progress_func);
 out_cleanup:
@@ -708,7 +776,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)
@@ -717,7 +785,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**)extra_arg = vol;
 	}
 	return ret;
 }