Branch data Line data Source code
1 : : /* SPDX-License-Identifier: LGPL-2.1+ */
2 : :
3 : : #include <errno.h>
4 : : #include <getopt.h>
5 : : #include <string.h>
6 : : #include <sys/prctl.h>
7 : : #include <unistd.h>
8 : :
9 : : #include "alloc-util.h"
10 : : #include "dirent-util.h"
11 : : #include "fd-util.h"
12 : : #include "fs-util.h"
13 : : #include "hashmap.h"
14 : : #include "locale-util.h"
15 : : #include "log.h"
16 : : #include "main-func.h"
17 : : #include "nulstr-util.h"
18 : : #include "pager.h"
19 : : #include "parse-util.h"
20 : : #include "path-util.h"
21 : : #include "pretty-print.h"
22 : : #include "process-util.h"
23 : : #include "signal-util.h"
24 : : #include "stat-util.h"
25 : : #include "string-util.h"
26 : : #include "strv.h"
27 : : #include "terminal-util.h"
28 : :
29 : : static const char prefixes[] =
30 : : "/etc\0"
31 : : "/run\0"
32 : : "/usr/local/lib\0"
33 : : "/usr/local/share\0"
34 : : "/usr/lib\0"
35 : : "/usr/share\0"
36 : : #if HAVE_SPLIT_USR
37 : : "/lib\0"
38 : : #endif
39 : : ;
40 : :
41 : : static const char suffixes[] =
42 : : "sysctl.d\0"
43 : : "tmpfiles.d\0"
44 : : "modules-load.d\0"
45 : : "binfmt.d\0"
46 : : "systemd/system\0"
47 : : "systemd/user\0"
48 : : "systemd/system-preset\0"
49 : : "systemd/user-preset\0"
50 : : "udev/rules.d\0"
51 : : "modprobe.d\0";
52 : :
53 : : static const char have_dropins[] =
54 : : "systemd/system\0"
55 : : "systemd/user\0";
56 : :
57 : : static PagerFlags arg_pager_flags = 0;
58 : : static int arg_diff = -1;
59 : :
60 : : static enum {
61 : : SHOW_MASKED = 1 << 0,
62 : : SHOW_EQUIVALENT = 1 << 1,
63 : : SHOW_REDIRECTED = 1 << 2,
64 : : SHOW_OVERRIDDEN = 1 << 3,
65 : : SHOW_UNCHANGED = 1 << 4,
66 : : SHOW_EXTENDED = 1 << 5,
67 : :
68 : : SHOW_DEFAULTS =
69 : : (SHOW_MASKED | SHOW_EQUIVALENT | SHOW_REDIRECTED | SHOW_OVERRIDDEN | SHOW_EXTENDED)
70 : : } arg_flags = 0;
71 : :
72 : 0 : static int equivalent(const char *a, const char *b) {
73 : 0 : _cleanup_free_ char *x = NULL, *y = NULL;
74 : : int r;
75 : :
76 : 0 : r = chase_symlinks(a, NULL, CHASE_TRAIL_SLASH, &x);
77 [ # # ]: 0 : if (r < 0)
78 : 0 : return r;
79 : :
80 : 0 : r = chase_symlinks(b, NULL, CHASE_TRAIL_SLASH, &y);
81 [ # # ]: 0 : if (r < 0)
82 : 0 : return r;
83 : :
84 : 0 : return path_equal(x, y);
85 : : }
86 : :
87 : 0 : static int notify_override_masked(const char *top, const char *bottom) {
88 [ # # ]: 0 : if (!(arg_flags & SHOW_MASKED))
89 : 0 : return 0;
90 : :
91 : 0 : printf("%s%s%s %s %s %s\n",
92 : : ansi_highlight_red(), "[MASKED]", ansi_normal(),
93 : : top, special_glyph(SPECIAL_GLYPH_ARROW), bottom);
94 : 0 : return 1;
95 : : }
96 : :
97 : 0 : static int notify_override_equivalent(const char *top, const char *bottom) {
98 [ # # ]: 0 : if (!(arg_flags & SHOW_EQUIVALENT))
99 : 0 : return 0;
100 : :
101 : 0 : printf("%s%s%s %s %s %s\n",
102 : : ansi_highlight_green(), "[EQUIVALENT]", ansi_normal(),
103 : : top, special_glyph(SPECIAL_GLYPH_ARROW), bottom);
104 : 0 : return 1;
105 : : }
106 : :
107 : 0 : static int notify_override_redirected(const char *top, const char *bottom) {
108 [ # # ]: 0 : if (!(arg_flags & SHOW_REDIRECTED))
109 : 0 : return 0;
110 : :
111 : 0 : printf("%s%s%s %s %s %s\n",
112 : : ansi_highlight(), "[REDIRECTED]", ansi_normal(),
113 : : top, special_glyph(SPECIAL_GLYPH_ARROW), bottom);
114 : 0 : return 1;
115 : : }
116 : :
117 : 0 : static int notify_override_overridden(const char *top, const char *bottom) {
118 [ # # ]: 0 : if (!(arg_flags & SHOW_OVERRIDDEN))
119 : 0 : return 0;
120 : :
121 : 0 : printf("%s%s%s %s %s %s\n",
122 : : ansi_highlight(), "[OVERRIDDEN]", ansi_normal(),
123 : : top, special_glyph(SPECIAL_GLYPH_ARROW), bottom);
124 : 0 : return 1;
125 : : }
126 : :
127 : 0 : static int notify_override_extended(const char *top, const char *bottom) {
128 [ # # ]: 0 : if (!(arg_flags & SHOW_EXTENDED))
129 : 0 : return 0;
130 : :
131 : 0 : printf("%s%s%s %s %s %s\n",
132 : : ansi_highlight(), "[EXTENDED]", ansi_normal(),
133 : : top, special_glyph(SPECIAL_GLYPH_ARROW), bottom);
134 : 0 : return 1;
135 : : }
136 : :
137 : 0 : static int notify_override_unchanged(const char *f) {
138 [ # # ]: 0 : if (!(arg_flags & SHOW_UNCHANGED))
139 : 0 : return 0;
140 : :
141 : 0 : printf("[UNCHANGED] %s\n", f);
142 : 0 : return 1;
143 : : }
144 : :
145 : 0 : static int found_override(const char *top, const char *bottom) {
146 : 0 : _cleanup_free_ char *dest = NULL;
147 : : pid_t pid;
148 : : int r;
149 : :
150 [ # # ]: 0 : assert(top);
151 [ # # ]: 0 : assert(bottom);
152 : :
153 [ # # ]: 0 : if (null_or_empty_path(top) > 0)
154 : 0 : return notify_override_masked(top, bottom);
155 : :
156 : 0 : r = readlink_malloc(top, &dest);
157 [ # # ]: 0 : if (r >= 0) {
158 [ # # ]: 0 : if (equivalent(dest, bottom) > 0)
159 : 0 : return notify_override_equivalent(top, bottom);
160 : : else
161 : 0 : return notify_override_redirected(top, bottom);
162 : : }
163 : :
164 : 0 : r = notify_override_overridden(top, bottom);
165 [ # # ]: 0 : if (!arg_diff)
166 : 0 : return r;
167 : :
168 : 0 : putchar('\n');
169 : :
170 : 0 : fflush(stdout);
171 : :
172 : 0 : r = safe_fork("(diff)", FORK_RESET_SIGNALS|FORK_DEATHSIG|FORK_CLOSE_ALL_FDS|FORK_RLIMIT_NOFILE_SAFE|FORK_LOG, &pid);
173 [ # # ]: 0 : if (r < 0)
174 : 0 : return r;
175 [ # # ]: 0 : if (r == 0) {
176 : 0 : execlp("diff", "diff", "-us", "--", bottom, top, NULL);
177 : 0 : log_open();
178 [ # # ]: 0 : log_error_errno(errno, "Failed to execute diff: %m");
179 : 0 : _exit(EXIT_FAILURE);
180 : : }
181 : :
182 : 0 : (void) wait_for_terminate_and_check("diff", pid, WAIT_LOG_ABNORMAL);
183 : 0 : putchar('\n');
184 : :
185 : 0 : return r;
186 : : }
187 : :
188 : 0 : static int enumerate_dir_d(
189 : : OrderedHashmap *top,
190 : : OrderedHashmap *bottom,
191 : : OrderedHashmap *drops,
192 : : const char *toppath, const char *drop) {
193 : :
194 : 0 : _cleanup_free_ char *unit = NULL;
195 : 0 : _cleanup_free_ char *path = NULL;
196 : 0 : _cleanup_strv_free_ char **list = NULL;
197 : : char **file;
198 : : char *c;
199 : : int r;
200 : :
201 [ # # ]: 0 : assert(!endswith(drop, "/"));
202 : :
203 : 0 : path = path_join(toppath, drop);
204 [ # # ]: 0 : if (!path)
205 : 0 : return -ENOMEM;
206 : :
207 [ # # ]: 0 : log_debug("Looking at %s", path);
208 : :
209 : 0 : unit = strdup(drop);
210 [ # # ]: 0 : if (!unit)
211 : 0 : return -ENOMEM;
212 : :
213 : 0 : c = strrchr(unit, '.');
214 [ # # ]: 0 : if (!c)
215 : 0 : return -EINVAL;
216 : 0 : *c = 0;
217 : :
218 : 0 : r = get_files_in_directory(path, &list);
219 [ # # ]: 0 : if (r < 0)
220 [ # # ]: 0 : return log_error_errno(r, "Failed to enumerate %s: %m", path);
221 : :
222 : 0 : strv_sort(list);
223 : :
224 [ # # # # ]: 0 : STRV_FOREACH(file, list) {
225 : : OrderedHashmap *h;
226 : : int k;
227 : : char *p;
228 : : char *d;
229 : :
230 [ # # ]: 0 : if (!endswith(*file, ".conf"))
231 : 0 : continue;
232 : :
233 : 0 : p = path_join(path, *file);
234 [ # # ]: 0 : if (!p)
235 : 0 : return -ENOMEM;
236 : 0 : d = p + strlen(toppath) + 1;
237 : :
238 [ # # ]: 0 : log_debug("Adding at top: %s %s %s", d, special_glyph(SPECIAL_GLYPH_ARROW), p);
239 : 0 : k = ordered_hashmap_put(top, d, p);
240 [ # # ]: 0 : if (k >= 0) {
241 : 0 : p = strdup(p);
242 [ # # ]: 0 : if (!p)
243 : 0 : return -ENOMEM;
244 : 0 : d = p + strlen(toppath) + 1;
245 [ # # ]: 0 : } else if (k != -EEXIST) {
246 : 0 : free(p);
247 : 0 : return k;
248 : : }
249 : :
250 [ # # ]: 0 : log_debug("Adding at bottom: %s %s %s", d, special_glyph(SPECIAL_GLYPH_ARROW), p);
251 : 0 : free(ordered_hashmap_remove(bottom, d));
252 : 0 : k = ordered_hashmap_put(bottom, d, p);
253 [ # # ]: 0 : if (k < 0) {
254 : 0 : free(p);
255 : 0 : return k;
256 : : }
257 : :
258 : 0 : h = ordered_hashmap_get(drops, unit);
259 [ # # ]: 0 : if (!h) {
260 : 0 : h = ordered_hashmap_new(&string_hash_ops);
261 [ # # ]: 0 : if (!h)
262 : 0 : return -ENOMEM;
263 : 0 : ordered_hashmap_put(drops, unit, h);
264 : 0 : unit = strdup(unit);
265 [ # # ]: 0 : if (!unit)
266 : 0 : return -ENOMEM;
267 : : }
268 : :
269 : 0 : p = strdup(p);
270 [ # # ]: 0 : if (!p)
271 : 0 : return -ENOMEM;
272 : :
273 [ # # ]: 0 : log_debug("Adding to drops: %s %s %s %s %s",
274 : : unit, special_glyph(SPECIAL_GLYPH_ARROW), basename(p), special_glyph(SPECIAL_GLYPH_ARROW), p);
275 : 0 : k = ordered_hashmap_put(h, basename(p), p);
276 [ # # ]: 0 : if (k < 0) {
277 : 0 : free(p);
278 [ # # ]: 0 : if (k != -EEXIST)
279 : 0 : return k;
280 : : }
281 : : }
282 : 0 : return 0;
283 : : }
284 : :
285 : 0 : static int enumerate_dir(
286 : : OrderedHashmap *top,
287 : : OrderedHashmap *bottom,
288 : : OrderedHashmap *drops,
289 : : const char *path, bool dropins) {
290 : :
291 : 0 : _cleanup_closedir_ DIR *d = NULL;
292 : : struct dirent *de;
293 : 0 : _cleanup_strv_free_ char **files = NULL, **dirs = NULL;
294 : 0 : size_t n_files = 0, allocated_files = 0, n_dirs = 0, allocated_dirs = 0;
295 : : char **t;
296 : : int r;
297 : :
298 [ # # ]: 0 : assert(top);
299 [ # # ]: 0 : assert(bottom);
300 [ # # ]: 0 : assert(drops);
301 [ # # ]: 0 : assert(path);
302 : :
303 [ # # ]: 0 : log_debug("Looking at %s", path);
304 : :
305 : 0 : d = opendir(path);
306 [ # # ]: 0 : if (!d) {
307 [ # # ]: 0 : if (errno == ENOENT)
308 : 0 : return 0;
309 : :
310 [ # # ]: 0 : return log_error_errno(errno, "Failed to open %s: %m", path);
311 : : }
312 : :
313 [ # # # # ]: 0 : FOREACH_DIRENT_ALL(de, d, return -errno) {
314 : 0 : dirent_ensure_type(d, de);
315 : :
316 [ # # # # : 0 : if (dropins && de->d_type == DT_DIR && endswith(de->d_name, ".d")) {
# # ]
317 [ # # ]: 0 : if (!GREEDY_REALLOC0(dirs, allocated_dirs, n_dirs + 2))
318 : 0 : return -ENOMEM;
319 : :
320 : 0 : dirs[n_dirs] = strdup(de->d_name);
321 [ # # ]: 0 : if (!dirs[n_dirs])
322 : 0 : return -ENOMEM;
323 : 0 : n_dirs ++;
324 : : }
325 : :
326 [ # # ]: 0 : if (!dirent_is_file(de))
327 : 0 : continue;
328 : :
329 [ # # ]: 0 : if (!GREEDY_REALLOC0(files, allocated_files, n_files + 2))
330 : 0 : return -ENOMEM;
331 : :
332 : 0 : files[n_files] = strdup(de->d_name);
333 [ # # ]: 0 : if (!files[n_files])
334 : 0 : return -ENOMEM;
335 : 0 : n_files ++;
336 : : }
337 : :
338 : 0 : strv_sort(dirs);
339 : 0 : strv_sort(files);
340 : :
341 [ # # # # ]: 0 : STRV_FOREACH(t, dirs) {
342 : 0 : r = enumerate_dir_d(top, bottom, drops, path, *t);
343 [ # # ]: 0 : if (r < 0)
344 : 0 : return r;
345 : : }
346 : :
347 [ # # # # ]: 0 : STRV_FOREACH(t, files) {
348 [ # # ]: 0 : _cleanup_free_ char *p = NULL;
349 : :
350 : 0 : p = path_join(path, *t);
351 [ # # ]: 0 : if (!p)
352 : 0 : return -ENOMEM;
353 : :
354 [ # # ]: 0 : log_debug("Adding at top: %s %s %s", basename(p), special_glyph(SPECIAL_GLYPH_ARROW), p);
355 : 0 : r = ordered_hashmap_put(top, basename(p), p);
356 [ # # ]: 0 : if (r >= 0) {
357 : 0 : p = strdup(p);
358 [ # # ]: 0 : if (!p)
359 : 0 : return -ENOMEM;
360 [ # # ]: 0 : } else if (r != -EEXIST)
361 : 0 : return r;
362 : :
363 [ # # ]: 0 : log_debug("Adding at bottom: %s %s %s", basename(p), special_glyph(SPECIAL_GLYPH_ARROW), p);
364 : 0 : free(ordered_hashmap_remove(bottom, basename(p)));
365 : 0 : r = ordered_hashmap_put(bottom, basename(p), p);
366 [ # # ]: 0 : if (r < 0)
367 : 0 : return r;
368 : 0 : p = NULL;
369 : : }
370 : :
371 : 0 : return 0;
372 : : }
373 : :
374 : 0 : static int should_skip_path(const char *prefix, const char *suffix) {
375 : : #if HAVE_SPLIT_USR
376 : : _cleanup_free_ char *target = NULL;
377 : : const char *dirname, *p;
378 : :
379 : : dirname = prefix_roota(prefix, suffix);
380 : :
381 : : if (chase_symlinks(dirname, NULL, 0, &target) < 0)
382 : : return false;
383 : :
384 : : NULSTR_FOREACH(p, prefixes) {
385 : : _cleanup_free_ char *tmp = NULL;
386 : :
387 : : if (path_startswith(dirname, p))
388 : : continue;
389 : :
390 : : tmp = path_join(p, suffix);
391 : : if (!tmp)
392 : : return -ENOMEM;
393 : :
394 : : if (path_equal(target, tmp)) {
395 : : log_debug("%s redirects to %s, skipping.", dirname, target);
396 : : return true;
397 : : }
398 : : }
399 : : #endif
400 : 0 : return false;
401 : : }
402 : :
403 : 0 : static int process_suffix(const char *suffix, const char *onlyprefix) {
404 : : const char *p;
405 : : char *f;
406 : : OrderedHashmap *top, *bottom, *drops;
407 : : OrderedHashmap *h;
408 : : char *key;
409 : 0 : int r = 0, k;
410 : : Iterator i, j;
411 : 0 : int n_found = 0;
412 : : bool dropins;
413 : :
414 [ # # ]: 0 : assert(suffix);
415 [ # # ]: 0 : assert(!startswith(suffix, "/"));
416 [ # # ]: 0 : assert(!strstr(suffix, "//"));
417 : :
418 : 0 : dropins = nulstr_contains(have_dropins, suffix);
419 : :
420 : 0 : top = ordered_hashmap_new(&string_hash_ops);
421 : 0 : bottom = ordered_hashmap_new(&string_hash_ops);
422 : 0 : drops = ordered_hashmap_new(&string_hash_ops);
423 [ # # # # : 0 : if (!top || !bottom || !drops) {
# # ]
424 : 0 : r = -ENOMEM;
425 : 0 : goto finish;
426 : : }
427 : :
428 [ # # # # ]: 0 : NULSTR_FOREACH(p, prefixes) {
429 [ # # # ]: 0 : _cleanup_free_ char *t = NULL;
430 : :
431 [ # # ]: 0 : if (should_skip_path(p, suffix) > 0)
432 : 0 : continue;
433 : :
434 : 0 : t = path_join(p, suffix);
435 [ # # ]: 0 : if (!t) {
436 : 0 : r = -ENOMEM;
437 : 0 : goto finish;
438 : : }
439 : :
440 : 0 : k = enumerate_dir(top, bottom, drops, t, dropins);
441 [ # # ]: 0 : if (r == 0)
442 : 0 : r = k;
443 : : }
444 : :
445 [ # # ]: 0 : ORDERED_HASHMAP_FOREACH_KEY(f, key, top, i) {
446 : : char *o;
447 : :
448 : 0 : o = ordered_hashmap_get(bottom, key);
449 [ # # ]: 0 : assert(o);
450 : :
451 [ # # # # ]: 0 : if (!onlyprefix || startswith(o, onlyprefix)) {
452 [ # # ]: 0 : if (path_equal(o, f)) {
453 : 0 : notify_override_unchanged(f);
454 : : } else {
455 : 0 : k = found_override(f, o);
456 [ # # ]: 0 : if (k < 0)
457 : 0 : r = k;
458 : : else
459 : 0 : n_found += k;
460 : : }
461 : : }
462 : :
463 : 0 : h = ordered_hashmap_get(drops, key);
464 [ # # ]: 0 : if (h)
465 [ # # ]: 0 : ORDERED_HASHMAP_FOREACH(o, h, j)
466 [ # # # # ]: 0 : if (!onlyprefix || startswith(o, onlyprefix))
467 : 0 : n_found += notify_override_extended(f, o);
468 : : }
469 : :
470 : 0 : finish:
471 : 0 : ordered_hashmap_free_free(top);
472 : 0 : ordered_hashmap_free_free(bottom);
473 : :
474 [ # # ]: 0 : ORDERED_HASHMAP_FOREACH_KEY(h, key, drops, i) {
475 : 0 : ordered_hashmap_free_free(ordered_hashmap_remove(drops, key));
476 : 0 : ordered_hashmap_remove(drops, key);
477 : 0 : free(key);
478 : : }
479 : 0 : ordered_hashmap_free(drops);
480 : :
481 [ # # ]: 0 : return r < 0 ? r : n_found;
482 : : }
483 : :
484 : 0 : static int process_suffixes(const char *onlyprefix) {
485 : : const char *n;
486 : 0 : int n_found = 0, r;
487 : :
488 [ # # # # ]: 0 : NULSTR_FOREACH(n, suffixes) {
489 : 0 : r = process_suffix(n, onlyprefix);
490 [ # # ]: 0 : if (r < 0)
491 : 0 : return r;
492 : :
493 : 0 : n_found += r;
494 : : }
495 : :
496 : 0 : return n_found;
497 : : }
498 : :
499 : 0 : static int process_suffix_chop(const char *arg) {
500 : : const char *p;
501 : :
502 [ # # ]: 0 : assert(arg);
503 : :
504 [ # # ]: 0 : if (!path_is_absolute(arg))
505 : 0 : return process_suffix(arg, NULL);
506 : :
507 : : /* Strip prefix from the suffix */
508 [ # # # # ]: 0 : NULSTR_FOREACH(p, prefixes) {
509 : : const char *suffix;
510 : :
511 : 0 : suffix = startswith(arg, p);
512 [ # # ]: 0 : if (suffix) {
513 : 0 : suffix += strspn(suffix, "/");
514 [ # # ]: 0 : if (*suffix)
515 : 0 : return process_suffix(suffix, p);
516 : : else
517 : 0 : return process_suffixes(arg);
518 : : }
519 : : }
520 : :
521 [ # # ]: 0 : return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
522 : : "Invalid suffix specification %s.", arg);
523 : : }
524 : :
525 : 12 : static int help(void) {
526 : 12 : _cleanup_free_ char *link = NULL;
527 : : int r;
528 : :
529 : 12 : r = terminal_urlify_man("systemd-delta", "1", &link);
530 [ - + ]: 12 : if (r < 0)
531 : 0 : return log_oom();
532 : :
533 : 12 : printf("%s [OPTIONS...] [SUFFIX...]\n\n"
534 : : "Find overridden configuration files.\n\n"
535 : : " -h --help Show this help\n"
536 : : " --version Show package version\n"
537 : : " --no-pager Do not pipe output into a pager\n"
538 : : " --diff[=1|0] Show a diff when overridden files differ\n"
539 : : " -t --type=LIST... Only display a selected set of override types\n"
540 : : "\nSee the %s for details.\n"
541 : : , program_invocation_short_name
542 : : , link
543 : : );
544 : :
545 : 12 : return 0;
546 : : }
547 : :
548 : 0 : static int parse_flags(const char *flag_str, int flags) {
549 : : const char *word, *state;
550 : : size_t l;
551 : :
552 [ # # ]: 0 : FOREACH_WORD_SEPARATOR(word, l, flag_str, ",", state) {
553 [ # # ]: 0 : if (strneq("masked", word, l))
554 : 0 : flags |= SHOW_MASKED;
555 [ # # ]: 0 : else if (strneq ("equivalent", word, l))
556 : 0 : flags |= SHOW_EQUIVALENT;
557 [ # # ]: 0 : else if (strneq("redirected", word, l))
558 : 0 : flags |= SHOW_REDIRECTED;
559 [ # # ]: 0 : else if (strneq("overridden", word, l))
560 : 0 : flags |= SHOW_OVERRIDDEN;
561 [ # # ]: 0 : else if (strneq("unchanged", word, l))
562 : 0 : flags |= SHOW_UNCHANGED;
563 [ # # ]: 0 : else if (strneq("extended", word, l))
564 : 0 : flags |= SHOW_EXTENDED;
565 [ # # ]: 0 : else if (strneq("default", word, l))
566 : 0 : flags |= SHOW_DEFAULTS;
567 : : else
568 : 0 : return -EINVAL;
569 : : }
570 : 0 : return flags;
571 : : }
572 : :
573 : 16 : static int parse_argv(int argc, char *argv[]) {
574 : :
575 : : enum {
576 : : ARG_NO_PAGER = 0x100,
577 : : ARG_DIFF,
578 : : ARG_VERSION
579 : : };
580 : :
581 : : static const struct option options[] = {
582 : : { "help", no_argument, NULL, 'h' },
583 : : { "version", no_argument, NULL, ARG_VERSION },
584 : : { "no-pager", no_argument, NULL, ARG_NO_PAGER },
585 : : { "diff", optional_argument, NULL, ARG_DIFF },
586 : : { "type", required_argument, NULL, 't' },
587 : : {}
588 : : };
589 : :
590 : : int c;
591 : :
592 [ - + ]: 16 : assert(argc >= 1);
593 [ - + ]: 16 : assert(argv);
594 : :
595 [ + - ]: 16 : while ((c = getopt_long(argc, argv, "ht:", options, NULL)) >= 0)
596 : :
597 [ + - - - : 16 : switch (c) {
- + - ]
598 : :
599 : 12 : case 'h':
600 : 12 : return help();
601 : :
602 : 0 : case ARG_VERSION:
603 : 0 : return version();
604 : :
605 : 0 : case ARG_NO_PAGER:
606 : 0 : arg_pager_flags |= PAGER_DISABLE;
607 : 0 : break;
608 : :
609 : 0 : case 't': {
610 : : int f;
611 : 0 : f = parse_flags(optarg, arg_flags);
612 [ # # ]: 0 : if (f < 0)
613 [ # # ]: 0 : return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
614 : : "Failed to parse flags field.");
615 : 0 : arg_flags = f;
616 : 0 : break;
617 : : }
618 : :
619 : 0 : case ARG_DIFF:
620 [ # # ]: 0 : if (!optarg)
621 : 0 : arg_diff = 1;
622 : : else {
623 : : int b;
624 : :
625 : 0 : b = parse_boolean(optarg);
626 [ # # ]: 0 : if (b < 0)
627 [ # # ]: 0 : return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
628 : : "Failed to parse diff boolean.");
629 : :
630 : 0 : arg_diff = b;
631 : : }
632 : 0 : break;
633 : :
634 : 4 : case '?':
635 : 4 : return -EINVAL;
636 : :
637 : 0 : default:
638 : 0 : assert_not_reached("Unhandled option");
639 : : }
640 : :
641 : 0 : return 1;
642 : : }
643 : :
644 : 16 : static int run(int argc, char *argv[]) {
645 : 16 : int r, k, n_found = 0;
646 : :
647 : 16 : log_show_color(true);
648 : 16 : log_parse_environment();
649 : 16 : log_open();
650 : :
651 : 16 : r = parse_argv(argc, argv);
652 [ + - ]: 16 : if (r <= 0)
653 : 16 : return r;
654 : :
655 [ # # ]: 0 : if (arg_flags == 0)
656 : 0 : arg_flags = SHOW_DEFAULTS;
657 : :
658 [ # # ]: 0 : if (arg_diff < 0)
659 : 0 : arg_diff = !!(arg_flags & SHOW_OVERRIDDEN);
660 [ # # ]: 0 : else if (arg_diff)
661 : 0 : arg_flags |= SHOW_OVERRIDDEN;
662 : :
663 : 0 : (void) pager_open(arg_pager_flags);
664 : :
665 [ # # ]: 0 : if (optind < argc) {
666 : : int i;
667 : :
668 [ # # ]: 0 : for (i = optind; i < argc; i++) {
669 : 0 : path_simplify(argv[i], false);
670 : :
671 : 0 : k = process_suffix_chop(argv[i]);
672 [ # # ]: 0 : if (k < 0)
673 : 0 : r = k;
674 : : else
675 : 0 : n_found += k;
676 : : }
677 : :
678 : : } else {
679 : 0 : k = process_suffixes(NULL);
680 [ # # ]: 0 : if (k < 0)
681 : 0 : r = k;
682 : : else
683 : 0 : n_found += k;
684 : : }
685 : :
686 [ # # ]: 0 : if (r >= 0)
687 [ # # ]: 0 : printf("%s%i overridden configuration files found.\n", n_found ? "\n" : "", n_found);
688 : 0 : return r;
689 : : }
690 : :
691 : 16 : DEFINE_MAIN_FUNCTION(run);
|
