X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fextract_image.c;h=19b87d4dc7230d52581df2d8ca560b8006577c46;hp=56c72f870e0947e7c5d05177c5f5228aa647e508;hb=7acdc3aecd7ce546727ae8239e0d942c2a00db43;hpb=52ce07dbc99a36a3050209b66a0aee257beda937 diff --git a/src/extract_image.c b/src/extract_image.c index 56c72f87..19b87d4d 100644 --- a/src/extract_image.c +++ b/src/extract_image.c @@ -2,15 +2,10 @@ * extract_image.c * * Support for extracting WIM files. - * - * This code does NOT contain any filesystem-specific features. In particular, - * security information (i.e. file permissions) and alternate data streams are - * ignored, except possibly to read an alternate data stream that contains - * symbolic link data. */ /* - * Copyright (C) 2012 Eric Biggers + * Copyright (C) 2012, 2013 Eric Biggers * * This file is part of wimlib, a library for working with WIM files. * @@ -31,33 +26,42 @@ #include "config.h" #include + +#ifdef __WIN32__ +# include "win32.h" +#else +# ifdef HAVE_UTIME_H +# include +# endif +# include "timestamp.h" +# include +#endif + #include #include +#include #include #include -#include -#include - -#ifdef HAVE_UTIME_H -#include -#endif - #include #include "dentry.h" #include "lookup_table.h" -#include "timestamp.h" #include "wimlib_internal.h" #include "xml.h" #ifdef WITH_NTFS_3G -#include +# include +#endif + +#ifdef HAVE_ALLOCA_H +# include #endif -static int extract_regular_file_linked(struct dentry *dentry, +#ifndef __WIN32__ +static int extract_regular_file_linked(struct wim_dentry *dentry, const char *output_path, struct apply_args *args, - struct lookup_table_entry *lte) + struct wim_lookup_table_entry *lte) { /* This mode overrides the normal hard-link extraction and * instead either symlinks or hardlinks *all* identical files in @@ -114,44 +118,101 @@ static int extract_regular_file_linked(struct dentry *dentry, return 0; } -static int extract_regular_file_unlinked(struct dentry *dentry, +static int symlink_apply_unix_data(const char *link, + const struct wimlib_unix_data *unix_data) +{ + if (lchown(link, unix_data->uid, unix_data->gid)) { + if (errno == EPERM) { + /* Ignore */ + WARNING_WITH_ERRNO("failed to set symlink UNIX owner/group"); + } else { + ERROR_WITH_ERRNO("failed to set symlink UNIX owner/group"); + return WIMLIB_ERR_INVALID_DENTRY; + } + } + return 0; +} + +static int fd_apply_unix_data(int fd, const struct wimlib_unix_data *unix_data) +{ + if (fchown(fd, unix_data->uid, unix_data->gid)) { + if (errno == EPERM) { + WARNING_WITH_ERRNO("failed to set file UNIX owner/group"); + /* Ignore? */ + } else { + ERROR_WITH_ERRNO("failed to set file UNIX owner/group"); + return WIMLIB_ERR_INVALID_DENTRY; + } + } + + if (fchmod(fd, unix_data->mode)) { + if (errno == EPERM) { + WARNING_WITH_ERRNO("failed to set UNIX file mode"); + /* Ignore? */ + } else { + ERROR_WITH_ERRNO("failed to set UNIX file mode"); + return WIMLIB_ERR_INVALID_DENTRY; + } + } + return 0; +} + +static int dir_apply_unix_data(const char *dir, + const struct wimlib_unix_data *unix_data) +{ + int dfd = open(dir, O_RDONLY); + int ret; + if (dfd >= 0) { + ret = fd_apply_unix_data(dfd, unix_data); + if (close(dfd)) { + ERROR_WITH_ERRNO("can't close directory `%s'", dir); + ret = WIMLIB_ERR_MKDIR; + } + } else { + ERROR_WITH_ERRNO("can't open directory `%s'", dir); + ret = WIMLIB_ERR_MKDIR; + } + return ret; +} + +static int extract_regular_file_unlinked(struct wim_dentry *dentry, struct apply_args *args, const char *output_path, - struct lookup_table_entry *lte) + struct wim_lookup_table_entry *lte) { /* Normal mode of extraction. Regular files and hard links are * extracted in the way that they appear in the WIM. */ int out_fd; int ret; - struct inode *inode = dentry->d_inode; + struct wim_inode *inode = dentry->d_inode; if (!((args->extract_flags & WIMLIB_EXTRACT_FLAG_MULTI_IMAGE) && (args->extract_flags & (WIMLIB_EXTRACT_FLAG_SYMLINK | WIMLIB_EXTRACT_FLAG_HARDLINK)))) { - /* If the dentry is one of a hard link set of at least 2 + /* If the dentry is part of a hard link set of at least 2 * dentries and 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 inode->extracted_file field so that other - * dentries in the hard link group can link to it. */ - if (inode->link_count > 1) { - if (inode->extracted_file) { + * already-extracted directory. Otherwise, extract the file and + * set the inode->i_extracted_file field so that other dentries + * in the hard link group can link to it. */ + if (inode->i_nlink > 1) { + if (inode->i_extracted_file) { DEBUG("Extracting hard link `%s' => `%s'", - output_path, inode->extracted_file); - if (link(inode->extracted_file, output_path) != 0) { + output_path, inode->i_extracted_file); + if (link(inode->i_extracted_file, output_path) != 0) { ERROR_WITH_ERRNO("Failed to hard link " "`%s' to `%s'", output_path, - inode->extracted_file); + inode->i_extracted_file); return WIMLIB_ERR_LINK; } return 0; } - FREE(inode->extracted_file); - inode->extracted_file = STRDUP(output_path); - if (!inode->extracted_file) { + FREE(inode->i_extracted_file); + inode->i_extracted_file = STRDUP(output_path); + if (!inode->i_extracted_file) { ERROR("Failed to allocate memory for filename"); return WIMLIB_ERR_NOMEM; } @@ -171,7 +232,7 @@ static int extract_regular_file_unlinked(struct dentry *dentry, /* Empty file with no lookup table entry */ DEBUG("Empty file `%s'.", output_path); ret = 0; - goto out; + goto out_extract_unix_data; } ret = extract_wim_resource_to_fd(lte, out_fd, wim_resource_size(lte)); @@ -179,24 +240,37 @@ static int extract_regular_file_unlinked(struct dentry *dentry, ERROR("Failed to extract resource to `%s'", output_path); goto out; } - args->progress.extract.completed_bytes += wim_resource_size(lte); + +out_extract_unix_data: + if (args->extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) { + struct wimlib_unix_data unix_data; + ret = inode_get_unix_data(inode, &unix_data, NULL); + if (ret > 0) + ; + else if (ret < 0) + ret = 0; + else + ret = fd_apply_unix_data(out_fd, &unix_data); + if (ret != 0) + goto out; + } + if (lte) + args->progress.extract.completed_bytes += wim_resource_size(lte); out: if (close(out_fd) != 0) { ERROR_WITH_ERRNO("Failed to close file `%s'", output_path); - ret = WIMLIB_ERR_WRITE; + if (ret == 0) + ret = WIMLIB_ERR_WRITE; } return ret; } -/* - * Extracts a regular file from the WIM archive. - */ -static int extract_regular_file(struct dentry *dentry, +static int extract_regular_file(struct wim_dentry *dentry, struct apply_args *args, const char *output_path) { - struct lookup_table_entry *lte; - const struct inode *inode = dentry->d_inode; + struct wim_lookup_table_entry *lte; + const struct wim_inode *inode = dentry->d_inode; lte = inode_unnamed_lte_resolved(inode); @@ -214,14 +288,14 @@ static int extract_regular_file(struct dentry *dentry, return extract_regular_file_unlinked(dentry, args, output_path, lte); } -static int extract_symlink(struct dentry *dentry, +static int extract_symlink(struct wim_dentry *dentry, struct apply_args *args, const char *output_path) { char target[4096]; ssize_t ret = inode_readlink(dentry->d_inode, target, sizeof(target), args->w, 0); - struct lookup_table_entry *lte; + struct wim_lookup_table_entry *lte; if (ret <= 0) { ERROR("Could not read the symbolic link from dentry `%s'", @@ -235,27 +309,37 @@ static int extract_symlink(struct dentry *dentry, return WIMLIB_ERR_LINK; } lte = inode_unnamed_lte_resolved(dentry->d_inode); + wimlib_assert(lte != NULL); + if (args->extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) { + struct wimlib_unix_data unix_data; + ret = inode_get_unix_data(dentry->d_inode, &unix_data, NULL); + if (ret > 0) + ; + else if (ret < 0) + ret = 0; + else + ret = symlink_apply_unix_data(output_path, &unix_data); + if (ret != 0) + return ret; + } args->progress.extract.completed_bytes += wim_resource_size(lte); return 0; } -/* - * Extracts a directory from the WIM archive. - * - * @dentry: The directory entry for the directory. - * @output_path: The path to which the directory is to be extracted to. - * @return: True on success, false on failure. - */ -static int extract_directory(const char *output_path, bool is_root) +#endif /* !__WIN32__ */ + +static int extract_directory(struct wim_dentry *dentry, + const char *output_path, bool is_root) { int ret; struct stat stbuf; + ret = stat(output_path, &stbuf); if (ret == 0) { if (S_ISDIR(stbuf.st_mode)) { /*if (!is_root)*/ /*WARNING("`%s' already exists", output_path);*/ - return 0; + goto dir_exists; } else { ERROR("`%s' is not a directory", output_path); return WIMLIB_ERR_MKDIR; @@ -266,106 +350,187 @@ static int extract_directory(const char *output_path, bool is_root) return WIMLIB_ERR_STAT; } } - /* Compute the output path directory to the directory. */ if (mkdir(output_path, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) != 0) { ERROR_WITH_ERRNO("Cannot create directory `%s'", output_path); return WIMLIB_ERR_MKDIR; } +dir_exists: + ret = 0; +#ifndef __WIN32__ + if (dentry) { + struct wimlib_unix_data unix_data; + ret = inode_get_unix_data(dentry->d_inode, &unix_data, NULL); + if (ret > 0) + ; + else if (ret < 0) + ret = 0; + else + ret = dir_apply_unix_data(output_path, &unix_data); + } +#endif + return ret; +} + +#ifndef __WIN32__ +static int unix_do_apply_dentry(const char *output_path, + size_t output_path_len, + struct wim_dentry *dentry, + struct apply_args *args) +{ + const struct wim_inode *inode = dentry->d_inode; + + if (inode_is_symlink(inode)) + return extract_symlink(dentry, args, output_path); + else if (inode_is_directory(inode)) + return extract_directory((args->extract_flags & + WIMLIB_EXTRACT_FLAG_UNIX_DATA) ? dentry : NULL, + output_path, false); + else + return extract_regular_file(dentry, args, output_path); +} + +static int unix_do_apply_dentry_timestamps(const char *output_path, + size_t output_path_len, + const struct wim_dentry *dentry, + struct apply_args *args) +{ + int ret; + const struct wim_inode *inode = dentry->d_inode; + +#ifdef HAVE_UTIMENSAT + /* Convert the WIM timestamps, which are accurate to 100 nanoseconds, + * into `struct timespec's for passing to utimensat(), which is accurate + * to 1 nanosecond. */ + + struct timespec ts[2]; + ts[0] = wim_timestamp_to_timespec(inode->i_last_access_time); + ts[1] = wim_timestamp_to_timespec(inode->i_last_write_time); + ret = utimensat(AT_FDCWD, output_path, ts, AT_SYMLINK_NOFOLLOW); + if (ret) + ret = errno; +#else + ret = ENOSYS; +#endif + + if (ret == ENOSYS) { + /* utimensat() not implemented or not available */ + #ifdef HAVE_LUTIMES + /* Convert the WIM timestamps, which are accurate to 100 + * nanoseconds, into `struct timeval's for passing to lutimes(), + * which is accurate to 1 microsecond. */ + struct timeval tv[2]; + tv[0] = wim_timestamp_to_timeval(inode->i_last_access_time); + tv[1] = wim_timestamp_to_timeval(inode->i_last_write_time); + ret = lutimes(output_path, tv); + if (ret) + ret = errno; + #endif + } + + if (ret == ENOSYS) { + /* utimensat() and lutimes() both not implemented or not + * available */ + #ifdef HAVE_UTIME + /* Convert the WIM timestamps, which are accurate to 100 + * nanoseconds, into a `struct utimbuf's for passing to + * utime(), which is accurate to 1 second. */ + struct utimbuf buf; + buf.actime = wim_timestamp_to_unix(inode->i_last_access_time); + buf.modtime = wim_timestamp_to_unix(inode->i_last_write_time); + ret = utime(output_path, &buf); + #endif + } + if (ret && args->num_utime_warnings < 10) { + WARNING_WITH_ERRNO("Failed to set timestamp on file `%s'", + output_path); + args->num_utime_warnings++; + } return 0; } +#endif /* !__WIN32__ */ -/* - * Extracts a file, directory, or symbolic link from the WIM archive. For use - * in for_dentry_in_tree(). - */ -static int apply_dentry_normal(struct dentry *dentry, void *arg) +/* Extracts a file, directory, or symbolic link from the WIM archive. */ +static int apply_dentry_normal(struct wim_dentry *dentry, void *arg) { struct apply_args *args = arg; - int extract_flags = args->extract_flags; - struct inode *inode = dentry->d_inode; size_t len; + char *output_path; + + len = strlen(args->target); + if (dentry_is_root(dentry)) { + output_path = (char*)args->target; + } else { + output_path = alloca(len + dentry->full_path_utf8_len + 1); + memcpy(output_path, args->target, len); + memcpy(output_path + len, dentry->full_path_utf8, dentry->full_path_utf8_len); + output_path[len + dentry->full_path_utf8_len] = '\0'; + len += dentry->full_path_utf8_len; + } +#ifdef __WIN32__ + return win32_do_apply_dentry(output_path, len, dentry, args); +#else + return unix_do_apply_dentry(output_path, len, dentry, args); +#endif +} + + +/* Apply timestamps to an extracted file or directory */ +static int apply_dentry_timestamps_normal(struct wim_dentry *dentry, void *arg) +{ + struct apply_args *args = arg; + size_t len; + char *output_path; + + len = strlen(args->target); + if (dentry_is_root(dentry)) { + output_path = (char*)args->target; + } else { + output_path = alloca(len + dentry->full_path_utf8_len + 1); + memcpy(output_path, args->target, len); + memcpy(output_path + len, dentry->full_path_utf8, dentry->full_path_utf8_len); + output_path[len + dentry->full_path_utf8_len] = '\0'; + len += dentry->full_path_utf8_len; + } +#ifdef __WIN32__ + return win32_do_apply_dentry_timestamps(output_path, len, dentry, args); +#else + return unix_do_apply_dentry_timestamps(output_path, len, dentry, args); +#endif +} + +/* Extract a dentry if it hasn't already been extracted, and either the dentry + * has no streams or WIMLIB_EXTRACT_FLAG_NO_STREAMS is not specified. */ +static int maybe_apply_dentry(struct wim_dentry *dentry, void *arg) +{ + struct apply_args *args = arg; int ret; if (dentry->is_extracted) return 0; - if (extract_flags & WIMLIB_EXTRACT_FLAG_NO_STREAMS) - if (inode_unnamed_lte_resolved(inode)) + if (args->extract_flags & WIMLIB_EXTRACT_FLAG_NO_STREAMS) + if (inode_unnamed_lte_resolved(dentry->d_inode)) return 0; - if ((extract_flags & WIMLIB_EXTRACT_FLAG_VERBOSE) && - args->progress_func) - { + if ((args->extract_flags & WIMLIB_EXTRACT_FLAG_VERBOSE) && + args->progress_func) { args->progress.extract.cur_path = dentry->full_path_utf8; args->progress_func(WIMLIB_PROGRESS_MSG_EXTRACT_DENTRY, &args->progress); } - - len = strlen(args->target); - char output_path[len + dentry->full_path_utf8_len + 1]; - memcpy(output_path, args->target, len); - memcpy(output_path + len, dentry->full_path_utf8, dentry->full_path_utf8_len); - output_path[len + dentry->full_path_utf8_len] = '\0'; - - if (inode_is_symlink(inode)) - ret = extract_symlink(dentry, args, output_path); - else if (inode_is_directory(inode)) - ret = extract_directory(output_path, false); - else - ret = extract_regular_file(dentry, args, output_path); + ret = args->apply_dentry(dentry, args); if (ret == 0) dentry->is_extracted = 1; return ret; } -/* Apply timestamp to extracted file */ -static int apply_dentry_timestamps_normal(struct dentry *dentry, void *arg) -{ - struct apply_args *args = arg; - size_t len = strlen(args->target); - char output_path[len + dentry->full_path_utf8_len + 1]; - const struct inode *inode = dentry->d_inode; - int ret; - - memcpy(output_path, args->target, len); - memcpy(output_path + len, dentry->full_path_utf8, dentry->full_path_utf8_len); - output_path[len + dentry->full_path_utf8_len] = '\0'; - - struct timeval tv[2]; - wim_timestamp_to_timeval(inode->last_access_time, &tv[0]); - wim_timestamp_to_timeval(inode->last_write_time, &tv[1]); - #ifdef HAVE_LUTIMES - ret = lutimes(output_path, tv); - #else - ret = -1; - errno = ENOSYS; - #endif - if (ret != 0) { - #ifdef HAVE_UTIME - if (errno == ENOSYS) { - struct utimbuf buf; - buf.actime = wim_timestamp_to_unix(inode->last_access_time); - buf.modtime = wim_timestamp_to_unix(inode->last_write_time); - if (utime(output_path, &buf) == 0) - return 0; - } - #endif - if (errno != ENOSYS || args->num_lutimes_warnings < 10) { - /*WARNING("Failed to set timestamp on file `%s': %s",*/ - /*output_path, strerror(errno));*/ - args->num_lutimes_warnings++; - } - } - return 0; -} - static int cmp_streams_by_wim_position(const void *p1, const void *p2) { - const struct lookup_table_entry *lte1, *lte2; - lte1 = *(const struct lookup_table_entry**)p1; - lte2 = *(const struct lookup_table_entry**)p2; + const struct wim_lookup_table_entry *lte1, *lte2; + lte1 = *(const struct wim_lookup_table_entry**)p1; + lte2 = *(const struct wim_lookup_table_entry**)p2; if (lte1->resource_entry.offset < lte2->resource_entry.offset) return -1; else if (lte1->resource_entry.offset > lte2->resource_entry.offset) @@ -378,7 +543,7 @@ static int sort_stream_list_by_wim_position(struct list_head *stream_list) { struct list_head *cur; size_t num_streams; - struct lookup_table_entry **array; + struct wim_lookup_table_entry **array; size_t i; size_t array_size; @@ -394,7 +559,7 @@ static int sort_stream_list_by_wim_position(struct list_head *stream_list) } cur = stream_list->next; for (i = 0; i < num_streams; i++) { - array[i] = container_of(cur, struct lookup_table_entry, staging_list); + array[i] = container_of(cur, struct wim_lookup_table_entry, staging_list); cur = cur->next; } @@ -411,7 +576,7 @@ static void calculate_bytes_to_extract(struct list_head *stream_list, int extract_flags, union wimlib_progress_info *progress) { - struct lookup_table_entry *lte; + struct wim_lookup_table_entry *lte; u64 total_bytes = 0; u64 num_streams = 0; @@ -438,7 +603,7 @@ static void calculate_bytes_to_extract(struct list_head *stream_list, progress->extract.completed_bytes = 0; } -static void maybe_add_stream_for_extraction(struct lookup_table_entry *lte, +static void maybe_add_stream_for_extraction(struct wim_lookup_table_entry *lte, struct list_head *stream_list) { if (++lte->out_refcnt == 1) { @@ -447,30 +612,29 @@ static void maybe_add_stream_for_extraction(struct lookup_table_entry *lte, } } -static void inode_find_streams_for_extraction(struct inode *inode, +static void inode_find_streams_for_extraction(struct wim_inode *inode, struct list_head *stream_list, int extract_flags) { - struct lookup_table_entry *lte; + struct wim_lookup_table_entry *lte; bool inode_added = false; lte = inode_unnamed_lte_resolved(inode); - if (lte) { maybe_add_stream_for_extraction(lte, stream_list); - list_add_tail(&inode->lte_inode_list, <e->inode_list); + list_add_tail(&inode->i_lte_inode_list, <e->inode_list); inode_added = true; } #ifdef WITH_NTFS_3G if (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) { - for (unsigned i = 0; i < inode->num_ads; i++) { - if (inode->ads_entries[i].stream_name_len != 0) { - lte = inode->ads_entries[i].lte; + for (unsigned i = 0; i < inode->i_num_ads; i++) { + if (inode->i_ads_entries[i].stream_name_len != 0) { + lte = inode->i_ads_entries[i].lte; if (lte) { maybe_add_stream_for_extraction(lte, stream_list); if (!inode_added) { - list_add_tail(&inode->lte_inode_list, + list_add_tail(&inode->i_lte_inode_list, <e->inode_list); inode_added = true; } @@ -483,17 +647,17 @@ static void inode_find_streams_for_extraction(struct inode *inode, static void find_streams_for_extraction(struct hlist_head *inode_list, struct list_head *stream_list, - struct lookup_table *lookup_table, + struct wim_lookup_table *lookup_table, int extract_flags) { - struct inode *inode; + struct wim_inode *inode; struct hlist_node *cur; - struct dentry *dentry; + struct wim_dentry *dentry; for_lookup_table_entry(lookup_table, lte_zero_out_refcnt, NULL); INIT_LIST_HEAD(stream_list); - hlist_for_each_entry(inode, cur, inode_list, hlist) { - if (!inode->resolved) + hlist_for_each_entry(inode, cur, inode_list, i_hlist) { + if (!inode->i_resolved) inode_resolve_ltes(inode, lookup_table); inode_for_each_dentry(dentry, inode) dentry->is_extracted = 0; @@ -503,8 +667,8 @@ static void find_streams_for_extraction(struct hlist_head *inode_list, } struct apply_operations { - int (*apply_dentry)(struct dentry *dentry, void *arg); - int (*apply_dentry_timestamps)(struct dentry *dentry, void *arg); + int (*apply_dentry)(struct wim_dentry *dentry, void *arg); + int (*apply_dentry_timestamps)(struct wim_dentry *dentry, void *arg); }; static const struct apply_operations normal_apply_operations = { @@ -526,25 +690,30 @@ static int apply_stream_list(struct list_head *stream_list, { uint64_t bytes_per_progress = args->progress.extract.total_bytes / 100; uint64_t next_progress = bytes_per_progress; - struct lookup_table_entry *lte; - struct inode *inode; - struct dentry *dentry; - int ret = 0; + struct wim_lookup_table_entry *lte; + struct wim_inode *inode; + struct wim_dentry *dentry; + int ret; - /* This complicated loop is actually just looping through the dentries - * (as for_dentry_in_tree() does), but the outer loop is actually over - * the distinct streams to be extracted so that sequential reading of - * the WIM can be implemented. */ + /* This complicated loop is essentially looping through the dentries, + * although dentries may be visited more than once (if a dentry contains + * two different nonempty streams) or not at all (if a dentry contains + * no non-empty streams). + * + * The outer loop is over the distinct streams to be extracted so that + * sequential reading of the WIM can be implemented. */ /* For each distinct stream to be extracted */ list_for_each_entry(lte, stream_list, staging_list) { /* For each inode that contains the stream */ - list_for_each_entry(inode, <e->inode_list, lte_inode_list) { + list_for_each_entry(inode, <e->inode_list, i_lte_inode_list) { /* For each dentry that points to the inode */ inode_for_each_dentry(dentry, inode) { - ret = ops->apply_dentry(dentry, args); + /* Extract the dentry if it was not already + * extracted */ + ret = maybe_apply_dentry(dentry, args); if (ret != 0) - goto out; + return ret; if (progress_func && args->progress.extract.completed_bytes >= next_progress) { @@ -564,10 +733,11 @@ static int apply_stream_list(struct list_head *stream_list, } } } -out: - return ret; + return 0; } +/* Extracts the image @image from the WIM @w to the directory or NTFS volume + * @target. */ static int extract_single_image(WIMStruct *w, int image, const char *target, int extract_flags, wimlib_progress_func_t progress_func) @@ -579,13 +749,12 @@ static int extract_single_image(WIMStruct *w, int image, struct apply_args args; const struct apply_operations *ops; - args.w = w; - args.target = target; - args.extract_flags = extract_flags; - args.num_lutimes_warnings = 0; - args.target = target; - args.stream_list = &stream_list; - args.progress_func = progress_func; + args.w = w; + args.target = target; + args.extract_flags = extract_flags; + args.num_utime_warnings = 0; + args.stream_list = &stream_list; + args.progress_func = progress_func; if (progress_func) { args.progress.extract.wimfile_name = w->filename; @@ -614,9 +783,11 @@ static int extract_single_image(WIMStruct *w, int image, inode_list = &w->image_metadata[image - 1].inode_list; + /* Build a list of the streams that need to be extracted */ find_streams_for_extraction(inode_list, &stream_list, w->lookup_table, extract_flags); + /* Calculate the number of bytes of data that will be extracted */ calculate_bytes_to_extract(&stream_list, extract_flags, &args.progress); @@ -625,6 +796,9 @@ static int extract_single_image(WIMStruct *w, int image, &args.progress); } + /* If a sequential extraction was specified, sort the streams to be + * extracted by their position in the WIM file, so that the WIM file can + * be read sequentially. */ if (extract_flags & WIMLIB_EXTRACT_FLAG_SEQUENTIAL) { ret = sort_stream_list_by_wim_position(&stream_list); if (ret != 0) { @@ -638,8 +812,10 @@ static int extract_single_image(WIMStruct *w, int image, &args.progress); } + /* Make the directory structure and extract empty files */ args.extract_flags |= WIMLIB_EXTRACT_FLAG_NO_STREAMS; - ret = for_dentry_in_tree(wim_root_dentry(w), ops->apply_dentry, &args); + args.apply_dentry = ops->apply_dentry; + ret = for_dentry_in_tree(wim_root_dentry(w), maybe_apply_dentry, &args); args.extract_flags &= ~WIMLIB_EXTRACT_FLAG_NO_STREAMS; if (ret != 0) goto out; @@ -649,13 +825,17 @@ static int extract_single_image(WIMStruct *w, int image, &args.progress); } + /* Extract non-empty files */ ret = apply_stream_list(&stream_list, &args, ops, progress_func); if (ret != 0) goto out; - if (progress_func) - progress_func(WIMLIB_PROGRESS_MSG_APPLY_TIMESTAMPS, NULL); + if (progress_func) { + progress_func(WIMLIB_PROGRESS_MSG_APPLY_TIMESTAMPS, + &args.progress); + } + /* Apply timestamps */ ret = for_dentry_in_tree_depth(wim_root_dentry(w), ops->apply_dentry_timestamps, &args); if (ret != 0) @@ -667,6 +847,7 @@ static int extract_single_image(WIMStruct *w, int image, } out: #ifdef WITH_NTFS_3G + /* Unmount the NTFS volume */ if (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) { if (ntfs_umount(args.vol, FALSE) != 0) { ERROR_WITH_ERRNO("Failed to unmount NTFS volume `%s'", args.target); @@ -679,8 +860,8 @@ out: } -/* Extracts all images from the WIM to @output_dir, with the images placed in - * subdirectories named by their image names. */ +/* Extracts all images from the WIM to the directory @target, with the images + * placed in subdirectories named by their image names. */ static int extract_all_images(WIMStruct *w, const char *target, int extract_flags, wimlib_progress_func_t progress_func) @@ -692,7 +873,7 @@ static int extract_all_images(WIMStruct *w, const char *target, int image; const char *image_name; - ret = extract_directory(target, true); + ret = extract_directory(NULL, target, true); if (ret != 0) return ret; @@ -714,15 +895,17 @@ static int extract_all_images(WIMStruct *w, const char *target, return 0; } -/* Extracts a single image or all images from a WIM file. */ -WIMLIBAPI int wimlib_extract_image(WIMStruct *w, int image, +/* Extracts a single image or all images from a WIM file to a directory or NTFS + * volume. */ +WIMLIBAPI int wimlib_extract_image(WIMStruct *w, + int image, const char *target, int extract_flags, WIMStruct **additional_swms, unsigned num_additional_swms, wimlib_progress_func_t progress_func) { - struct lookup_table *joined_tab, *w_tab_save; + struct wim_lookup_table *joined_tab, *w_tab_save; int ret; if (!target) @@ -734,6 +917,17 @@ WIMLIBAPI int wimlib_extract_image(WIMStruct *w, int image, == (WIMLIB_EXTRACT_FLAG_SYMLINK | WIMLIB_EXTRACT_FLAG_HARDLINK)) return WIMLIB_ERR_INVALID_PARAM; +#ifdef __WIN32__ + if (extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) { + ERROR("Extracting UNIX data is not supported on Windows"); + return WIMLIB_ERR_INVALID_PARAM; + } + if (extract_flags & (WIMLIB_EXTRACT_FLAG_SYMLINK | WIMLIB_EXTRACT_FLAG_HARDLINK)) { + ERROR("Linked extraction modes are not supported on Windows"); + return WIMLIB_ERR_INVALID_PARAM; + } +#endif + if (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) { #ifdef WITH_NTFS_3G if ((extract_flags & (WIMLIB_EXTRACT_FLAG_SYMLINK | WIMLIB_EXTRACT_FLAG_HARDLINK))) { @@ -746,6 +940,10 @@ WIMLIBAPI int wimlib_extract_image(WIMStruct *w, int image, "directly to a NTFS volume"); return WIMLIB_ERR_INVALID_PARAM; } + if (extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) { + ERROR("Cannot restore UNIX-specific data in the NTFS extraction mode"); + return WIMLIB_ERR_INVALID_PARAM; + } #else ERROR("wimlib was compiled without support for NTFS-3g, so"); ERROR("we cannot apply a WIM image directly to a NTFS volume"); @@ -766,6 +964,9 @@ WIMLIBAPI int wimlib_extract_image(WIMStruct *w, int image, w->lookup_table = joined_tab; } +#ifdef __WIN32__ + win32_acquire_restore_privileges(); +#endif if (image == WIMLIB_ALL_IMAGES) { extract_flags |= WIMLIB_EXTRACT_FLAG_MULTI_IMAGE; ret = extract_all_images(w, target, extract_flags, @@ -775,6 +976,9 @@ WIMLIBAPI int wimlib_extract_image(WIMStruct *w, int image, ret = extract_single_image(w, image, target, extract_flags, progress_func); } +#ifdef __WIN32__ + win32_release_restore_privileges(); +#endif if (extract_flags & (WIMLIB_EXTRACT_FLAG_SYMLINK | WIMLIB_EXTRACT_FLAG_HARDLINK))