From: Eric Biggers Date: Sat, 28 Dec 2013 15:37:38 +0000 (-0600) Subject: Tweak support for extracting paths X-Git-Tag: v1.6.0~80 X-Git-Url: https://wimlib.net/git/?p=wimlib;a=commitdiff_plain;h=eb83f143258d4f8bf072694d7ed5130f40824bd7 Tweak support for extracting paths --- diff --git a/include/wimlib/apply.h b/include/wimlib/apply.h index 11a03651..5cd6e10f 100644 --- a/include/wimlib/apply.h +++ b/include/wimlib/apply.h @@ -211,11 +211,13 @@ struct apply_ctx { size_t target_nchars; wimlib_progress_func_t progress_func; union wimlib_progress_info progress; - struct wim_dentry *extract_root; const struct apply_operations *ops; + struct list_head stream_list; struct wim_features supported_features; + bool root_dentry_is_special; u32 supported_attributes_mask; - struct list_head stream_list; + + struct wim_dentry *extract_root; tchar *realtarget; size_t realtarget_nchars; unsigned long invalid_sequence; @@ -224,7 +226,6 @@ struct apply_ctx { struct filedes tmpfile_fd; tchar *tmpfile_name; u64 num_streams_remaining; - bool root_dentry_is_special; uint64_t next_progress; intptr_t private[8]; }; diff --git a/include/wimlib/dentry.h b/include/wimlib/dentry.h index 22f0aff5..f61060e4 100644 --- a/include/wimlib/dentry.h +++ b/include/wimlib/dentry.h @@ -151,16 +151,17 @@ struct wim_dentry { * including the terminating null character. */ u32 full_path_nbytes; + /* For extraction operations, this flag will be set on dentries in the + * tree being extracted. Otherwise this will always be 0. */ + u8 in_extraction_tree : 1; + /* For extraction operations, this flag will be set when a dentry in the * tree being extracted is not being extracted for some reason (file - * type not supported by target filesystem or contains invalid - * characters). Otherwise this will always be 0. */ + * type not supported by target filesystem, contains invalid characters, + * or not in one of the multiple sub-trees being extracted). Otherwise + * this will always be 0. */ u8 extraction_skipped : 1; - /* For extraction operations, this flag will be set on dentries in the - * tree being extracted. */ - u8 in_extraction_tree : 1; - /* During extraction extractions, this flag will be set after the * "skeleton" of the dentry has been extracted. */ u8 skeleton_extracted : 1; @@ -445,10 +446,16 @@ extern int set_dentry_name(struct wim_dentry *dentry, const tchar *new_name); +/* Note: the NTFS-3g headers define CASE_SENSITIVE, hence the WIMLIB prefix. */ typedef enum { - /* NTFS-3g headers define CASE_SENSITIVE... */ + /* Use either case-sensitive or case-insensitive search, depending on + * the variable @default_ignore_case. */ WIMLIB_CASE_PLATFORM_DEFAULT = 0, + + /* Use case-sensitive search. */ WIMLIB_CASE_SENSITIVE = 1, + + /* Use case-insensitive search. */ WIMLIB_CASE_INSENSITIVE = 2, } CASE_SENSITIVITY_TYPE; diff --git a/include/wimlib/wildcard.h b/include/wimlib/wildcard.h index 4506ac3f..29636a44 100644 --- a/include/wimlib/wildcard.h +++ b/include/wimlib/wildcard.h @@ -3,18 +3,16 @@ #include -#define WILDCARD_FLAG_USE_LITERAL_IF_NO_MATCHES 0x00000001 -#define WILDCARD_FLAG_WARN_IF_NO_MATCH 0x00000002 -#define WILDCARD_FLAG_ERROR_IF_NO_MATCH 0x00000004 -#define WILDCARD_FLAG_CASE_INSENSITIVE 0x00000008 +#define WILDCARD_FLAG_WARN_IF_NO_MATCH 0x00000001 +#define WILDCARD_FLAG_ERROR_IF_NO_MATCH 0x00000002 +#define WILDCARD_FLAG_CASE_INSENSITIVE 0x00000004 extern int -expand_wildcard_wim_paths(WIMStruct *wim, - const tchar * const *wildcards, - size_t num_wildcards, - tchar ***expanded_paths_ret, - size_t *num_expanded_paths_ret, - u32 flags); +expand_wildcard(WIMStruct *wim, + const tchar *wildcard_path, + int (*consume_dentry)(struct wim_dentry *, void *), + void *consume_dentry_ctx, + u32 flags); #ifdef __WIN32__ extern int diff --git a/src/dentry.c b/src/dentry.c index ad78f7db..1abe6ba7 100644 --- a/src/dentry.c +++ b/src/dentry.c @@ -671,6 +671,9 @@ ads_entry_has_name(const struct wim_ads_entry *entry, ignore_case); } +/* Default case sensitivity behavior for searches with + * WIMLIB_CASE_PLATFORM_DEFAULT specified. This can be modified by + * wimlib_global_init(). */ bool default_ignore_case = #ifdef __WIN32__ true diff --git a/src/extract.c b/src/extract.c index 4204acab..abce21f0 100644 --- a/src/extract.c +++ b/src/extract.c @@ -69,7 +69,8 @@ #define WIMLIB_EXTRACT_FLAG_MULTI_IMAGE 0x80000000 #define WIMLIB_EXTRACT_FLAG_FROM_PIPE 0x40000000 -#define WIMLIB_EXTRACT_MASK_PUBLIC 0x3fffffff +#define WIMLIB_EXTRACT_FLAG_PATHMODE 0x20000000 +#define WIMLIB_EXTRACT_MASK_PUBLIC 0x1fffffff /* Given a WIM dentry in the tree to be extracted, resolve all streams in the * corresponding inode and set 'out_refcnt' in each to 0. */ @@ -1745,8 +1746,6 @@ dentry_calculate_extraction_path(struct wim_dentry *dentry, void *_args) struct apply_ctx *ctx = _args; int ret; - dentry->in_extraction_tree = 1; - if (dentry == ctx->extract_root || dentry->extraction_skipped) return 0; @@ -1761,38 +1760,36 @@ dentry_calculate_extraction_path(struct wim_dentry *dentry, void *_args) goto skip_dentry; } -#ifdef __WIN32__ if (!ctx->ops->supports_case_sensitive_filenames) { struct wim_dentry *other; list_for_each_entry(other, &dentry->case_insensitive_conflict_list, case_insensitive_conflict_list) { - if (ctx->extract_flags & - WIMLIB_EXTRACT_FLAG_ALL_CASE_CONFLICTS) { - WARNING("\"%"TS"\" has the same " - "case-insensitive name as " - "\"%"TS"\"; extracting " - "dummy name instead", - dentry_full_path(dentry), - dentry_full_path(other)); - goto out_replace; - } else { - WARNING("Not extracting \"%"TS"\": " - "has same case-insensitive " - "name as \"%"TS"\"", - dentry_full_path(dentry), - dentry_full_path(other)); - goto skip_dentry; + if (!other->extraction_skipped) { + if (ctx->extract_flags & + WIMLIB_EXTRACT_FLAG_ALL_CASE_CONFLICTS) { + WARNING("\"%"TS"\" has the same " + "case-insensitive name as " + "\"%"TS"\"; extracting " + "dummy name instead", + dentry_full_path(dentry), + dentry_full_path(other)); + goto out_replace; + } else { + WARNING("Not extracting \"%"TS"\": " + "has same case-insensitive " + "name as \"%"TS"\"", + dentry_full_path(dentry), + dentry_full_path(other)); + goto skip_dentry; + } } } } -#else /* __WIN32__ */ - wimlib_assert(ctx->ops->supports_case_sensitive_filenames); -#endif /* !__WIN32__ */ if (file_name_valid(dentry->file_name, dentry->file_name_nbytes / 2, false)) { -#ifdef __WIN32__ +#if TCHAR_IS_UTF16LE dentry->extraction_name = dentry->file_name; dentry->extraction_name_nchars = dentry->file_name_nbytes / 2; return 0; @@ -1827,7 +1824,7 @@ out_replace: tchar *tchar_name; size_t tchar_nchars; - #ifdef __WIN32__ + #if TCHAR_IS_UTF16LE tchar_name = utf16_name_copy; tchar_nchars = dentry->file_name_nbytes / 2; #else @@ -1844,7 +1841,7 @@ out_replace: fixed_name_num_chars += tsprintf(fixed_name + tchar_nchars, T(" (invalid filename #%lu)"), ++ctx->invalid_sequence); - #ifndef __WIN32__ + #if !TCHAR_IS_UTF16LE FREE(tchar_name); #endif dentry->extraction_name = memdup(fixed_name, @@ -1887,6 +1884,9 @@ dentry_tally_features(struct wim_dentry *dentry, void *_features) struct wim_features *features = _features; struct wim_inode *inode = dentry->d_inode; + if (dentry->extraction_skipped) + return 0; + if (inode->i_attributes & FILE_ATTRIBUTE_ARCHIVE) features->archive_files++; if (inode->i_attributes & FILE_ATTRIBUTE_HIDDEN) @@ -1969,7 +1969,8 @@ do_feature_check(const struct wim_features *required_features, const struct wim_features *supported_features, int extract_flags, const struct apply_operations *ops, - const tchar *wim_source_path) + const tchar *wim_source_path, + bool warn) { const tchar *loc; const tchar *mode = T("this extraction mode"); @@ -1979,148 +1980,150 @@ do_feature_check(const struct wim_features *required_features, else loc = wim_source_path; - /* We're an archive program, so theoretically we can do what we want - * with FILE_ATTRIBUTE_ARCHIVE (which is a dumb flag anyway). Don't - * bother the user about it. */ + if (warn) { + /* We're an archive program, so theoretically we can do what we want + * with FILE_ATTRIBUTE_ARCHIVE (which is a dumb flag anyway). Don't + * bother the user about it. */ #if 0 - if (required_features->archive_files && !supported_features->archive_files) - { - WARNING( - "%lu files in %"TS" are marked as archived, but this attribute\n" -" is not supported in %"TS".", - required_features->archive_files, loc, mode); - } + if (required_features->archive_files && !supported_features->archive_files) + { + WARNING( + "%lu files in %"TS" are marked as archived, but this attribute\n" + " is not supported in %"TS".", + required_features->archive_files, loc, mode); + } #endif - if (required_features->hidden_files && !supported_features->hidden_files) - { - WARNING( - "%lu files in %"TS" are marked as hidden, but this\n" -" attribute is not supported in %"TS".", - required_features->hidden_files, loc, mode); - } + if (required_features->hidden_files && !supported_features->hidden_files) + { + WARNING( + "%lu files in %"TS" are marked as hidden, but this\n" + " attribute is not supported in %"TS".", + required_features->hidden_files, loc, mode); + } - if (required_features->system_files && !supported_features->system_files) - { - WARNING( - "%lu files in %"TS" are marked as system files,\n" -" but this attribute is not supported in %"TS".", - required_features->system_files, loc, mode); - } + if (required_features->system_files && !supported_features->system_files) + { + WARNING( + "%lu files in %"TS" are marked as system files,\n" + " but this attribute is not supported in %"TS".", + required_features->system_files, loc, mode); + } - if (required_features->compressed_files && !supported_features->compressed_files) - { - WARNING( - "%lu files in %"TS" are marked as being transparently\n" -" compressed, but transparent compression is not supported in\n" -" %"TS". These files will be extracted as uncompressed.", - required_features->compressed_files, loc, mode); - } + if (required_features->compressed_files && !supported_features->compressed_files) + { + WARNING( + "%lu files in %"TS" are marked as being transparently\n" + " compressed, but transparent compression is not supported in\n" + " %"TS". These files will be extracted as uncompressed.", + required_features->compressed_files, loc, mode); + } - if (required_features->encrypted_files && !supported_features->encrypted_files) - { - WARNING( - "%lu files in %"TS" are marked as being encrypted,\n" -" but encryption is not supported in %"TS". These files\n" -" will not be extracted.", - required_features->encrypted_files, loc, mode); - } + if (required_features->encrypted_files && !supported_features->encrypted_files) + { + WARNING( + "%lu files in %"TS" are marked as being encrypted,\n" + " but encryption is not supported in %"TS". These files\n" + " will not be extracted.", + required_features->encrypted_files, loc, mode); + } - if (required_features->encrypted_directories && - !supported_features->encrypted_directories) - { - WARNING( - "%lu directories in %"TS" are marked as being encrypted,\n" -" but encryption is not supported in %"TS".\n" -" These directories will be extracted as unencrypted.", - required_features->encrypted_directories, loc, mode); - } + if (required_features->encrypted_directories && + !supported_features->encrypted_directories) + { + WARNING( + "%lu directories in %"TS" are marked as being encrypted,\n" + " but encryption is not supported in %"TS".\n" + " These directories will be extracted as unencrypted.", + required_features->encrypted_directories, loc, mode); + } - if (required_features->not_context_indexed_files && - !supported_features->not_context_indexed_files) - { - WARNING( - "%lu files in %"TS" are marked as not content indexed,\n" -" but this attribute is not supported in %"TS".", - required_features->not_context_indexed_files, loc, mode); - } + if (required_features->not_context_indexed_files && + !supported_features->not_context_indexed_files) + { + WARNING( + "%lu files in %"TS" are marked as not content indexed,\n" + " but this attribute is not supported in %"TS".", + required_features->not_context_indexed_files, loc, mode); + } - if (required_features->sparse_files && !supported_features->sparse_files) - { - WARNING( - "%lu files in %"TS" are marked as sparse, but creating\n" -" sparse files is not supported in %"TS". These files\n" -" will be extracted as non-sparse.", - required_features->sparse_files, loc, mode); - } + if (required_features->sparse_files && !supported_features->sparse_files) + { + WARNING( + "%lu files in %"TS" are marked as sparse, but creating\n" + " sparse files is not supported in %"TS". These files\n" + " will be extracted as non-sparse.", + required_features->sparse_files, loc, mode); + } - if (required_features->named_data_streams && - !supported_features->named_data_streams) - { - WARNING( - "%lu files in %"TS" contain one or more alternate (named)\n" -" data streams, which are not supported in %"TS".\n" -" Alternate data streams will NOT be extracted.", - required_features->named_data_streams, loc, mode); - } + if (required_features->named_data_streams && + !supported_features->named_data_streams) + { + WARNING( + "%lu files in %"TS" contain one or more alternate (named)\n" + " data streams, which are not supported in %"TS".\n" + " Alternate data streams will NOT be extracted.", + required_features->named_data_streams, loc, mode); + } - if (unlikely(extract_flags & (WIMLIB_EXTRACT_FLAG_HARDLINK | - WIMLIB_EXTRACT_FLAG_SYMLINK)) && - required_features->named_data_streams && - supported_features->named_data_streams) - { - WARNING( - "%lu files in %"TS" contain one or more alternate (named)\n" -" data streams, which are not supported in linked extraction mode.\n" -" Alternate data streams will NOT be extracted.", - required_features->named_data_streams, loc); - } + if (unlikely(extract_flags & (WIMLIB_EXTRACT_FLAG_HARDLINK | + WIMLIB_EXTRACT_FLAG_SYMLINK)) && + required_features->named_data_streams && + supported_features->named_data_streams) + { + WARNING( + "%lu files in %"TS" contain one or more alternate (named)\n" + " data streams, which are not supported in linked extraction mode.\n" + " Alternate data streams will NOT be extracted.", + required_features->named_data_streams, loc); + } - if (required_features->hard_links && !supported_features->hard_links) - { - WARNING( - "%lu files in %"TS" are hard links, but hard links are\n" -" not supported in %"TS". Hard links will be extracted as\n" -" duplicate copies of the linked files.", - required_features->hard_links, loc, mode); - } + if (required_features->hard_links && !supported_features->hard_links) + { + WARNING( + "%lu files in %"TS" are hard links, but hard links are\n" + " not supported in %"TS". Hard links will be extracted as\n" + " duplicate copies of the linked files.", + required_features->hard_links, loc, mode); + } - if (required_features->reparse_points && !supported_features->reparse_points) - { - if (supported_features->symlink_reparse_points) { - if (required_features->other_reparse_points) { + if (required_features->reparse_points && !supported_features->reparse_points) + { + if (supported_features->symlink_reparse_points) { + if (required_features->other_reparse_points) { + WARNING( + "%lu files in %"TS" are reparse points that are neither\n" + " symbolic links nor junction points and are not supported in\n" + " %"TS". These reparse points will not be extracted.", + required_features->other_reparse_points, loc, + mode); + } + } else { WARNING( - "%lu files in %"TS" are reparse points that are neither\n" -" symbolic links nor junction points and are not supported in\n" -" %"TS". These reparse points will not be extracted.", - required_features->other_reparse_points, loc, - mode); + "%lu files in %"TS" are reparse points, which are\n" + " not supported in %"TS" and will not be extracted.", + required_features->reparse_points, loc, mode); } - } else { - WARNING( - "%lu files in %"TS" are reparse points, which are\n" -" not supported in %"TS" and will not be extracted.", - required_features->reparse_points, loc, mode); } - } - if (required_features->security_descriptors && - !supported_features->security_descriptors) - { - WARNING( - "%lu files in %"TS" have Windows NT security descriptors,\n" -" but extracting security descriptors is not supported in\n" -" %"TS". No security descriptors will be extracted.", - required_features->security_descriptors, loc, mode); - } + if (required_features->security_descriptors && + !supported_features->security_descriptors) + { + WARNING( + "%lu files in %"TS" have Windows NT security descriptors,\n" + " but extracting security descriptors is not supported in\n" + " %"TS". No security descriptors will be extracted.", + required_features->security_descriptors, loc, mode); + } - if (required_features->short_names && !supported_features->short_names) - { - WARNING( - "%lu files in %"TS" have short (DOS) names, but\n" -" extracting short names is not supported in %"TS".\n" -" Short names will not be extracted.\n", - required_features->short_names, loc, mode); + if (required_features->short_names && !supported_features->short_names) + { + WARNING( + "%lu files in %"TS" have short (DOS) names, but\n" + " extracting short names is not supported in %"TS".\n" + " Short names will not be extracted.\n", + required_features->short_names, loc, mode); + } } if ((extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) && @@ -2204,54 +2207,38 @@ do_extract_warnings(struct apply_ctx *ctx) #endif } -/* - * extract_tree - Extract a file or directory tree from the currently selected - * WIM image. - * - * @wim: WIMStruct for the WIM file, with the desired image selected - * (as wim->current_image). - * - * @wim_source_path: - * "Canonical" (i.e. no leading or trailing slashes, path - * separators WIM_PATH_SEPARATOR) path inside the WIM image to - * extract. An empty string means the full image. - * - * @target: - * Filesystem path to extract the file or directory tree to. - * (Or, with WIMLIB_EXTRACT_FLAG_NTFS: the name of a NTFS volume.) - * - * @extract_flags: - * WIMLIB_EXTRACT_FLAG_*. Also, the private flag - * WIMLIB_EXTRACT_FLAG_MULTI_IMAGE will be set if this is being - * called through wimlib_extract_image() with WIMLIB_ALL_IMAGES as - * the image. - * - * @progress_func: - * If non-NULL, progress function for the extraction. The messages - * that may be sent in this function are: - * - * WIMLIB_PROGRESS_MSG_EXTRACT_TREE_BEGIN or - * WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_BEGIN; - * WIMLIB_PROGRESS_MSG_EXTRACT_DIR_STRUCTURE_BEGIN; - * WIMLIB_PROGRESS_MSG_EXTRACT_DIR_STRUCTURE_END; - * WIMLIB_PROGRESS_MSG_EXTRACT_DENTRY; - * WIMLIB_PROGRESS_MSG_EXTRACT_STREAMS; - * WIMLIB_PROGRESS_MSG_APPLY_TIMESTAMPS; - * WIMLIB_PROGRESS_MSG_EXTRACT_TREE_END or - * WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_END. - * - * Returns 0 on success; a positive WIMLIB_ERR_* code on failure. - */ static int -extract_tree(WIMStruct *wim, const tchar *wim_source_path, const tchar *target, - int extract_flags, wimlib_progress_func_t progress_func) +dentry_set_skipped(struct wim_dentry *dentry, void *_ignore) +{ + dentry->in_extraction_tree = 1; + dentry->extraction_skipped = 1; + return 0; +} + +static int +dentry_set_not_skipped(struct wim_dentry *dentry, void *_ignore) +{ + dentry->in_extraction_tree = 1; + dentry->extraction_skipped = 0; + return 0; +} + +static int +extract_trees(WIMStruct *wim, struct wim_dentry **trees, size_t num_trees, + const tchar *wim_source_path, const tchar *target, + int extract_flags, wimlib_progress_func_t progress_func) { - struct wim_dentry *root; struct wim_features required_features; struct apply_ctx ctx; int ret; struct wim_lookup_table_entry *lte; + wimlib_assert(num_trees != 0); + wimlib_assert(target != NULL); + + if (num_trees > 1) + wimlib_assert((extract_flags & WIMLIB_EXTRACT_FLAG_PATHMODE)); + /* Start initializing the apply_ctx. */ memset(&ctx, 0, sizeof(struct apply_ctx)); ctx.wim = wim; @@ -2271,19 +2258,32 @@ extract_tree(WIMStruct *wim, const tchar *wim_source_path, const tchar *target, } INIT_LIST_HEAD(&ctx.stream_list); - /* Translate the path to extract into the corresponding - * `struct wim_dentry', which will be the root of the - * "dentry tree" to extract. */ - root = get_dentry(wim, wim_source_path, WIMLIB_CASE_PLATFORM_DEFAULT); - if (!root) { - ERROR("Path \"%"TS"\" does not exist in WIM image %d", - wim_source_path, wim->current_image); - ret = WIMLIB_ERR_PATH_DOES_NOT_EXIST; - goto out; + if (extract_flags & WIMLIB_EXTRACT_FLAG_PATHMODE) { + /* Path mode --- there may be multiple trees, and targets are + * set relative to the root of the image. + * + * Consider all dentries to be in the extraction tree, but + * assume all to be skipped unless in one of the subtrees being + * extracted or one of the ancestors of the subtrees up to the + * image root. */ + ctx.extract_root = wim_root_dentry(wim); + for_dentry_in_tree(ctx.extract_root, dentry_set_skipped, NULL); + + for (size_t i = 0; i < num_trees; i++) { + struct wim_dentry *d; + + for_dentry_in_tree(trees[i], dentry_set_not_skipped, NULL); + d = trees[i]; + while (d != ctx.extract_root) { + d = d->parent; + dentry_set_not_skipped(d, NULL); + } + } + } else { + ctx.extract_root = trees[0]; + for_dentry_in_tree(ctx.extract_root, dentry_set_not_skipped, NULL); } - ctx.extract_root = root; - /* Select the appropriate apply_operations based on the * platform and extract_flags. */ #ifdef __WIN32__ @@ -2308,11 +2308,14 @@ extract_tree(WIMStruct *wim, const tchar *wim_source_path, const tchar *target, */ ret = ctx.ops->start_extract(target, &ctx); if (ret) - goto out; + goto out_dentry_reset_needs_extraction; - dentry_tree_get_features(root, &required_features); + /* Get and check the features required to extract the dentry tree. */ + dentry_tree_get_features(ctx.extract_root, &required_features); ret = do_feature_check(&required_features, &ctx.supported_features, - extract_flags, ctx.ops, wim_source_path); + extract_flags, ctx.ops, + wim_source_path, + !(extract_flags & WIMLIB_EXTRACT_FLAG_PATHMODE)); if (ret) goto out_finish_or_abort_extract; @@ -2327,8 +2330,9 @@ extract_tree(WIMStruct *wim, const tchar *wim_source_path, const tchar *target, /* Calculate the actual filename component of each extracted dentry. In * the process, set the dentry->extraction_skipped flag on dentries that - * are being skipped for some reason (e.g. invalid filename). */ - ret = for_dentry_in_tree(root, dentry_calculate_extraction_path, &ctx); + * are being skipped because of filename or supported features problems. */ + ret = for_dentry_in_tree(ctx.extract_root, + dentry_calculate_extraction_path, &ctx); if (ret) goto out_dentry_reset_needs_extraction; @@ -2370,7 +2374,7 @@ extract_tree(WIMStruct *wim, const tchar *wim_source_path, const tchar *target, * directory tree. (If not, extract_dentry_to_stdout() will * return an error.) */ if (extract_flags & WIMLIB_EXTRACT_FLAG_TO_STDOUT) { - ret = extract_dentry_to_stdout(root); + ret = extract_dentry_to_stdout(ctx.extract_root); goto out_teardown_stream_list; } @@ -2395,9 +2399,9 @@ extract_tree(WIMStruct *wim, const tchar *wim_source_path, const tchar *target, if (!ctx.root_dentry_is_special) { tchar path[ctx.ops->path_max]; - if (build_extraction_path(path, root, &ctx)) + if (build_extraction_path(path, ctx.extract_root, &ctx)) { - ret = extract_inode(path, &ctx, root->d_inode); + ret = extract_inode(path, &ctx, ctx.extract_root->d_inode); if (ret) goto out_free_realtarget; } @@ -2424,7 +2428,7 @@ extract_tree(WIMStruct *wim, const tchar *wim_source_path, const tchar *target, } if (ctx.ops->requires_short_name_reordering) { - ret = for_dentry_in_tree(root, dentry_extract_dir_skeleton, + ret = for_dentry_in_tree(ctx.extract_root, dentry_extract_dir_skeleton, &ctx); if (ret) goto out_free_realtarget; @@ -2439,7 +2443,7 @@ extract_tree(WIMStruct *wim, const tchar *wim_source_path, const tchar *target, &ctx.progress); if (!(extract_flags & WIMLIB_EXTRACT_FLAG_RESUME)) { - ret = for_dentry_in_tree(root, dentry_extract_skeleton, &ctx); + ret = for_dentry_in_tree(ctx.extract_root, dentry_extract_skeleton, &ctx); if (ret) goto out_free_realtarget; } @@ -2459,7 +2463,7 @@ extract_tree(WIMStruct *wim, const tchar *wim_source_path, const tchar *target, if (progress_func) progress_func(WIMLIB_PROGRESS_MSG_EXTRACT_DIR_STRUCTURE_BEGIN, &ctx.progress); - ret = for_dentry_in_tree(root, dentry_extract, &ctx); + ret = for_dentry_in_tree(ctx.extract_root, dentry_extract, &ctx); if (ret) goto out_free_realtarget; if (progress_func) @@ -2491,7 +2495,7 @@ extract_tree(WIMStruct *wim, const tchar *wim_source_path, const tchar *target, if (progress_func) progress_func(WIMLIB_PROGRESS_MSG_APPLY_TIMESTAMPS, &ctx.progress); - ret = for_dentry_in_tree_depth(root, dentry_extract_final, &ctx); + ret = for_dentry_in_tree_depth(ctx.extract_root, dentry_extract_final, &ctx); if (ret) goto out_free_realtarget; @@ -2513,8 +2517,6 @@ out_teardown_stream_list: list_for_each_entry(lte, &ctx.stream_list, extraction_list) if (lte->out_refcnt > ARRAY_LEN(lte->inline_lte_dentries)) FREE(lte->lte_dentries); -out_dentry_reset_needs_extraction: - for_dentry_in_tree(root, dentry_reset_needs_extraction, NULL); out_finish_or_abort_extract: if (ret) { if (ctx.ops->abort_extract) @@ -2523,10 +2525,67 @@ out_finish_or_abort_extract: if (ctx.ops->finish_extract) ret = ctx.ops->finish_extract(&ctx); } -out: +out_dentry_reset_needs_extraction: + for_dentry_in_tree(ctx.extract_root, dentry_reset_needs_extraction, NULL); return ret; } +/* + * extract_tree - Extract a file or directory tree from the currently selected + * WIM image. + * + * @wim: WIMStruct for the WIM file, with the desired image selected + * (as wim->current_image). + * + * @wim_source_path: + * "Canonical" (i.e. no leading or trailing slashes, path + * separators WIM_PATH_SEPARATOR) path inside the WIM image to + * extract. An empty string means the full image. + * + * @target: + * Filesystem path to extract the file or directory tree to. + * (Or, with WIMLIB_EXTRACT_FLAG_NTFS: the name of a NTFS volume.) + * + * @extract_flags: + * WIMLIB_EXTRACT_FLAG_*. Also, the private flag + * WIMLIB_EXTRACT_FLAG_MULTI_IMAGE will be set if this is being + * called through wimlib_extract_image() with WIMLIB_ALL_IMAGES as + * the image. + * + * @progress_func: + * If non-NULL, progress function for the extraction. The messages + * that may be sent in this function are: + * + * WIMLIB_PROGRESS_MSG_EXTRACT_TREE_BEGIN or + * WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_BEGIN; + * WIMLIB_PROGRESS_MSG_EXTRACT_DIR_STRUCTURE_BEGIN; + * WIMLIB_PROGRESS_MSG_EXTRACT_DIR_STRUCTURE_END; + * WIMLIB_PROGRESS_MSG_EXTRACT_DENTRY; + * WIMLIB_PROGRESS_MSG_EXTRACT_STREAMS; + * WIMLIB_PROGRESS_MSG_APPLY_TIMESTAMPS; + * WIMLIB_PROGRESS_MSG_EXTRACT_TREE_END or + * WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_END. + * + * Returns 0 on success; a positive WIMLIB_ERR_* code on failure. + */ +static int +extract_tree(WIMStruct *wim, const tchar *wim_source_path, + const tchar *target, int extract_flags, + wimlib_progress_func_t progress_func) +{ + struct wim_dentry *root; + + root = get_dentry(wim, wim_source_path, WIMLIB_CASE_PLATFORM_DEFAULT); + + if (root == NULL) { + ERROR("Path \"%"TS"\" does not exist in WIM image %d", + wim_source_path, wim->current_image); + return WIMLIB_ERR_PATH_DOES_NOT_EXIST; + } + return extract_trees(wim, &root, 1, wim_source_path, + target, extract_flags, progress_func); +} + /* Validates a single wimlib_extract_command, mostly checking to make sure the * extract flags make sense. */ static int @@ -3063,6 +3122,34 @@ wimlib_extract_pathlist(WIMStruct *wim, int image, return ret; } +struct append_dentry_ctx { + struct wim_dentry **dentries; + size_t num_dentries; + size_t num_alloc_dentries; +}; + +static int +append_dentry_cb(struct wim_dentry *dentry, void *_ctx) +{ + struct append_dentry_ctx *ctx = _ctx; + + if (ctx->num_dentries == ctx->num_alloc_dentries) { + struct wim_dentry **new_dentries; + size_t new_length; + + new_length = max(ctx->num_alloc_dentries + 8, + ctx->num_alloc_dentries * 3 / 2); + new_dentries = REALLOC(ctx->dentries, + new_length * sizeof(ctx->dentries[0])); + if (new_dentries == NULL) + return WIMLIB_ERR_NOMEM; + ctx->dentries = new_dentries; + ctx->num_alloc_dentries = new_length; + } + ctx->dentries[ctx->num_dentries++] = dentry; + return 0; +} + /* API function documented in wimlib.h */ WIMLIBAPI int wimlib_extract_paths(WIMStruct *wim, @@ -3074,16 +3161,25 @@ wimlib_extract_paths(WIMStruct *wim, wimlib_progress_func_t progress_func) { int ret; - tchar **expanded_paths; - size_t num_expanded_paths; - struct wimlib_extract_command *cmds; + struct append_dentry_ctx append_dentry_ctx = { + .dentries = NULL, + .num_dentries = 0, + .num_alloc_dentries = 0, + }; + struct wim_dentry **trees; + size_t num_trees; + + extract_flags &= WIMLIB_EXTRACT_MASK_PUBLIC; + + if (target == NULL || (num_paths != 0 && paths == NULL)) + return WIMLIB_ERR_INVALID_PARAM; ret = select_wim_image(wim, image); if (ret) return ret; if (extract_flags & WIMLIB_EXTRACT_FLAG_GLOB_PATHS) { - int wildcard_flags = 0; + u32 wildcard_flags = 0; if (extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_GLOB) wildcard_flags |= WILDCARD_FLAG_ERROR_IF_NO_MATCH; @@ -3093,66 +3189,49 @@ wimlib_extract_paths(WIMStruct *wim, if (default_ignore_case) wildcard_flags |= WILDCARD_FLAG_CASE_INSENSITIVE; - ret = expand_wildcard_wim_paths(wim, paths, num_paths, - &expanded_paths, - &num_expanded_paths, - wildcard_flags); - if (ret) - return ret; + for (size_t i = 0; i < num_paths; i++) { + ret = expand_wildcard(wim, paths[i], + append_dentry_cb, + &append_dentry_ctx, + wildcard_flags); + if (ret) { + trees = append_dentry_ctx.dentries; + goto out_free_trees; + } + } + trees = append_dentry_ctx.dentries; + num_trees = append_dentry_ctx.num_dentries; } else { - expanded_paths = (tchar**)paths; - num_expanded_paths = num_paths; - } - - cmds = CALLOC(num_expanded_paths, sizeof(cmds[0])); - if (cmds == NULL) { - ret = WIMLIB_ERR_NOMEM; - goto out_free_expanded_paths; - } - - for (size_t i = 0; i < num_expanded_paths; i++) { - cmds[i].wim_source_path = expanded_paths[i]; - cmds[i].extract_flags = 0; - - tchar *dest_path; - size_t dest_len = 0; - dest_len += tstrlen(target); - dest_len += 1; - dest_len += tstrlen(expanded_paths[i]); - dest_len += 1; + trees = MALLOC(num_paths * sizeof(trees[0])); + if (trees == NULL) + return WIMLIB_ERR_NOMEM; - dest_path = MALLOC(dest_len * sizeof(tchar)); - if (dest_path == NULL) { - ret = WIMLIB_ERR_NOMEM; - goto out_free_extraction_cmds; - } - tchar *p = dest_path; - p = tmempcpy(p, target, tstrlen(target)); - *p++ = OS_PREFERRED_PATH_SEPARATOR; - for (tchar *path_p = expanded_paths[i]; *path_p != '\0'; path_p++) { - if (is_any_path_separator(*path_p)) - *p++ = OS_PREFERRED_PATH_SEPARATOR; - else - *p++ = *path_p; + for (size_t i = 0; i < num_paths; i++) { + trees[i] = get_dentry(wim, paths[i], + WIMLIB_CASE_PLATFORM_DEFAULT); + if (trees[i] == NULL) { + ERROR("Path \"%"TS"\" does not exist " + "in WIM image %d", + paths[i], wim->current_image); + ret = WIMLIB_ERR_PATH_DOES_NOT_EXIST; + goto out_free_trees; + } } - *p++ = T('\0'); - wimlib_assert(p - dest_path == dest_len); - cmds[i].fs_dest_path = dest_path; + num_trees = num_paths; } - ret = wimlib_extract_files(wim, image, - cmds, num_expanded_paths, - extract_flags & ~WIMLIB_EXTRACT_FLAG_GLOB_PATHS, - progress_func); -out_free_extraction_cmds: - for (size_t i = 0; i < num_expanded_paths; i++) - FREE(cmds[i].fs_dest_path); - FREE(cmds); -out_free_expanded_paths: - if (extract_flags & WIMLIB_EXTRACT_FLAG_GLOB_PATHS) { - for (size_t i = 0; i < num_expanded_paths; i++) - FREE(expanded_paths[i]); - FREE(expanded_paths); + if (num_trees == 0) { + ret = 0; + goto out_free_trees; } + + ret = extract_trees(wim, trees, num_trees, + T(""), target, + ((extract_flags & + ~WIMLIB_EXTRACT_FLAG_GLOB_PATHS) + | WIMLIB_EXTRACT_FLAG_PATHMODE), + progress_func); +out_free_trees: + FREE(trees); return ret; } diff --git a/src/wildcard.c b/src/wildcard.c index 06d64748..0965b26c 100644 --- a/src/wildcard.c +++ b/src/wildcard.c @@ -34,12 +34,9 @@ #include "wimlib/wildcard.h" struct match_dentry_ctx { - int (*consume_path)(const tchar *, void *, bool); - void *consume_path_ctx; - size_t consume_path_count; - tchar *expanded_path; - size_t expanded_path_len; - size_t expanded_path_alloc_len; + int (*consume_dentry)(struct wim_dentry *, void *); + void *consume_dentry_ctx; + size_t consume_dentry_count; tchar *wildcard_path; size_t cur_component_offset; size_t cur_component_len; @@ -60,32 +57,32 @@ match_wildcard_case_sensitive(const tchar *string, size_t string_len, return (wildcard_len == 0); } else if (wildcard_len == 0) { return false; - } else if (*string == *wildcard || *wildcard == '?') { + } else if (*string == *wildcard || *wildcard == T('?')) { string++; string_len--; wildcard_len--; wildcard++; continue; - } else if (*wildcard == '*') { + } else if (*wildcard == T('*')) { return match_wildcard_case_sensitive( string, string_len, wildcard + 1, wildcard_len - 1) || - match_wildcard_case_sensitive( - string + 1, string_len - 1, - wildcard, wildcard_len); + match_wildcard_case_sensitive( + string + 1, string_len - 1, + wildcard, wildcard_len); } else { return false; } } } -#endif +#endif /* __WIN32__ */ static bool match_wildcard(const tchar *string, tchar *wildcard, size_t wildcard_len, bool case_insensitive) { - /* Note: in Windows builds fnmatch() calls a replacement function. - * It does support case-sensitive globbing. */ + /* Note: in Windows builds fnmatch() calls a replacement function. It + * does not support case-sensitive globbing. */ #ifdef __WIN32__ if (case_insensitive) #endif @@ -166,29 +163,6 @@ match_dentry(struct wim_dentry *cur_dentry, void *_ctx) ctx->cur_component_len, ctx->case_insensitive)) { - size_t len_needed = ctx->expanded_path_len + 1 + name_len + 1; - size_t expanded_path_len_save; - - if (len_needed > ctx->expanded_path_alloc_len) { - tchar *expanded_path; - - expanded_path = REALLOC(ctx->expanded_path, - len_needed * sizeof(ctx->expanded_path[0])); - if (expanded_path == NULL) { - ret = WIMLIB_ERR_NOMEM; - goto out_free_name; - } - ctx->expanded_path = expanded_path; - ctx->expanded_path_alloc_len = len_needed; - } - expanded_path_len_save = ctx->expanded_path_len; - - ctx->expanded_path[ctx->expanded_path_len++] = WIM_PATH_SEPARATOR; - tmemcpy(&ctx->expanded_path[ctx->expanded_path_len], - name, name_len); - ctx->expanded_path_len += name_len; - ctx->expanded_path[ctx->expanded_path_len] = T('\0'); - switch (wildcard_status(&ctx->wildcard_path[ ctx->cur_component_offset + ctx->cur_component_len])) @@ -200,22 +174,18 @@ match_dentry(struct wim_dentry *cur_dentry, void *_ctx) } /* Fall through */ case WILDCARD_STATUS_DONE_FULLY: - ret = (*ctx->consume_path)(ctx->expanded_path, - ctx->consume_path_ctx, - false); - ctx->consume_path_count++; + ret = (*ctx->consume_dentry)(cur_dentry, + ctx->consume_dentry_ctx); + ctx->consume_dentry_count++; break; case WILDCARD_STATUS_NOT_DONE: ret = expand_wildcard_recursive(cur_dentry, ctx); break; } - ctx->expanded_path_len = expanded_path_len_save; - ctx->expanded_path[expanded_path_len_save] = T('\0'); } else { ret = 0; } -out_free_name: #if !TCHAR_IS_UTF16LE FREE(name); #endif @@ -264,11 +234,47 @@ expand_wildcard_recursive(struct wim_dentry *cur_dentry, return ret; } -static int +/* Expand a wildcard relative to the current WIM image. + * + * @wim + * WIMStruct whose currently selected image is searched to expand the + * wildcard. + * @wildcard_path + * Wildcard path to expand, which may contain the '?' and '*' characters. + * Path separators may be either forward slashes, and leading path + * separators are ignored. Trailing path separators indicate that the + * wildcard can only match directories. + * @consume_dentry + * Callback function which will receive each directory entry matched by the + * wildcard. + * @consume_dentry_ctx + * Argument to pass to @consume_dentry. + * @flags + * Zero or more of the following flags: + * + * WILDCARD_FLAG_WARN_IF_NO_MATCH: + * Issue a warning if the wildcard does not match any dentries. + * + * WILDCARD_FLAG_ERROR_IF_NO_MATCH: + * Issue an error and return WIMLIB_ERR_PATH_DOES_NOT_EXIST if the + * wildcard does not match any dentries. + * + * WILDCARD_FLAG_CASE_INSENSITIVE: + * Perform the matching case insensitively. Note that this may + * cause @wildcard to match multiple dentries, even if it does not + * contain wildcard characters. + * + * @return 0 on success; a positive error code on error; or the first nonzero + * value returned by @consume_dentry. + * + * Note: this function uses the @tmp_list field of dentries it attempts to + * match. + */ +int expand_wildcard(WIMStruct *wim, const tchar *wildcard_path, - int (*consume_path)(const tchar *, void *, bool), - void *consume_path_ctx, + int (*consume_dentry)(struct wim_dentry *, void *), + void *consume_dentry_ctx, u32 flags) { struct wim_dentry *root; @@ -279,36 +285,26 @@ expand_wildcard(WIMStruct *wim, goto no_match; struct match_dentry_ctx ctx = { - .consume_path = consume_path, - .consume_path_ctx = consume_path_ctx, - .consume_path_count = 0, - .expanded_path = MALLOC(256 * sizeof(ctx.expanded_path[0])), - .expanded_path_len = 0, - .expanded_path_alloc_len = 256, + .consume_dentry = consume_dentry, + .consume_dentry_ctx = consume_dentry_ctx, + .consume_dentry_count = 0, .wildcard_path = TSTRDUP(wildcard_path), .cur_component_offset = 0, .cur_component_len = 0, .case_insensitive = ((flags & WILDCARD_FLAG_CASE_INSENSITIVE) != 0), }; - if (ctx.expanded_path == NULL || ctx.wildcard_path == NULL) { - FREE(ctx.expanded_path); - FREE(ctx.wildcard_path); + if (ctx.wildcard_path == NULL) return WIMLIB_ERR_NOMEM; - } ret = expand_wildcard_recursive(root, &ctx); - FREE(ctx.expanded_path); FREE(ctx.wildcard_path); - if (ret == 0 && ctx.consume_path_count == 0) + if (ret == 0 && ctx.consume_dentry_count == 0) goto no_match; return ret; no_match: ret = 0; - if (flags & WILDCARD_FLAG_USE_LITERAL_IF_NO_MATCHES) - ret = (*consume_path)(wildcard_path, consume_path_ctx, true); - if (flags & WILDCARD_FLAG_WARN_IF_NO_MATCH) WARNING("No matches for wildcard path \"%"TS"\"", wildcard_path); @@ -318,70 +314,3 @@ no_match: } return ret; } - -struct expanded_paths_ctx { - tchar **expanded_paths; - size_t num_expanded_paths; - size_t alloc_length; -}; - -static int -append_path_cb(const tchar *path, void *_ctx, bool may_need_trans) -{ - struct expanded_paths_ctx *ctx = _ctx; - tchar *path_dup; - - if (ctx->num_expanded_paths == ctx->alloc_length) { - tchar **new_paths; - size_t new_alloc_length = max(ctx->alloc_length + 8, - ctx->alloc_length * 3 / 2); - - new_paths = REALLOC(ctx->expanded_paths, - new_alloc_length * sizeof(new_paths[0])); - if (new_paths == NULL) - return WIMLIB_ERR_NOMEM; - ctx->expanded_paths = new_paths; - ctx->alloc_length = new_alloc_length; - } - path_dup = TSTRDUP(path); - if (path_dup == NULL) - return WIMLIB_ERR_NOMEM; - if (may_need_trans) { - for (tchar *p = path_dup; *p; p++) - if (is_any_path_separator(*p)) - *p = WIM_PATH_SEPARATOR; - } - ctx->expanded_paths[ctx->num_expanded_paths++] = path_dup; - return 0; -} - -int -expand_wildcard_wim_paths(WIMStruct *wim, - const tchar * const *wildcards, - size_t num_wildcards, - tchar ***expanded_paths_ret, - size_t *num_expanded_paths_ret, - u32 flags) -{ - int ret; - struct expanded_paths_ctx ctx = { - .expanded_paths = NULL, - .num_expanded_paths = 0, - .alloc_length = 0, - }; - for (size_t i = 0; i < num_wildcards; i++) { - ret = expand_wildcard(wim, wildcards[i], append_path_cb, &ctx, - flags); - if (ret) - goto out_free; - } - *expanded_paths_ret = ctx.expanded_paths; - *num_expanded_paths_ret = ctx.num_expanded_paths; - return 0; - -out_free: - for (size_t i = 0; i < ctx.num_expanded_paths; i++) - FREE(ctx.expanded_paths[i]); - FREE(ctx.expanded_paths); - return ret; -}