X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fcapture_common.c;h=e544b7c126794f0e5013b684d9c3d83f455058de;hp=4db070f8ec3aeac1282d98e3565dd8d45533f665;hb=5fce6aa92826ec69fdeeea13e28292fa1fbb43a8;hpb=88bfb44de205f72acaefac0d509e1e4e604496f1 diff --git a/src/capture_common.c b/src/capture_common.c index 4db070f8..e544b7c1 100644 --- a/src/capture_common.c +++ b/src/capture_common.c @@ -5,36 +5,35 @@ /* * Copyright (C) 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 + +#include "wimlib/blob_table.h" #include "wimlib/capture.h" #include "wimlib/dentry.h" #include "wimlib/error.h" -#include "wimlib/lookup_table.h" #include "wimlib/paths.h" +#include "wimlib/progress.h" #include "wimlib/textfile.h" #include "wimlib/wildcard.h" -#include - /* * Tally a file (or directory) that has been scanned for a capture operation, * and possibly call the progress function provided by the library user. @@ -43,39 +42,41 @@ * Flags, optional progress function, and progress data for the capture * operation. * @status - * Status of the scanned file (ok, unsupported, excluded, or excluded - * symlink). + * Status of the scanned file. * @inode * If @status is WIMLIB_SCAN_DENTRY_OK, this is a pointer to the WIM inode * that has been created for the scanned file. The first time the file is * seen, inode->i_nlink will be 1. On subsequent visits of the same inode * via additional hard links, inode->i_nlink will be greater than 1. */ -void -do_capture_progress(struct add_image_params *params, int status, +int +do_capture_progress(struct capture_params *params, int status, const struct wim_inode *inode) { switch (status) { case WIMLIB_SCAN_DENTRY_OK: if (!(params->add_flags & WIMLIB_ADD_FLAG_VERBOSE)) - return; + return 0; + break; case WIMLIB_SCAN_DENTRY_UNSUPPORTED: case WIMLIB_SCAN_DENTRY_EXCLUDED: - case WIMLIB_SCAN_DENTRY_EXCLUDED_SYMLINK: + case WIMLIB_SCAN_DENTRY_FIXED_SYMLINK: + case WIMLIB_SCAN_DENTRY_NOT_FIXED_SYMLINK: if (!(params->add_flags & WIMLIB_ADD_FLAG_EXCLUDE_VERBOSE)) - return; + return 0; + break; } params->progress.scan.status = status; if (status == WIMLIB_SCAN_DENTRY_OK && inode->i_nlink == 1) { /* Successful scan, and visiting inode for the first time */ - /* Tally size of all data streams. */ - const struct wim_lookup_table_entry *lte; - for (unsigned i = 0; i <= inode->i_num_ads; i++) { - lte = inode_stream_lte_resolved(inode, i); - if (lte) - params->progress.scan.num_bytes_scanned += lte->size; + /* Tally size of all streams. */ + for (unsigned i = 0; i < inode->i_num_streams; i++) { + const struct blob_descriptor *blob = + stream_blob_resolved(&inode->i_streams[i]); + if (blob) + params->progress.scan.num_bytes_scanned += blob->size; } /* Tally the file itself. */ @@ -84,11 +85,10 @@ do_capture_progress(struct add_image_params *params, int status, else params->progress.scan.num_nondirs_scanned++; } + /* Call the user-provided progress function. */ - if (params->progress_func) { - params->progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, - ¶ms->progress); - } + return call_progress(params->progfunc, WIMLIB_PROGRESS_MSG_SCAN_DENTRY, + ¶ms->progress, params->progctx); } /* @@ -176,8 +176,15 @@ read_capture_config(const tchar *config_file, const void *buf, /* [PrepopulateList] is used for apply, not capture. But since we do * understand it, recognize it, thereby avoiding the unrecognized - * section warning, but discard the resulting strings. */ + * section warning, but discard the resulting strings. + * + * We currently ignore [CompressionExclusionList] and + * [CompressionFolderList]. This is a known issue that doesn't seem to + * have any real consequences, so don't issue warnings about not + * recognizing those sections. */ STRING_SET(prepopulate_pats); + STRING_SET(compression_exclusion_pats); + STRING_SET(compression_folder_pats); struct text_file_section sections[] = { {T("ExclusionList"), @@ -186,16 +193,39 @@ read_capture_config(const tchar *config_file, const void *buf, &config->exclusion_exception_pats}, {T("PrepopulateList"), &prepopulate_pats}, + {T("CompressionExclusionList"), + &compression_exclusion_pats}, + {T("CompressionFolderList"), + &compression_folder_pats}, }; void *mem; ret = do_load_text_file(config_file, buf, bufsize, &mem, sections, ARRAY_LEN(sections), LOAD_TEXT_FILE_REMOVE_QUOTES, mangle_pat); - if (ret) + if (ret) { + ERROR("Failed to load capture configuration file \"%"TS"\"", + config_file); + switch (ret) { + case WIMLIB_ERR_INVALID_UTF8_STRING: + case WIMLIB_ERR_INVALID_UTF16_STRING: + ERROR("Note: the capture configuration file must be " + "valid UTF-8 or UTF-16LE"); + ret = WIMLIB_ERR_INVALID_CAPTURE_CONFIG; + break; + case WIMLIB_ERR_OPEN: + case WIMLIB_ERR_STAT: + case WIMLIB_ERR_NOMEM: + case WIMLIB_ERR_READ: + ret = WIMLIB_ERR_UNABLE_TO_READ_CAPTURE_CONFIG; + break; + } return ret; + } FREE(prepopulate_pats.strings); + FREE(compression_exclusion_pats.strings); + FREE(compression_folder_pats.strings); config->buf = mem; return 0; @@ -240,7 +270,7 @@ match_pattern_list(const tchar *path, size_t path_nchars, * As a special case, the empty string will be interpreted as a single path * separator (which means the root of capture itself). */ -bool +static bool should_exclude_path(const tchar *path, size_t path_nchars, const struct capture_config *config) { @@ -260,3 +290,71 @@ should_exclude_path(const tchar *path, size_t path_nchars, !match_pattern_list(path, path_nchars, &config->exclusion_exception_pats); } + +/* + * Determine if a file should be excluded from capture. + * + * This function tests exclusions from both of the two possible sources of + * exclusions: + * + * (1) The capture configuration file + * (2) The user-provided progress function + * + * The capture implementation must have set params->capture_root_nchars to an + * appropriate value. Example for UNIX: if the capture root directory is + * "foobar/subdir", then all paths will be provided starting with + * "foobar/subdir", so params->capture_root_nchars must be set to + * strlen("foobar/subdir") so that try_exclude() can use the appropriate suffix + * when it calls should_exclude_path(). + * + * + * Returns: + * < 0 if excluded + * = 0 if not excluded and no error + * > 0 (wimlib error code) if error + */ +int +try_exclude(const tchar *full_path, size_t full_path_nchars, + const struct capture_params *params) +{ + int ret; + + if (should_exclude_path(full_path + params->capture_root_nchars, + full_path_nchars - params->capture_root_nchars, + params->config)) + return -1; + + if (unlikely(params->add_flags & WIMLIB_ADD_FLAG_TEST_FILE_EXCLUSION)) { + union wimlib_progress_info info; + + info.test_file_exclusion.path = full_path; + info.test_file_exclusion.will_exclude = false; + + #ifdef __WIN32__ + /* Hack for Windows... */ + + wchar_t *p_question_mark = NULL; + + if (!wcsncmp(full_path, L"\\??\\", 4)) { + /* Trivial transformation: NT namespace => Win32 namespace */ + p_question_mark = (wchar_t *)&full_path[1]; + *p_question_mark = L'\\'; + } + #endif + + ret = call_progress(params->progfunc, WIMLIB_PROGRESS_MSG_TEST_FILE_EXCLUSION, + &info, params->progctx); + + #ifdef __WIN32__ + if (p_question_mark) + *p_question_mark = L'?'; + #endif + + if (ret) + return ret; + if (info.test_file_exclusion.will_exclude) + return -1; + } + + return 0; +}