X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fextract.c;h=701d1294deb95db4d8d27e753f4b4f2078c2d45c;hp=f3b8da06ab6e439fa61bc637510e6ab36805cebd;hb=14c65f15f708c27dc434db1f0d112fad2a0b007c;hpb=ef8f45b98b5c4db398321cd36d052ccbb9c3784a

diff --git a/src/extract.c b/src/extract.c
index f3b8da06..701d1294 100644
--- a/src/extract.c
+++ b/src/extract.c
@@ -27,6 +27,7 @@
 #include "wimlib_internal.h"
 #include "dentry.h"
 #include "lookup_table.h"
+#include "timestamp.h"
 #include "xml.h"
 #include <sys/stat.h>
 #include <fcntl.h>
@@ -37,126 +38,124 @@
 
 #ifdef WITH_NTFS_3G
 #include <ntfs-3g/volume.h>
+#include <ntfs-3g/security.h>
 #endif
 
-/* Sets and creates the directory to which files are to be extracted when
- * extracting files from the WIM. */
-static int set_output_dir(WIMStruct *w, const char *dir)
+/* Internal */
+#define WIMLIB_EXTRACT_FLAG_MULTI_IMAGE 0x80000000
+
+static int extract_regular_file_linked(const struct dentry *dentry, 
+				       const char *output_dir,
+				       const char *output_path,
+				       int extract_flags,
+				       struct lookup_table_entry *lte)
 {
-	char *p;
-	DEBUG("Setting output directory to `%s'", dir);
+	/* This mode overrides the normal hard-link extraction and
+	 * instead either symlinks or hardlinks *all* identical files in
+	 * the WIM, even if they are in a different image (in the case
+	 * of a multi-image extraction) */
 
-	p = STRDUP(dir);
-	if (!p) {
-		ERROR("Out of memory");
-		return WIMLIB_ERR_NOMEM;
-	}
+	wimlib_assert(lte->file_on_disk);
 
-	if (mkdir(dir, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) != 0) {
-		if (errno == EEXIST) {
-			DEBUG("`%s' already exists", dir);
-			goto done;
+
+	if (extract_flags & WIMLIB_EXTRACT_FLAG_HARDLINK) {
+		if (link(lte->file_on_disk, output_path) != 0) {
+			ERROR_WITH_ERRNO("Failed to hard link "
+					 "`%s' to `%s'",
+					 output_path, lte->file_on_disk);
+			return WIMLIB_ERR_LINK;
 		}
-		ERROR_WITH_ERRNO("Cannot create directory `%s'", dir);
-		FREE(p);
-		return WIMLIB_ERR_MKDIR;
 	} else {
-		DEBUG("Created directory `%s'", dir);
+		int num_path_components;
+		int num_output_dir_path_components;
+		size_t file_on_disk_len;
+		char *p;
+		const char *p2;
+		size_t i;
+
+		wimlib_assert(extract_flags & WIMLIB_EXTRACT_FLAG_SYMLINK);
+
+		num_path_components = 
+			get_num_path_components(dentry->full_path_utf8) - 1;
+		num_output_dir_path_components =
+			get_num_path_components(output_dir);
+
+		if (extract_flags & WIMLIB_EXTRACT_FLAG_MULTI_IMAGE) {
+			num_path_components++;
+			num_output_dir_path_components--;
+		}
+		file_on_disk_len = strlen(lte->file_on_disk);
+
+		char buf[file_on_disk_len + 3 * num_path_components + 1];
+		p = &buf[0];
+
+		for (i = 0; i < num_path_components; i++) {
+			*p++ = '.';
+			*p++ = '.';
+			*p++ = '/';
+		}
+		p2 = lte->file_on_disk;
+		while (*p2 == '/')
+			p2++;
+		while (num_output_dir_path_components--)
+			p2 = path_next_part(p2, NULL);
+		strcpy(p, p2);
+		if (symlink(buf, output_path) != 0) {
+			ERROR_WITH_ERRNO("Failed to symlink `%s' to "
+					 "`%s'",
+					 buf, lte->file_on_disk);
+			return WIMLIB_ERR_LINK;
+		}
+
 	}
-done:
-	FREE(w->output_dir);
-	w->output_dir = p;
 	return 0;
 }
 
-/* 
- * Extracts a regular file from the WIM archive. 
- *
- * @dentry:  		The directory entry for the file, which must be a
- *				regular file.
- * @output_path:   	The path to which the file is to be extracted.
- * @lookup_table:	The lookup table for the WIM file.
- * @wim_fp:  		The FILE* for the WIM, opened for reading.
- * @wim_ctype:  	The type of compression used in the WIM.
- * @link_type:		One of WIM_LINK_TYPE_*; specifies what to do with
- * 			files that are hard-linked inside the WIM.
- * @is_multi_image_extraction: 
- * 			True if the image currently being extracted is just one 
- * 			image of a multi-image extraction.  This is needed so
- * 			that cross-image symbolic links can be created
- * 			correctly.
- */
-static int extract_regular_file(WIMStruct *w, 
-				const struct dentry *dentry, 
-				const char *output_path)
+static int extract_regular_file_unlinked(WIMStruct *w,
+					 struct dentry *dentry, 
+				         const char *output_path,
+				         int extract_flags,
+				         struct lookup_table_entry *lte)
 {
-	struct lookup_table_entry *lte;
-	int ret;
+	/* Normal mode of extraction.  Regular files and hard links are
+	 * extracted in the way that they appear in the WIM. */
+
 	int out_fd;
 	const struct resource_entry *res_entry;
-
-	lte = lookup_resource(w->lookup_table, dentry->hash);
-
-	/* If we already extracted the same file or a hard link copy of it, we
-	 * may be able to simply create a link.  The exact action is specified
-	 * by the current @link_type. */
-	if ((w->extract_flags & (WIMLIB_EXTRACT_FLAG_SYMLINK | WIMLIB_EXTRACT_FLAG_HARDLINK)) &&
-	      lte && lte->out_refcnt != 0)
-	{
-		wimlib_assert(lte->file_on_disk);
-
-		if (w->extract_flags & WIMLIB_EXTRACT_FLAG_HARDLINK) {
-			if (link(lte->file_on_disk, output_path) != 0) {
-				ERROR_WITH_ERRNO("Failed to hard link "
-						 "`%s' to `%s'",
-						 output_path, lte->file_on_disk);
-				return WIMLIB_ERR_LINK;
-			}
-		} else {
-			int num_path_components;
-			int num_output_dir_path_components;
-			size_t file_on_disk_len;
-			char *p;
-			const char *p2;
-			size_t i;
-
-			num_path_components = 
-				get_num_path_components(dentry->full_path_utf8) - 1;
-			num_output_dir_path_components =
-				get_num_path_components(w->output_dir);
-
-			if (w->is_multi_image_extraction) {
-				num_path_components++;
-				num_output_dir_path_components--;
-			}
-			file_on_disk_len = strlen(lte->file_on_disk);
-
-			char buf[file_on_disk_len + 3 * num_path_components + 1];
-			p = &buf[0];
-
-			for (i = 0; i < num_path_components; i++) {
-				*p++ = '.';
-				*p++ = '.';
-				*p++ = '/';
-			}
-			p2 = lte->file_on_disk;
-			while (*p2 == '/')
-				p2++;
-			while (num_output_dir_path_components--)
-				p2 = path_next_part(p2, NULL);
-			strcpy(p, p2);
-			if (symlink(buf, output_path) != 0) {
-				ERROR_WITH_ERRNO("Failed to symlink `%s' to "
-						 "`%s'",
-						 buf, lte->file_on_disk);
-				return WIMLIB_ERR_LINK;
+	int ret;
+	const struct list_head *head = &dentry->link_group_list;
+
+	if (head->next != head) {
+		/* This dentry is one of a hard link set of at least 2 dentries.
+		 * If one of the other dentries has already been extracted, make
+		 * a hard link to the file corresponding to this
+		 * already-extracted directory.  Otherwise, extract the
+		 * file, and set the dentry->extracted_file field so that other
+		 * dentries in the hard link group can link to it. */
+		struct dentry *other;
+		list_for_each_entry(other, head, link_group_list) {
+			if (other->extracted_file) {
+				DEBUG("Extracting hard link `%s' => `%s'",
+				      output_path, other->extracted_file);
+				if (link(other->extracted_file, output_path) != 0) {
+					ERROR_WITH_ERRNO("Failed to hard link "
+							 "`%s' to `%s'",
+							 output_path,
+							 other->extracted_file);
+					return WIMLIB_ERR_LINK;
+				}
+				return 0;
 			}
-
 		}
-		return 0;
-	} 
+		FREE(dentry->extracted_file);
+		dentry->extracted_file = STRDUP(output_path);
+		if (!dentry->extracted_file) {
+			ERROR("Failed to allocate memory for filename");
+			return WIMLIB_ERR_NOMEM;
+		}
+	}
 
-	/* Otherwise, we must actually extract the file contents. */
+	/* Extract the contents of the file to @output_path. */
 
 	out_fd = open(output_path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
 	if (out_fd == -1) {
@@ -165,13 +164,14 @@ static int extract_regular_file(WIMStruct *w,
 		return WIMLIB_ERR_OPEN;
 	}
 
-	/* Extract empty file, with no lookup table entry... */
 	if (!lte) {
+		/* Empty file with no lookup table entry */
 		DEBUG("Empty file `%s'.", output_path);
 		ret = 0;
 		goto done;
 	}
 
+
 	res_entry = &lte->resource_entry;
 
 	ret = extract_resource_to_fd(w, res_entry, out_fd, 
@@ -182,19 +182,71 @@ static int extract_regular_file(WIMStruct *w,
 		goto done;
 	}
 
-	/* Mark the lookup table entry to indicate this file has been extracted. */
-	lte->out_refcnt++;
-	FREE(lte->file_on_disk);
-	lte->file_on_disk = STRDUP(output_path);
-	if (lte->file_on_disk)
-		ret = 0;
-	else
-		ret = WIMLIB_ERR_NOMEM;
+	if (extract_flags & WIMLIB_EXTRACT_FLAG_MULTI_IMAGE) {
+		/* Mark the lookup table entry to indicate this file has been
+		 * extracted. */
+		lte->out_refcnt++;
+		FREE(lte->file_on_disk);
+		lte->file_on_disk = STRDUP(output_path);
+		if (!lte->file_on_disk)
+			ret = WIMLIB_ERR_NOMEM;
+	}
 done:
-	close(out_fd);
+	if (close(out_fd) != 0) {
+		ERROR_WITH_ERRNO("Failed to close file `%s'", output_path);
+		ret = WIMLIB_ERR_WRITE;
+	}
 	return ret;
 }
 
+/* 
+ * Extracts a regular file from the WIM archive. 
+ */
+static int extract_regular_file(WIMStruct *w, 
+				struct dentry *dentry, 
+				const char *output_dir,
+				const char *output_path,
+				int extract_flags)
+{
+	struct lookup_table_entry *lte;
+
+	lte = dentry_first_lte(dentry, w->lookup_table);
+
+	if ((extract_flags & (WIMLIB_EXTRACT_FLAG_SYMLINK |
+			      WIMLIB_EXTRACT_FLAG_HARDLINK)) && lte) {
+		if (lte->out_refcnt++ != 0)
+			return extract_regular_file_linked(dentry, output_dir,
+							   output_path,
+							   extract_flags, lte);
+		lte->file_on_disk = STRDUP(output_path);
+		if (!lte->file_on_disk)
+			return WIMLIB_ERR_NOMEM;
+	}
+
+	return extract_regular_file_unlinked(w, dentry, output_path,
+					     extract_flags, lte);
+
+}
+
+static int extract_symlink(const struct dentry *dentry, const char *output_path,
+			   const WIMStruct *w)
+{
+	char target[4096];
+	ssize_t ret = dentry_readlink(dentry, target, sizeof(target), w);
+	if (ret <= 0) {
+		ERROR("Could not read the symbolic link from dentry `%s'",
+		      dentry->full_path_utf8);
+		return WIMLIB_ERR_INVALID_DENTRY;
+	}
+	ret = symlink(target, output_path);
+	if (ret != 0) {
+		ERROR_WITH_ERRNO("Failed to symlink `%s' to `%s'",
+				 output_path, target);
+		return WIMLIB_ERR_LINK;
+	}
+	return 0;
+}
+
 /* 
  * Extracts a directory from the WIM archive. 
  *
@@ -202,7 +254,7 @@ done:
  * @output_path:   	The path to which the directory is to be extracted to.
  * @return: 		True on success, false on failure. 
  */
-static int extract_directory(struct dentry *dentry, const char *output_path)
+static int extract_directory(const char *output_path)
 {
 	/* Compute the output path directory to the directory. */
 	if (mkdir(output_path, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) != 0) 
@@ -222,38 +274,60 @@ static int extract_directory(struct dentry *dentry, const char *output_path)
 	return 0;
 }
 
+struct extract_args {
+	WIMStruct *w;
+	int extract_flags;
+	const char *output_dir;
+#ifdef WITH_NTFS_3G
+	struct SECURITY_API *scapi;
+#endif
+};
 
 /* 
- * Extracts a file or directory from the WIM archive.  For use in
- * for_dentry_in_tree().
- *
- * @dentry:	The dentry to extract.
- * @arg:	A pointer to the WIMStruct for the WIM file.
+ * Extracts a file, directory, or symbolic link from the WIM archive.  For use
+ * in for_dentry_in_tree().
  */
-static int extract_regular_file_or_directory(struct dentry *dentry, void *arg)
+static int extract_dentry(struct dentry *dentry, void *arg)
 {
-	WIMStruct *w = (WIMStruct*)arg;
-	size_t len = strlen(w->output_dir);
+	struct extract_args *args = arg;
+	WIMStruct *w = args->w;
+	int extract_flags = args->extract_flags;
+	size_t len = strlen(args->output_dir);
 	char output_path[len + dentry->full_path_utf8_len + 1];
+	int ret;
 
-	if (w->extract_flags & WIMLIB_EXTRACT_FLAG_VERBOSE)
+	if (extract_flags & WIMLIB_EXTRACT_FLAG_VERBOSE) {
+		wimlib_assert(dentry->full_path_utf8);
 		puts(dentry->full_path_utf8);
+	}
 
-	memcpy(output_path, w->output_dir, len);
+	memcpy(output_path, args->output_dir, len);
 	memcpy(output_path + len, dentry->full_path_utf8, dentry->full_path_utf8_len);
 	output_path[len + dentry->full_path_utf8_len] = '\0';
 
-	if (dentry_is_regular_file(dentry)) {
-		return extract_regular_file(w, dentry, output_path);
-	} else {
-		if (dentry_is_root(dentry)) /* Root doesn't need to be extracted. */
-			return 0;
-		else
-			return extract_directory(dentry, output_path);
+	if (dentry_is_symlink(dentry))
+		ret = extract_symlink(dentry, output_path, w);
+	else if (dentry_is_directory(dentry))
+		ret = extract_directory(output_path);
+	else
+		ret = extract_regular_file(w, dentry, args->output_dir,
+					    output_path, extract_flags);
+	if (ret != 0)
+		return ret;
+
+	struct timeval tv[2];
+	wim_timestamp_to_timeval(dentry->last_access_time, &tv[0]);
+	wim_timestamp_to_timeval(dentry->last_write_time, &tv[1]);
+	if (lutimes(output_path, tv) != 0) {
+		WARNING("Failed to set timestamp on file `%s': %s",
+		        output_path, strerror(errno));
 	}
+	return 0;
 }
 
-static int extract_single_image(WIMStruct *w, int image)
+
+static int extract_single_image(WIMStruct *w, int image,
+				const char *output_dir, int extract_flags)
 {
 	DEBUG("Extracting image %d", image);
 
@@ -262,17 +336,26 @@ static int extract_single_image(WIMStruct *w, int image)
 	if (ret != 0)
 		return ret;
 
-	return for_dentry_in_tree(wim_root_dentry(w),
-				  extract_regular_file_or_directory, w);
+	struct extract_args args = {
+		.w = w,
+		.extract_flags = extract_flags,
+		.output_dir = output_dir,
+	#ifdef WITH_NTFS_3G
+		.scapi = NULL
+	#endif
+	};
+
+	return for_dentry_in_tree(wim_root_dentry(w), extract_dentry, &args);
 }
 
 
-/* Extracts all images from the WIM to w->output_dir, with the images placed in
+/* Extracts all images from the WIM to @output_dir, with the images placed in
  * subdirectories named by their image names. */
-static int extract_all_images(WIMStruct *w)
+static int extract_all_images(WIMStruct *w, const char *output_dir,
+			      int extract_flags)
 {
 	size_t image_name_max_len = max(xml_get_max_image_name_len(w), 20);
-	size_t output_path_len = strlen(w->output_dir);
+	size_t output_path_len = strlen(output_dir);
 	char buf[output_path_len + 1 + image_name_max_len + 1];
 	int ret;
 	int image;
@@ -280,7 +363,11 @@ static int extract_all_images(WIMStruct *w)
 
 	DEBUG("Attempting to extract all images from `%s'", w->filename);
 
-	memcpy(buf, w->output_dir, output_path_len);
+	ret = extract_directory(output_dir);
+	if (ret != 0)
+		return ret;
+
+	memcpy(buf, output_dir, output_path_len);
 	buf[output_path_len] = '/';
 	for (image = 1; image <= w->hdr.image_count; image++) {
 		
@@ -291,10 +378,7 @@ static int extract_all_images(WIMStruct *w)
 			/* Image name is empty. Use image number instead */
 			sprintf(buf + output_path_len + 1, "%d", image);
 		}
-		ret = set_output_dir(w, buf);
-		if (ret != 0)
-			goto done;
-		ret = extract_single_image(w, image);
+		ret = extract_single_image(w, image, buf, extract_flags);
 		if (ret != 0)
 			goto done;
 	}
@@ -308,21 +392,18 @@ done:
 WIMLIBAPI int wimlib_extract_image(WIMStruct *w, int image,
 				   const char *output_dir, int flags)
 {
-	int ret;
+
 	if (!output_dir)
 		return WIMLIB_ERR_INVALID_PARAM;
+
 	if ((flags & (WIMLIB_EXTRACT_FLAG_SYMLINK | WIMLIB_EXTRACT_FLAG_HARDLINK))
 			== (WIMLIB_EXTRACT_FLAG_SYMLINK | WIMLIB_EXTRACT_FLAG_HARDLINK))
 		return WIMLIB_ERR_INVALID_PARAM;
-	
-	ret = set_output_dir(w, output_dir);
-	if (ret != 0)
-		return ret;
 
 	if ((flags & WIMLIB_EXTRACT_FLAG_NTFS)) {
 	#ifdef WITH_NTFS_3G
 		unsigned long mnt_flags;
-		ret = ntfs_check_if_mounted(output_dir, &mnt_flags);
+		int ret = ntfs_check_if_mounted(output_dir, &mnt_flags);
 		if (ret != 0) {
 			ERROR_WITH_ERRNO("NTFS-3g: Cannot determine if `%s' "
 					 "is mounted", output_dir);
@@ -331,6 +412,7 @@ WIMLIBAPI int wimlib_extract_image(WIMStruct *w, int image,
 		if (!(mnt_flags & NTFS_MF_MOUNTED)) {
 			ERROR("NTFS-3g: Filesystem on `%s' is not mounted ",
 			      output_dir);
+			return WIMLIB_ERR_NTFS_3G;
 		}
 		if (mnt_flags & NTFS_MF_READONLY) {
 			ERROR("NTFS-3g: Filesystem on `%s' is mounted "
@@ -344,14 +426,15 @@ WIMLIBAPI int wimlib_extract_image(WIMStruct *w, int image,
 		return WIMLIB_ERR_UNSUPPORTED;
 	#endif
 	}
-	w->extract_flags = flags;
+
+	for_lookup_table_entry(w->lookup_table, zero_out_refcnts, NULL);
+
 	if (image == WIM_ALL_IMAGES) {
-		w->is_multi_image_extraction = true;
-		ret = extract_all_images(w);
+		flags |= WIMLIB_EXTRACT_FLAG_MULTI_IMAGE;
+		return extract_all_images(w, output_dir, flags);
 	} else {
-		w->is_multi_image_extraction = false;
-		ret = extract_single_image(w, image);
+		flags &= ~WIMLIB_EXTRACT_FLAG_MULTI_IMAGE;
+		return extract_single_image(w, image, output_dir, flags);
 	}
-	return ret;
 
 }