/*
* Copyright (C) 2012, 2013, 2014 Eric Biggers
*
- * This file is part of wimlib, a library for working with WIM files.
+ * 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
+ * Software Foundation; either version 3 of the License, or (at your option) any
+ * later version.
*
- * wimlib is free software; you can redistribute it and/or modify it under the
- * terms of the GNU General Public License as published by the Free
- * Software Foundation; either version 3 of the License, or (at your option)
- * any later version.
- *
- * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
- * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * This file is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
* details.
*
- * You should have received a copy of the GNU General Public License
- * along with wimlib; if not, see http://www.gnu.org/licenses/.
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this file; if not, see http://www.gnu.org/licenses/.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
-#include "wimlib/apply.h"
-#include "wimlib/dentry.h"
-#include "wimlib/error.h"
-#include "wimlib/file_io.h"
-#include "wimlib/reparse.h"
-#include "wimlib/timestamp.h"
-
#include <errno.h>
#include <fcntl.h>
-#include <limits.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
+#include "wimlib/apply.h"
+#include "wimlib/assert.h"
+#include "wimlib/dentry.h"
+#include "wimlib/error.h"
+#include "wimlib/file_io.h"
+#include "wimlib/lookup_table.h"
+#include "wimlib/reparse.h"
+#include "wimlib/timestamp.h"
+#include "wimlib/unix_data.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,
* open(..., O_NOFOLLOW | ...) recognizes the symbolic link rather than
}
#define NUM_PATHBUFS 2 /* We need 2 when creating hard links */
-#define MAX_OPEN_FDS 1024 /* TODO: Add special case for when the number of
- identical streams exceeds this number. */
struct unix_apply_ctx {
/* Extract flags, the pointer to the WIMStruct, etc. */
unsigned which_pathbuf;
/* Currently open file descriptors for extraction */
- struct filedes open_fds[MAX_OPEN_FDS];
+ struct filedes open_fds[MAX_OPEN_STREAMS];
/* Number of currently open file descriptors in open_fds, starting from
* the beginning of the array. */
/* Number of characters in target_abspath. */
size_t target_abspath_nchars;
+
+ /* Number of special files we couldn't create due to EPERM */
+ unsigned long num_special_files_ignored;
};
/* Returns the number of characters needed to represent the path to the
d = dentry;
do {
len += d->d_extraction_name_nchars + 1;
- d = d->parent;
+ d = d->d_parent;
} while (!dentry_is_root(d) && will_extract_dentry(d));
return len;
p -= d->d_extraction_name_nchars;
memcpy(p, d->d_extraction_name, d->d_extraction_name_nchars);
*--p = '/';
- d = d->parent;
+ d = d->d_parent;
} while (!dentry_is_root(d) && will_extract_dentry(d));
return pathbuf;
const char *path, struct unix_apply_ctx *ctx)
{
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_has_unix_data(inode))
+ && inode_get_unix_data(inode, &unix_data))
{
- u32 uid = inode->i_unix_data.uid;
- u32 gid = inode->i_unix_data.gid;
- u32 mode = inode->i_unix_data.mode;
+ u32 uid = unix_data.uid;
+ u32 gid = unix_data.gid;
+ u32 mode = unix_data.mode;
ret = unix_set_owner_and_group(fd, path, uid, gid);
if (ret) {
ERROR_WITH_ERRNO("Can't create directory \"%s\"", path);
return WIMLIB_ERR_MKDIR;
}
- return 0;
+
+ return report_file_created(&ctx->common);
}
-/* If @dentry represents an empty regular file, create it, set its metadata, and
- * create any needed hard links. */
+/* If @dentry represents an empty regular file or a special file, create it, set
+ * its metadata, and create any needed hard links. */
static int
unix_extract_if_empty_file(const struct wim_dentry *dentry,
struct unix_apply_ctx *ctx)
{
const struct wim_inode *inode;
+ struct wimlib_unix_data unix_data;
const char *path;
- int fd;
int ret;
inode = dentry->d_inode;
if (dentry != inode_first_extraction_dentry(inode))
return 0;
- /* Not an empty regular file? */
+ /* Is this a directory, a symbolic link, or any type of nonempty file?
+ */
if (inode_is_directory(inode) || inode_is_symlink(inode) ||
inode_unnamed_lte_resolved(inode))
return 0;
- path = unix_build_extraction_path(dentry, ctx);
-retry_create:
- fd = open(path, O_TRUNC | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644);
- if (fd < 0) {
- if (errno == EEXIST && !unlink(path))
- goto retry_create;
- ERROR_WITH_ERRNO("Can't create regular file \"%s\"", path);
- return WIMLIB_ERR_OPEN;
- }
- /* On empty files, we can set timestamps immediately because we don't
- * need to write any data to them. */
- ret = unix_set_metadata(fd, inode, path, ctx);
- if (close(fd) && !ret) {
- ERROR_WITH_ERRNO("Error closing \"%s\"", path);
- ret = WIMLIB_ERR_WRITE;
+ /* Recognize special files in UNIX_DATA mode */
+ if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) &&
+ inode_get_unix_data(inode, &unix_data) &&
+ !S_ISREG(unix_data.mode))
+ {
+ path = unix_build_extraction_path(dentry, ctx);
+ retry_mknod:
+ if (mknod(path, unix_data.mode, unix_data.rdev)) {
+ if (errno == EPERM) {
+ WARNING_WITH_ERRNO("Can't create special "
+ "file \"%s\"", path);
+ ctx->num_special_files_ignored++;
+ return 0;
+ }
+ if (errno == EEXIST && !unlink(path))
+ goto retry_mknod;
+ ERROR_WITH_ERRNO("Can't create special file \"%s\"",
+ path);
+ return WIMLIB_ERR_MKNOD;
+ }
+ /* On special files, we can set timestamps immediately because
+ * we don't need to write any data to them. */
+ ret = unix_set_metadata(-1, inode, path, ctx);
+ } else {
+ int fd;
+
+ path = unix_build_extraction_path(dentry, ctx);
+ retry_create:
+ fd = open(path, O_TRUNC | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644);
+ if (fd < 0) {
+ if (errno == EEXIST && !unlink(path))
+ goto retry_create;
+ ERROR_WITH_ERRNO("Can't create regular file \"%s\"", path);
+ return WIMLIB_ERR_OPEN;
+ }
+ /* On empty files, we can set timestamps immediately because we
+ * don't need to write any data to them. */
+ ret = unix_set_metadata(fd, inode, path, ctx);
+ if (close(fd) && !ret) {
+ ERROR_WITH_ERRNO("Error closing \"%s\"", path);
+ ret = WIMLIB_ERR_WRITE;
+ }
}
if (ret)
return ret;
- return unix_create_hardlinks(inode, dentry, path, ctx);
+ ret = unix_create_hardlinks(inode, dentry, path, ctx);
+ if (ret)
+ return ret;
+
+ return report_file_created(&ctx->common);
}
static int
return 0;
}
+static void
+unix_count_dentries(const struct list_head *dentry_list,
+ uint64_t *dir_count_ret, uint64_t *empty_file_count_ret)
+{
+ const struct wim_dentry *dentry;
+ uint64_t dir_count = 0;
+ uint64_t empty_file_count = 0;
+
+ list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
+
+ const struct wim_inode *inode = dentry->d_inode;
+
+ if (inode_is_directory(inode))
+ dir_count++;
+ else if ((dentry == inode_first_extraction_dentry(inode)) &&
+ !inode_unnamed_lte_resolved(inode))
+ empty_file_count++;
+ }
+
+ *dir_count_ret = dir_count;
+ *empty_file_count_ret = empty_file_count;
+}
+
static int
unix_create_symlink(const struct wim_inode *inode, const char *path,
const u8 *rpdata, u16 rpdatalen, bool rpfix,
return 0;
}
+ /* This should be ensured by extract_stream_list() */
+ wimlib_assert(ctx->num_open_fds < MAX_OPEN_STREAMS);
+
first_dentry = inode_first_extraction_dentry(inode);
first_path = unix_build_extraction_path(first_dentry, ctx);
retry_create:
/* Called when starting to read a single-instance stream for extraction */
static int
-unix_begin_extract_stream(struct wim_lookup_table_entry *stream,
- u32 flags, void *_ctx)
+unix_begin_extract_stream(struct wim_lookup_table_entry *stream, void *_ctx)
{
struct unix_apply_ctx *ctx = _ctx;
const struct stream_owner *owners = stream_owners(stream);
/* We finally have the symlink data, so we can create
* the symlink. */
const char *path;
+ bool rpfix;
+
+ rpfix = (ctx->common.extract_flags &
+ WIMLIB_EXTRACT_FLAG_RPFIX) &&
+ !inode->i_not_rpfixed;
path = unix_build_inode_extraction_path(inode, ctx);
ret = unix_create_symlink(inode, path,
ctx->reparse_data,
stream->size,
- (ctx->common.extract_flags &
- WIMLIB_EXTRACT_FLAG_RPFIX),
+ rpfix,
ctx->target_abspath,
ctx->target_abspath_nchars);
if (ret) {
ret = unix_set_metadata(-1, dentry->d_inode, NULL, ctx);
if (ret)
return ret;
+ ret = report_file_metadata_applied(&ctx->common);
+ if (ret)
+ return ret;
}
}
return 0;
int ret;
struct unix_apply_ctx *ctx = (struct unix_apply_ctx *)_ctx;
size_t path_max;
+ uint64_t dir_count;
+ uint64_t empty_file_count;
/* Compute the maximum path length that will be needed, then allocate
* some path buffers. */
* because we can't extract any other files until their directories
* exist. Empty files are needed because they don't have
* representatives in the stream list. */
+
+ unix_count_dentries(dentry_list, &dir_count, &empty_file_count);
+
+ ret = start_file_structure_phase(&ctx->common, dir_count + empty_file_count);
+ if (ret)
+ goto out;
+
ret = unix_create_dirs_and_empty_files(dentry_list, ctx);
if (ret)
goto out;
+ ret = end_file_structure_phase(&ctx->common);
+ if (ret)
+ goto out;
+
/* Get full path to target if needed for absolute symlink fixups. */
if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_RPFIX) &&
ctx->common.required_features.symlink_reparse_points)
if (ret)
goto out;
+
/* Set directory metadata. We do this last so that we get the right
* directory timestamps. */
+ ret = start_file_metadata_phase(&ctx->common, dir_count);
+ if (ret)
+ goto out;
+
ret = unix_set_dir_metadata(dentry_list, ctx);
+ if (ret)
+ goto out;
+
+ ret = end_file_metadata_phase(&ctx->common);
+ if (ret)
+ goto out;
+
+ if (ctx->num_special_files_ignored) {
+ WARNING("%lu special files were not extracted due to EPERM!",
+ ctx->num_special_files_ignored);
+ }
out:
for (unsigned i = 0; i < NUM_PATHBUFS; i++)
FREE(ctx->pathbufs[i]);
git://wimlib.net / wimlib / blobdiff