X-Git-Url: https://wimlib.net/git/?a=blobdiff_plain;f=src%2Fextract_image.c;h=96c929453f152fcd09c763e31016c626b4a7a578;hb=5ed5a1ef610700e463abd0c07aed377cce5eef47;hp=470469a0be0a8c511b2f8f97c6b3d8d747cab9f9;hpb=fea0ee9f10fbcb85ff56ca06510e96186a7611ae;p=wimlib diff --git a/src/extract_image.c b/src/extract_image.c index 470469a0..96c92945 100644 --- a/src/extract_image.c +++ b/src/extract_image.c @@ -54,10 +54,10 @@ #include #endif -static int extract_regular_file_linked(struct dentry *dentry, +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 +114,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,32 +228,45 @@ 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_full_wim_resource_to_fd(lte, out_fd); + ret = extract_wim_resource_to_fd(lte, out_fd, wim_resource_size(lte)); if (ret != 0) { 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 +284,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 +305,35 @@ 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) +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,42 +344,34 @@ 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; } - return 0; +dir_exists: + 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); + } else { + ret = 0; + } + return ret; } -/* - * 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; + struct wim_inode *inode = dentry->d_inode; size_t len; - int ret; - - if (dentry->is_extracted) - return 0; - - if (extract_flags & WIMLIB_EXTRACT_FLAG_NO_STREAMS) - if (inode_unnamed_lte_resolved(inode)) - return 0; - - if ((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]; @@ -310,32 +380,33 @@ static int apply_dentry_normal(struct dentry *dentry, void *arg) output_path[len + dentry->full_path_utf8_len] = '\0'; if (inode_is_symlink(inode)) - ret = extract_symlink(dentry, args, output_path); + return extract_symlink(dentry, args, output_path); else if (inode_is_directory(inode)) - ret = extract_directory(output_path, false); + return extract_directory((args->extract_flags & + WIMLIB_EXTRACT_FLAG_UNIX_DATA) ? dentry : NULL, + output_path, false); else - ret = extract_regular_file(dentry, args, output_path); - if (ret == 0) - dentry->is_extracted = 1; - return ret; + return extract_regular_file(dentry, args, output_path); } -/* Apply timestamp to extracted file */ -static int apply_dentry_timestamps_normal(struct dentry *dentry, void *arg) +/* 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 = strlen(args->target); char output_path[len + dentry->full_path_utf8_len + 1]; - const struct inode *inode = dentry->d_inode; + const struct wim_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'; + /* Convert the WIM timestamps, which are accurate to 100 nanoseconds, + * into struct timeval's. */ struct timeval tv[2]; - wim_timestamp_to_timeval(inode->last_access_time, &tv[0]); - wim_timestamp_to_timeval(inode->last_write_time, &tv[1]); + wim_timestamp_to_timeval(inode->i_last_access_time, &tv[0]); + wim_timestamp_to_timeval(inode->i_last_write_time, &tv[1]); #ifdef HAVE_LUTIMES ret = lutimes(output_path, tv); #else @@ -346,26 +417,52 @@ static int apply_dentry_timestamps_normal(struct dentry *dentry, void *arg) #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); + buf.actime = wim_timestamp_to_unix(inode->i_last_access_time); + buf.modtime = wim_timestamp_to_unix(inode->i_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));*/ + /*WARNING_WITH_ERRNO("Failed to set timestamp on file `%s',*/ + /*output_path");*/ args->num_lutimes_warnings++; } } return 0; } +/* 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 (args->extract_flags & WIMLIB_EXTRACT_FLAG_NO_STREAMS) + if (inode_unnamed_lte_resolved(dentry->d_inode)) + return 0; + + 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); + } + ret = args->apply_dentry(dentry, args); + if (ret == 0) + dentry->is_extracted = 1; + return ret; +} + 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 +475,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 +491,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 +508,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 +535,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 +544,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 +579,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 +599,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,40 +622,54 @@ 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 && - args->progress.extract.total_bytes != 0) + args->progress.extract.completed_bytes >= next_progress) { progress_func(WIMLIB_PROGRESS_MSG_EXTRACT_STREAMS, &args->progress); - next_progress += bytes_per_progress; + if (args->progress.extract.completed_bytes >= + args->progress.extract.total_bytes) + { + next_progress = ~0ULL; + } else { + next_progress = + min (args->progress.extract.completed_bytes + + bytes_per_progress, + args->progress.extract.total_bytes); + } } } } } -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) @@ -575,7 +685,6 @@ static int extract_single_image(WIMStruct *w, int image, 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; @@ -606,9 +715,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); @@ -617,6 +728,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) { @@ -630,8 +744,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; @@ -641,13 +757,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) @@ -659,6 +779,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); @@ -671,8 +792,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) @@ -684,7 +805,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; @@ -706,15 +827,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) @@ -738,6 +861,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");