Add support for extract list files

[wimlib] / src / capture_common.c

diff --git a/src/capture_common.c b/src/capture_common.c
index a18b49ca9e226740080920401152d51fb676bdea..f5866b493ed77fe396680e8750e52d80f7b0bcbe 100644 (file)
--- a/src/capture_common.c
+++ b/src/capture_common.c
@@ -21,33 +21,37 @@
  * along with wimlib; if not, see http://www.gnu.org/licenses/.
  */
 
-#include "wimlib_internal.h"
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
 
-#include <string.h>
+#include "wimlib/assert.h"
+#include "wimlib/capture.h"
+#include "wimlib/dentry.h"
+#include "wimlib/error.h"
+#include "wimlib/lookup_table.h"
+#include "wimlib/paths.h"
+#include "wimlib/wildcard.h"
 
-#ifdef __WIN32__
-#  include "win32.h"
-#else
-#  include <fnmatch.h>
-#endif
+#include <string.h>
 
 static int
 canonicalize_pattern(const tchar *pat, tchar **canonical_pat_ret)
 {
        tchar *canonical_pat;
 
-       if (pat[0] != T('/') && pat[0] != T('\\') &&
+       if (!is_any_path_separator(pat[0]) &&
            pat[0] != T('\0') && pat[1] == T(':'))
        {
                /* Pattern begins with drive letter */
-               if (pat[2] != T('/') && pat[2] != T('\\')) {
+               if (!is_any_path_separator(pat[2])) {
                        /* Something like c:file, which is actually a path
                         * relative to the current working directory on the c:
                         * drive.  We require paths with drive letters to be
                         * absolute. */
                        ERROR("Invalid path \"%"TS"\"; paths including drive letters "
                              "must be absolute!", pat);
-                       ERROR("Maybe try \"%"TC":/%"TS"\"?",
+                       ERROR("Maybe try \"%"TC":\\%"TS"\"?",
                              pat[0], pat + 2);
                        return WIMLIB_ERR_INVALID_CAPTURE_CONFIG;
                }
@@ -60,6 +64,12 @@ canonicalize_pattern(const tchar *pat, tchar **canonical_pat_ret)
        canonical_pat = canonicalize_fs_path(pat);
        if (!canonical_pat)
                return WIMLIB_ERR_NOMEM;
+
+       /* Translate all possible path separators into the operating system's
+        * preferred path separator. */
+       for (tchar *p = canonical_pat; *p; p++)
+               if (is_any_path_separator(*p))
+                       *p = OS_PREFERRED_PATH_SEPARATOR;
        *canonical_pat_ret = canonical_pat;
        return 0;
 }
@@ -138,11 +148,11 @@ match_pattern(const tchar *path,
                const tchar *pat = list->pats[i];
                const tchar *string;
 
-               if (*pat == T('/')) {
+               if (*pat == OS_PREFERRED_PATH_SEPARATOR) {
                        /* Absolute path from root of capture */
                        string = path;
                } else {
-                       if (tstrchr(pat, T('/')))
+                       if (tstrchr(pat, OS_PREFERRED_PATH_SEPARATOR))
                                /* Relative path from root of capture */
                                string = path + 1;
                        else
@@ -154,7 +164,7 @@ match_pattern(const tchar *path,
                 * replacement function in win32.c. */
                if (fnmatch(pat, string, FNM_PATHNAME | FNM_NOESCAPE
                                #ifdef FNM_CASEFOLD
-                                       | FNM_CASEFOLD
+                                       | FNM_CASEFOLD
                                #endif
                            ) == 0)
                {
@@ -162,13 +172,45 @@ match_pattern(const tchar *path,
                              string, pat);
                        return true;
                } else {
-                       DEBUG2("\"%"TS"\" does not match the pattern \"%"TS"\"",
-                              string, pat);
+                       DEBUG("\"%"TS"\" does not match the pattern \"%"TS"\"",
+                             string, pat);
                }
        }
        return false;
 }
 
+void
+do_capture_progress(struct add_image_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;
+       case WIMLIB_SCAN_DENTRY_UNSUPPORTED:
+       case WIMLIB_SCAN_DENTRY_EXCLUDED:
+               if (!(params->add_flags & WIMLIB_ADD_FLAG_EXCLUDE_VERBOSE))
+                       return;
+       }
+       params->progress.scan.status = status;
+       if (status == WIMLIB_SCAN_DENTRY_OK && inode->i_nlink == 1) {
+               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 != NULL)
+                               params->progress.scan.num_bytes_scanned += lte->size;
+               }
+               if (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY)
+                       params->progress.scan.num_dirs_scanned++;
+               else
+                       params->progress.scan.num_nondirs_scanned++;
+       }
+       if (params->progress_func) {
+               params->progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY,
+                                     &params->progress);
+       }
+}
+
 /* Return true if the image capture configuration file indicates we should
  * exclude the filename @path from capture.
  *
@@ -188,7 +230,7 @@ exclude_path(const tchar *path, size_t path_len,
        if (exclude_prefix) {
                wimlib_assert(path_len >= config->_prefix_num_tchars);
                if (!tmemcmp(config->_prefix, path, config->_prefix_num_tchars) &&
-                   path[config->_prefix_num_tchars] == T('/'))
+                   path[config->_prefix_num_tchars] == OS_PREFERRED_PATH_SEPARATOR)
                {
                        path += config->_prefix_num_tchars;
                }