Improved error reporting if loading capture configuration file fails
[wimlib] / src / capture_common.c
1 /*
2  * capture_common.c - Mostly code to handle excluding paths from capture.
3  */
4
5 /*
6  * Copyright (C) 2013, 2014 Eric Biggers
7  *
8  * This file is free software; you can redistribute it and/or modify it under
9  * the terms of the GNU Lesser General Public License as published by the Free
10  * Software Foundation; either version 3 of the License, or (at your option) any
11  * later version.
12  *
13  * This file is distributed in the hope that it will be useful, but WITHOUT
14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
15  * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
16  * details.
17  *
18  * You should have received a copy of the GNU Lesser General Public License
19  * along with this file; if not, see http://www.gnu.org/licenses/.
20  */
21
22 #ifdef HAVE_CONFIG_H
23 #  include "config.h"
24 #endif
25
26 #include <string.h>
27
28 #include "wimlib/blob_table.h"
29 #include "wimlib/capture.h"
30 #include "wimlib/dentry.h"
31 #include "wimlib/error.h"
32 #include "wimlib/paths.h"
33 #include "wimlib/progress.h"
34 #include "wimlib/textfile.h"
35 #include "wimlib/wildcard.h"
36
37 /*
38  * Tally a file (or directory) that has been scanned for a capture operation,
39  * and possibly call the progress function provided by the library user.
40  *
41  * @params
42  *      Flags, optional progress function, and progress data for the capture
43  *      operation.
44  * @status
45  *      Status of the scanned file.
46  * @inode
47  *      If @status is WIMLIB_SCAN_DENTRY_OK, this is a pointer to the WIM inode
48  *      that has been created for the scanned file.  The first time the file is
49  *      seen, inode->i_nlink will be 1.  On subsequent visits of the same inode
50  *      via additional hard links, inode->i_nlink will be greater than 1.
51  */
52 int
53 do_capture_progress(struct capture_params *params, int status,
54                     const struct wim_inode *inode)
55 {
56         switch (status) {
57         case WIMLIB_SCAN_DENTRY_OK:
58                 if (!(params->add_flags & WIMLIB_ADD_FLAG_VERBOSE))
59                         return 0;
60                 break;
61         case WIMLIB_SCAN_DENTRY_UNSUPPORTED:
62         case WIMLIB_SCAN_DENTRY_EXCLUDED:
63         case WIMLIB_SCAN_DENTRY_FIXED_SYMLINK:
64         case WIMLIB_SCAN_DENTRY_NOT_FIXED_SYMLINK:
65                 if (!(params->add_flags & WIMLIB_ADD_FLAG_EXCLUDE_VERBOSE))
66                         return 0;
67                 break;
68         }
69         params->progress.scan.status = status;
70         if (status == WIMLIB_SCAN_DENTRY_OK && inode->i_nlink == 1) {
71
72                 /* Successful scan, and visiting inode for the first time  */
73
74                 /* Tally size of all streams.  */
75                 for (unsigned i = 0; i < inode->i_num_streams; i++) {
76                         const struct blob_descriptor *blob =
77                                 stream_blob_resolved(&inode->i_streams[i]);
78                         if (blob)
79                                 params->progress.scan.num_bytes_scanned += blob->size;
80                 }
81
82                 /* Tally the file itself.  */
83                 if (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY)
84                         params->progress.scan.num_dirs_scanned++;
85                 else
86                         params->progress.scan.num_nondirs_scanned++;
87         }
88
89         /* Call the user-provided progress function.  */
90         return call_progress(params->progfunc, WIMLIB_PROGRESS_MSG_SCAN_DENTRY,
91                              &params->progress, params->progctx);
92 }
93
94 /*
95  * Given a null-terminated pathname pattern @pat that has been read from line
96  * @line_no of the file @path, validate and canonicalize the pattern.
97  *
98  * On success, returns 0.
99  * On failure, returns WIMLIB_ERR_INVALID_CAPTURE_CONFIG.
100  * In either case, @pat may have been modified in-place (and possibly
101  * shortened).
102  */
103 int
104 mangle_pat(tchar *pat, const tchar *path, unsigned long line_no)
105 {
106         if (!is_any_path_separator(pat[0]) &&
107             pat[0] != T('\0') && pat[1] == T(':'))
108         {
109                 /* Pattern begins with drive letter.  */
110
111                 if (!is_any_path_separator(pat[2])) {
112                         /* Something like c:file, which is actually a path
113                          * relative to the current working directory on the c:
114                          * drive.  We require paths with drive letters to be
115                          * absolute.  */
116                         ERROR("%"TS":%lu: Invalid pattern \"%"TS"\":\n"
117                               "        Patterns including drive letters must be absolute!\n"
118                               "        Maybe try \"%"TC":%"TC"%"TS"\"?\n",
119                               path, line_no, pat,
120                               pat[0], OS_PREFERRED_PATH_SEPARATOR, &pat[2]);
121                         return WIMLIB_ERR_INVALID_CAPTURE_CONFIG;
122                 }
123
124                 WARNING("%"TS":%lu: Pattern \"%"TS"\" starts with a drive "
125                         "letter, which is being removed.",
126                         path, line_no, pat);
127
128                 /* Strip the drive letter.  */
129                 tmemmove(pat, pat + 2, tstrlen(pat + 2) + 1);
130         }
131
132         /* Collapse consecutive path separators, and translate both / and \ into
133          * / (UNIX) or \ (Windows).
134          *
135          * Note: we expect that this function produces patterns that can be used
136          * for both filesystem paths and WIM paths, so the desired path
137          * separators must be the same.  */
138         BUILD_BUG_ON(OS_PREFERRED_PATH_SEPARATOR != WIM_PATH_SEPARATOR);
139         do_canonicalize_path(pat, pat);
140
141         /* Relative patterns can only match file names, so they must be
142          * single-component only.  */
143         if (pat[0] != OS_PREFERRED_PATH_SEPARATOR &&
144             tstrchr(pat, OS_PREFERRED_PATH_SEPARATOR))
145         {
146                 ERROR("%"TS":%lu: Invalid pattern \"%"TS"\":\n"
147                       "        Relative patterns can only include one path component!\n"
148                       "        Maybe try \"%"TC"%"TS"\"?",
149                       path, line_no, pat, OS_PREFERRED_PATH_SEPARATOR, pat);
150                 return WIMLIB_ERR_INVALID_CAPTURE_CONFIG;
151         }
152
153         return 0;
154 }
155
156 /*
157  * Read, parse, and validate a capture configuration file from either an on-disk
158  * file or an in-memory buffer.
159  *
160  * To read from a file, specify @config_file, and use NULL for @buf.
161  * To read from a buffer, specify @buf and @bufsize.
162  *
163  * @config must be initialized to all 0's.
164  *
165  * On success, 0 will be returned, and the resulting capture configuration will
166  * be stored in @config.
167  *
168  * On failure, a positive error code will be returned, and the contents of
169  * @config will be invalidated.
170  */
171 int
172 read_capture_config(const tchar *config_file, const void *buf,
173                     size_t bufsize, struct capture_config *config)
174 {
175         int ret;
176
177         /* [PrepopulateList] is used for apply, not capture.  But since we do
178          * understand it, recognize it, thereby avoiding the unrecognized
179          * section warning, but discard the resulting strings.
180          *
181          * We currently ignore [CompressionExclusionList] and
182          * [CompressionFolderList].  This is a known issue that doesn't seem to
183          * have any real consequences, so don't issue warnings about not
184          * recognizing those sections.  */
185         STRING_SET(prepopulate_pats);
186         STRING_SET(compression_exclusion_pats);
187         STRING_SET(compression_folder_pats);
188
189         struct text_file_section sections[] = {
190                 {T("ExclusionList"),
191                         &config->exclusion_pats},
192                 {T("ExclusionException"),
193                         &config->exclusion_exception_pats},
194                 {T("PrepopulateList"),
195                         &prepopulate_pats},
196                 {T("CompressionExclusionList"),
197                         &compression_exclusion_pats},
198                 {T("CompressionFolderList"),
199                         &compression_folder_pats},
200         };
201         void *mem;
202
203         ret = do_load_text_file(config_file, buf, bufsize, &mem,
204                                 sections, ARRAY_LEN(sections),
205                                 LOAD_TEXT_FILE_REMOVE_QUOTES, mangle_pat);
206         if (ret) {
207                 ERROR("Failed to load capture configuration file \"%"TS"\"",
208                       config_file);
209                 switch (ret) {
210                 case WIMLIB_ERR_INVALID_UTF8_STRING:
211                 case WIMLIB_ERR_INVALID_UTF16_STRING:
212                         ERROR("Note: the capture configuration file must be "
213                               "valid UTF-8 or UTF-16LE");
214                         ret = WIMLIB_ERR_INVALID_CAPTURE_CONFIG;
215                         break;
216                 case WIMLIB_ERR_OPEN:
217                 case WIMLIB_ERR_STAT:
218                 case WIMLIB_ERR_NOMEM:
219                 case WIMLIB_ERR_READ:
220                         ret = WIMLIB_ERR_UNABLE_TO_READ_CAPTURE_CONFIG;
221                         break;
222                 }
223                 return ret;
224         }
225
226         FREE(prepopulate_pats.strings);
227         FREE(compression_exclusion_pats.strings);
228         FREE(compression_folder_pats.strings);
229
230         config->buf = mem;
231         return 0;
232 }
233
234 void
235 destroy_capture_config(struct capture_config *config)
236 {
237         FREE(config->exclusion_pats.strings);
238         FREE(config->exclusion_exception_pats.strings);
239         FREE(config->buf);
240 }
241
242 /*
243  * Determine whether a path matches any wildcard pattern in a list.
244  *
245  * Special rules apply about what form @path must be in; see match_path().
246  */
247 bool
248 match_pattern_list(const tchar *path, size_t path_nchars,
249                    const struct string_set *list)
250 {
251         for (size_t i = 0; i < list->num_strings; i++)
252                 if (match_path(path, path_nchars, list->strings[i],
253                                OS_PREFERRED_PATH_SEPARATOR, true))
254                         return true;
255         return false;
256 }
257
258 /*
259  * Determine whether the filesystem @path should be excluded from capture, based
260  * on the current capture configuration file.
261  *
262  * The @path must be given relative to the root of the capture, but with a
263  * leading path separator.  For example, if the file "in/file" is being tested
264  * and the library user ran wimlib_add_image(wim, "in", ...), then the directory
265  * "in" is the root of the capture and the path should be specified as "/file".
266  *
267  * Also, all path separators in @path must be OS_PREFERRED_PATH_SEPARATOR, there
268  * cannot be trailing slashes, and there cannot be consecutive path separators.
269  *
270  * As a special case, the empty string will be interpreted as a single path
271  * separator (which means the root of capture itself).
272  */
273 static bool
274 should_exclude_path(const tchar *path, size_t path_nchars,
275                     const struct capture_config *config)
276 {
277         tchar dummy[2];
278
279         if (!config)
280                 return false;
281
282         if (!*path) {
283                 dummy[0] = OS_PREFERRED_PATH_SEPARATOR;
284                 dummy[1] = T('\0');
285                 path = dummy;
286                 path_nchars = 1;
287         }
288
289         return match_pattern_list(path, path_nchars, &config->exclusion_pats) &&
290               !match_pattern_list(path, path_nchars, &config->exclusion_exception_pats);
291
292 }
293
294 /*
295  * Determine if a file should be excluded from capture.
296  *
297  * This function tests exclusions from both of the two possible sources of
298  * exclusions:
299  *
300  *      (1) The capture configuration file
301  *      (2) The user-provided progress function
302  *
303  * The capture implementation must have set params->capture_root_nchars to an
304  * appropriate value.  Example for UNIX:  if the capture root directory is
305  * "foobar/subdir", then all paths will be provided starting with
306  * "foobar/subdir", so params->capture_root_nchars must be set to
307  * strlen("foobar/subdir") so that try_exclude() can use the appropriate suffix
308  * when it calls should_exclude_path().
309  *
310  *
311  * Returns:
312  *      < 0 if excluded
313  *      = 0 if not excluded and no error
314  *      > 0 (wimlib error code) if error
315  */
316 int
317 try_exclude(const tchar *full_path, size_t full_path_nchars,
318             const struct capture_params *params)
319 {
320         int ret;
321
322         if (should_exclude_path(full_path + params->capture_root_nchars,
323                                 full_path_nchars - params->capture_root_nchars,
324                                 params->config))
325                 return -1;
326
327         if (unlikely(params->add_flags & WIMLIB_ADD_FLAG_TEST_FILE_EXCLUSION)) {
328                 union wimlib_progress_info info;
329
330                 info.test_file_exclusion.path = full_path;
331                 info.test_file_exclusion.will_exclude = false;
332
333         #ifdef __WIN32__
334                 /* Hack for Windows...  */
335
336                 wchar_t *p_question_mark = NULL;
337
338                 if (!wcsncmp(full_path, L"\\??\\", 4)) {
339                         /* Trivial transformation:  NT namespace => Win32 namespace  */
340                         p_question_mark = (wchar_t *)&full_path[1];
341                         *p_question_mark = L'\\';
342                 }
343         #endif
344
345                 ret = call_progress(params->progfunc, WIMLIB_PROGRESS_MSG_TEST_FILE_EXCLUSION,
346                                     &info, params->progctx);
347
348         #ifdef __WIN32__
349                 if (p_question_mark)
350                         *p_question_mark = L'?';
351         #endif
352
353                 if (ret)
354                         return ret;
355                 if (info.test_file_exclusion.will_exclude)
356                         return -1;
357         }
358
359         return 0;
360 }