X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Funix_apply.c;h=daadfc9ec15d31c86a90251fbe699c7a2eb40668;hp=f1962d9884b63752892217f3eed71b29393a777c;hb=da76dcea3a09c6de9cf865609f1e1732fc2c521a;hpb=0469bcaaa79d7b6031fbdc0a26f38ee7e22ced37

diff --git a/src/unix_apply.c b/src/unix_apply.c
index f1962d98..daadfc9e 100644
--- a/src/unix_apply.c
+++ b/src/unix_apply.c
@@ -3,7 +3,7 @@
  */
 
 /*
- * Copyright (C) 2012, 2013, 2014 Eric Biggers
+ * Copyright (C) 2012-2016 Eric Biggers
  *
  * This file 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
@@ -29,6 +29,9 @@
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
+#ifdef HAVE_SYS_XATTR_H
+#  include <sys/xattr.h>
+#endif
 #include <unistd.h>
 
 #include "wimlib/apply.h"
@@ -40,6 +43,7 @@
 #include "wimlib/reparse.h"
 #include "wimlib/timestamp.h"
 #include "wimlib/unix_data.h"
+#include "wimlib/xattr.h"
 
 /* We don't require O_NOFOLLOW, but the advantage of having it is that if we
  * need to extract a file to a location at which there exists a symbolic link,
@@ -54,11 +58,15 @@ static int
 unix_get_supported_features(const char *target,
 			    struct wim_features *supported_features)
 {
+	supported_features->sparse_files = 1;
 	supported_features->hard_links = 1;
 	supported_features->symlink_reparse_points = 1;
 	supported_features->unix_data = 1;
 	supported_features->timestamps = 1;
 	supported_features->case_sensitive_filenames = 1;
+#ifdef HAVE_XATTR_SUPPORT
+	supported_features->linux_xattrs = 1;
+#endif
 	return 0;
 }
 
@@ -81,6 +89,13 @@ struct unix_apply_ctx {
 	 * the beginning of the array.  */
 	unsigned num_open_fds;
 
+	/* For each currently open file, whether we're writing to it in "sparse"
+	 * mode or not.  */
+	bool is_sparse_file[MAX_OPEN_FILES];
+
+	/* Whether is_sparse_file[] is true for any currently open file  */
+	bool any_sparse_files;
+
 	/* Buffer for reading reparse point data into memory  */
 	u8 reparse_data[REPARSE_DATA_MAX_SIZE];
 
@@ -156,7 +171,9 @@ unix_build_extraction_path(const struct wim_dentry *dentry,
 	d = dentry;
 	do {
 		p -= d->d_extraction_name_nchars;
-		memcpy(p, d->d_extraction_name, d->d_extraction_name_nchars);
+		if (d->d_extraction_name_nchars)
+			memcpy(p, d->d_extraction_name,
+			       d->d_extraction_name_nchars);
 		*--p = '/';
 		d = d->d_parent;
 	} while (!dentry_is_root(d) && will_extract_dentry(d));
@@ -251,70 +268,165 @@ unix_set_mode(int fd, const char *path, mode_t mode)
 	return WIMLIB_ERR_SET_SECURITY;
 }
 
+#ifdef HAVE_XATTR_SUPPORT
+/* Apply extended attributes to a file */
+static int
+apply_linux_xattrs(int fd, const struct wim_inode *inode,
+		   const char *path, struct unix_apply_ctx *ctx,
+		   const void *entries, size_t entries_size)
+{
+	const void * const entries_end = entries + entries_size;
+	char name[XATTR_NAME_MAX + 1];
+
+	for (const struct wimlib_xattr_entry *entry = entries;
+	     (void *)entry < entries_end; entry = xattr_entry_next(entry))
+	{
+		u16 name_len;
+		const void *value;
+		u32 value_len;
+		int res;
+
+		if (!valid_xattr_entry(entry, entries_end - (void *)entry)) {
+			if (!path) {
+				path = unix_build_inode_extraction_path(inode,
+									ctx);
+			}
+			ERROR("\"%s\": extended attribute is corrupt", path);
+			return WIMLIB_ERR_INVALID_XATTR;
+		}
+		name_len = le16_to_cpu(entry->name_len);
+		memcpy(name, entry->name, name_len);
+		name[name_len] = '\0';
+
+		value = entry->name + name_len;
+		value_len = le32_to_cpu(entry->value_len);
+
+		if (fd >= 0)
+			res = fsetxattr(fd, name, value, value_len, 0);
+		else
+			res = lsetxattr(path, name, value, value_len, 0);
+
+		if (unlikely(res != 0)) {
+			if (!path) {
+				path = unix_build_inode_extraction_path(inode,
+									ctx);
+			}
+			if (is_security_xattr(name) &&
+			    (ctx->common.extract_flags &
+			     WIMLIB_EXTRACT_FLAG_STRICT_ACLS))
+			{
+				ERROR_WITH_ERRNO("\"%s\": unable to set extended attribute \"%s\"",
+						 path, name);
+				return WIMLIB_ERR_SET_XATTR;
+			}
+			WARNING_WITH_ERRNO("\"%s\": unable to set extended attribute \"%s\"",
+					   path, name);
+		}
+	}
+	return 0;
+}
+#endif /* HAVE_XATTR_SUPPORT */
+
 /*
- * Set metadata on an extracted file.
+ * Apply UNIX-specific metadata to a file if available.  This includes standard
+ * UNIX permissions (uid, gid, and mode) and possibly extended attributes too.
  *
- * @fd is an open file descriptor to the extracted file, or -1.  @path is the
- * path to the extracted file, or NULL.  If valid, this function uses @fd.
- * Otherwise, if valid, it uses @path.  Otherwise, it calculates the path to one
- * alias of the extracted file and uses it.
+ * Note that some xattrs which grant privileges, e.g. security.capability, are
+ * cleared by Linux on chown(), even when running as root.  Also, when running
+ * as non-root, if we need to chmod() the file to readonly, we can't do that
+ * before setting xattrs because setxattr() requires write permission.  These
+ * restrictions result in the following ordering which we follow: chown(),
+ * setxattr(), then chmod().
+ *
+ * N.B. the file may be specified by either 'fd' (for regular files) or 'path',
+ * and it may be a symlink.  For symlinks we need lchown() and lsetxattr() but
+ * need to skip the chmod(), since mode bits are not meaningful for symlinks.
  */
 static int
-unix_set_metadata(int fd, const struct wim_inode *inode,
-		  const char *path, struct unix_apply_ctx *ctx)
+apply_unix_metadata(int fd, const struct wim_inode *inode,
+		    const char *path, struct unix_apply_ctx *ctx)
 {
+	bool have_dat;
+	struct wimlib_unix_data dat;
+#ifdef HAVE_XATTR_SUPPORT
+	const void *entries;
+	u32 entries_size;
+#endif
 	int ret;
-	struct wimlib_unix_data unix_data;
-
-	if (fd < 0 && !path)
-		path = unix_build_inode_extraction_path(inode, ctx);
 
-	if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA)
-	    && inode_get_unix_data(inode, &unix_data))
-	{
-		u32 uid = unix_data.uid;
-		u32 gid = unix_data.gid;
-		u32 mode = unix_data.mode;
+	have_dat = inode_get_unix_data(inode, &dat);
 
-		ret = unix_set_owner_and_group(fd, path, uid, gid);
+	if (have_dat) {
+		ret = unix_set_owner_and_group(fd, path, dat.uid, dat.gid);
 		if (ret) {
 			if (!path)
 				path = unix_build_inode_extraction_path(inode, ctx);
 			if (ctx->common.extract_flags &
 			    WIMLIB_EXTRACT_FLAG_STRICT_ACLS)
 			{
-				ERROR_WITH_ERRNO("Can't set uid=%"PRIu32" and "
-						 "gid=%"PRIu32" on \"%s\"",
-						 uid, gid, path);
+				ERROR_WITH_ERRNO("\"%s\": unable to set uid=%"PRIu32" and gid=%"PRIu32,
+						 path, dat.uid, dat.gid);
 				return ret;
-			} else {
-				WARNING_WITH_ERRNO("Can't set uid=%"PRIu32" and "
-						   "gid=%"PRIu32" on \"%s\"",
-						   uid, gid, path);
 			}
+			WARNING_WITH_ERRNO("\"%s\": unable to set uid=%"PRIu32" and gid=%"PRIu32,
+					   path, dat.uid, dat.gid);
 		}
+	}
+
+#if HAVE_XATTR_SUPPORT
+	entries = inode_get_linux_xattrs(inode, &entries_size);
+	if (entries) {
+		ret = apply_linux_xattrs(fd, inode, path, ctx,
+					 entries, entries_size);
+		if (ret)
+			return ret;
+	}
+#endif
 
-		ret = 0;
-		if (!inode_is_symlink(inode))
-			ret = unix_set_mode(fd, path, mode);
+	if (have_dat && !inode_is_symlink(inode)) {
+		ret = unix_set_mode(fd, path, dat.mode);
 		if (ret) {
 			if (!path)
 				path = unix_build_inode_extraction_path(inode, ctx);
 			if (ctx->common.extract_flags &
 			    WIMLIB_EXTRACT_FLAG_STRICT_ACLS)
 			{
-				ERROR_WITH_ERRNO("Can't set mode=0%"PRIo32" "
-						 "on \"%s\"", mode, path);
+				ERROR_WITH_ERRNO("\"%s\": unable to set mode=0%"PRIo32,
+						 path, dat.mode);
 				return ret;
-			} else {
-				WARNING_WITH_ERRNO("Can't set mode=0%"PRIo32" "
-						   "on \"%s\"", mode, path);
 			}
+			WARNING_WITH_ERRNO("\"%s\": unable to set mode=0%"PRIo32,
+					   path, dat.mode);
 		}
 	}
 
-	ret = unix_set_timestamps(fd, path,
-				  inode->i_last_access_time,
+	return 0;
+}
+
+/*
+ * Set metadata on an extracted file.
+ *
+ * @fd is an open file descriptor to the extracted file, or -1.  @path is the
+ * path to the extracted file, or NULL.  If valid, this function uses @fd.
+ * Otherwise, if valid, it uses @path.  Otherwise, it calculates the path to one
+ * alias of the extracted file and uses it.
+ */
+static int
+unix_set_metadata(int fd, const struct wim_inode *inode,
+		  const char *path, struct unix_apply_ctx *ctx)
+{
+	int ret;
+
+	if (fd < 0 && !path)
+		path = unix_build_inode_extraction_path(inode, ctx);
+
+	if (ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) {
+		ret = apply_unix_metadata(fd, inode, path, ctx);
+		if (ret)
+			return ret;
+	}
+
+	ret = unix_set_timestamps(fd, path, inode->i_last_access_time,
 				  inode->i_last_write_time);
 	if (ret) {
 		if (!path)
@@ -322,12 +434,12 @@ unix_set_metadata(int fd, const struct wim_inode *inode,
 		if (ctx->common.extract_flags &
 		    WIMLIB_EXTRACT_FLAG_STRICT_TIMESTAMPS)
 		{
-			ERROR_WITH_ERRNO("Can't set timestamps on \"%s\"", path);
+			ERROR_WITH_ERRNO("\"%s\": unable to set timestamps", path);
 			return ret;
-		} else {
-			WARNING_WITH_ERRNO("Can't set timestamps on \"%s\"", path);
 		}
+		WARNING_WITH_ERRNO("\"%s\": unable to set timestamps", path);
 	}
+
 	return 0;
 }
 
@@ -434,7 +546,7 @@ unix_extract_if_empty_file(const struct wim_dentry *dentry,
 
 		path = unix_build_extraction_path(dentry, ctx);
 	retry_create:
-		fd = open(path, O_TRUNC | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644);
+		fd = open(path, O_EXCL | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644);
 		if (fd < 0) {
 			if (errno == EEXIST && !unlink(path))
 				goto retry_create;
@@ -539,6 +651,7 @@ unix_cleanup_open_fds(struct unix_apply_ctx *ctx, unsigned offset)
 	for (unsigned i = offset; i < ctx->num_open_fds; i++)
 		filedes_close(&ctx->open_fds[i]);
 	ctx->num_open_fds = 0;
+	ctx->any_sparse_files = false;
 }
 
 static int
@@ -575,13 +688,22 @@ unix_begin_extract_blob_instance(const struct blob_descriptor *blob,
 	first_dentry = inode_first_extraction_dentry(inode);
 	first_path = unix_build_extraction_path(first_dentry, ctx);
 retry_create:
-	fd = open(first_path, O_TRUNC | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644);
+	fd = open(first_path, O_EXCL | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644);
 	if (fd < 0) {
 		if (errno == EEXIST && !unlink(first_path))
 			goto retry_create;
 		ERROR_WITH_ERRNO("Can't create regular file \"%s\"", first_path);
 		return WIMLIB_ERR_OPEN;
 	}
+	if (inode->i_attributes & FILE_ATTRIBUTE_SPARSE_FILE) {
+		ctx->is_sparse_file[ctx->num_open_fds] = true;
+		ctx->any_sparse_files = true;
+	} else {
+		ctx->is_sparse_file[ctx->num_open_fds] = false;
+#ifdef HAVE_POSIX_FALLOCATE
+		posix_fallocate(fd, 0, blob->size);
+#endif
+	}
 	filedes_init(&ctx->open_fds[ctx->num_open_fds++], fd);
 	return unix_create_hardlinks(inode, first_dentry, first_path, ctx);
 }
@@ -609,21 +731,41 @@ unix_begin_extract_blob(struct blob_descriptor *blob, void *_ctx)
 
 /* Called when the next chunk of a blob has been read for extraction  */
 static int
-unix_extract_chunk(const void *chunk, size_t size, void *_ctx)
+unix_extract_chunk(const struct blob_descriptor *blob, u64 offset,
+		   const void *chunk, size_t size, void *_ctx)
 {
 	struct unix_apply_ctx *ctx = _ctx;
+	const void * const end = chunk + size;
+	const void *p;
+	bool zeroes;
+	size_t len;
+	unsigned i;
 	int ret;
 
-	for (unsigned i = 0; i < ctx->num_open_fds; i++) {
-		ret = full_write(&ctx->open_fds[i], chunk, size);
-		if (ret) {
-			ERROR_WITH_ERRNO("Error writing data to filesystem");
-			return ret;
+	/*
+	 * For sparse files, only write nonzero regions.  This lets the
+	 * filesystem use holes to represent zero regions.
+	 */
+	for (p = chunk; p != end; p += len, offset += len) {
+		zeroes = maybe_detect_sparse_region(p, end - p, &len,
+						    ctx->any_sparse_files);
+		for (i = 0; i < ctx->num_open_fds; i++) {
+			if (!zeroes || !ctx->is_sparse_file[i]) {
+				ret = full_pwrite(&ctx->open_fds[i],
+						  p, len, offset);
+				if (ret)
+					goto err;
+			}
 		}
 	}
+
 	if (ctx->reparse_ptr)
 		ctx->reparse_ptr = mempcpy(ctx->reparse_ptr, chunk, size);
 	return 0;
+
+err:
+	ERROR_WITH_ERRNO("Error writing data to filesystem");
+	return ret;
 }
 
 /* Called when a blob has been fully read for extraction  */
@@ -663,10 +805,17 @@ unix_end_extract_blob(struct blob_descriptor *blob, int status, void *_ctx)
 			if (ret)
 				break;
 		} else {
-			/* Set metadata on regular file just before closing it.
-			 */
 			struct filedes *fd = &ctx->open_fds[j];
 
+			/* If the file is sparse, extend it to its final size. */
+			if (ctx->is_sparse_file[j] && ftruncate(fd->fd, blob->size)) {
+				ERROR_WITH_ERRNO("Error extending \"%s\" to final size",
+						 unix_build_inode_extraction_path(inode, ctx));
+				ret = WIMLIB_ERR_WRITE;
+				break;
+			}
+
+			/* Set metadata on regular file just before closing.  */
 			ret = unix_set_metadata(fd->fd, inode, NULL, ctx);
 			if (ret)
 				break;
@@ -763,7 +912,7 @@ unix_extract(struct list_head *dentry_list, struct apply_ctx *_ctx)
 
 	struct read_blob_callbacks cbs = {
 		.begin_blob	= unix_begin_extract_blob,
-		.consume_chunk	= unix_extract_chunk,
+		.continue_blob	= unix_extract_chunk,
 		.end_blob	= unix_end_extract_blob,
 		.ctx		= ctx,
 	};