src/delta/delta.c - systemd-stable - Rivoreo Source Code Repositories

 /***
   This file is part of systemd.

   Copyright 2012 Lennart Poettering
   Copyright 2013 Zbigniew Jędrzejewski-Szmek

   systemd 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 2.1 of the License, or
   (at your option) any later version.

   systemd 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 Lesser General Public License
   along with systemd; If not, see <http://www.gnu.org/licenses/>.
 ***/

 #include <errno.h>
 #include <getopt.h>
 #include <string.h>
 #include <sys/prctl.h>
 #include <unistd.h>

 #include "alloc-util.h"
 #include "dirent-util.h"
 #include "fd-util.h"
 #include "fs-util.h"
 #include "hashmap.h"
 #include "locale-util.h"
 #include "log.h"
 #include "pager.h"
 #include "parse-util.h"
 #include "path-util.h"
 #include "process-util.h"
 #include "signal-util.h"
 #include "stat-util.h"
 #include "string-util.h"
 #include "strv.h"
 #include "terminal-util.h"
 #include "util.h"

 static const char prefixes[] =
         "/etc\0"
         "/run\0"
         "/usr/local/lib\0"
         "/usr/local/share\0"
         "/usr/lib\0"
         "/usr/share\0"
 #ifdef HAVE_SPLIT_USR
         "/lib\0"
 #endif
         ;

 static const char suffixes[] =
         "sysctl.d\0"
         "tmpfiles.d\0"
         "modules-load.d\0"
         "binfmt.d\0"
         "systemd/system\0"
         "systemd/user\0"
         "systemd/system-preset\0"
         "systemd/user-preset\0"
         "udev/rules.d\0"
         "modprobe.d\0";

 static const char have_dropins[] =
         "systemd/system\0"
         "systemd/user\0";

 static bool arg_no_pager = false;
 static int arg_diff = -1;

 static enum {
         SHOW_MASKED = 1 << 0,
         SHOW_EQUIVALENT = 1 << 1,
         SHOW_REDIRECTED = 1 << 2,
         SHOW_OVERRIDDEN = 1 << 3,
         SHOW_UNCHANGED = 1 << 4,
         SHOW_EXTENDED = 1 << 5,

         SHOW_DEFAULTS =
         (SHOW_MASKED | SHOW_EQUIVALENT | SHOW_REDIRECTED | SHOW_OVERRIDDEN | SHOW_EXTENDED)
 } arg_flags = 0;

 static int equivalent(const char *a, const char *b) {
         _cleanup_free_ char *x = NULL, *y = NULL;
         int r;

         r = chase_symlinks(a, NULL, 0, &x);
         if (r < 0)
                 return r;

         r = chase_symlinks(b, NULL, 0, &y);
         if (r < 0)
                 return r;

         return path_equal(x, y);
 }

 static int notify_override_masked(const char *top, const char *bottom) {
         if (!(arg_flags & SHOW_MASKED))
                 return 0;

         printf("%s%s%s     %s %s %s\n",
                ansi_highlight_red(), "[MASKED]", ansi_normal(),
                top, special_glyph(ARROW), bottom);
         return 1;
 }

 static int notify_override_equivalent(const char *top, const char *bottom) {
         if (!(arg_flags & SHOW_EQUIVALENT))
                 return 0;

         printf("%s%s%s %s %s %s\n",
                ansi_highlight_green(), "[EQUIVALENT]", ansi_normal(),
                top, special_glyph(ARROW), bottom);
         return 1;
 }

 static int notify_override_redirected(const char *top, const char *bottom) {
         if (!(arg_flags & SHOW_REDIRECTED))
                 return 0;

         printf("%s%s%s %s %s %s\n",
                ansi_highlight(), "[REDIRECTED]", ansi_normal(),
                top, special_glyph(ARROW), bottom);
         return 1;
 }

 static int notify_override_overridden(const char *top, const char *bottom) {
         if (!(arg_flags & SHOW_OVERRIDDEN))
                 return 0;

         printf("%s%s%s %s %s %s\n",
                ansi_highlight(), "[OVERRIDDEN]", ansi_normal(),
                top, special_glyph(ARROW), bottom);
         return 1;
 }

 static int notify_override_extended(const char *top, const char *bottom) {
         if (!(arg_flags & SHOW_EXTENDED))
                return 0;

         printf("%s%s%s   %s %s %s\n",
                ansi_highlight(), "[EXTENDED]", ansi_normal(),
                top, special_glyph(ARROW), bottom);
         return 1;
 }

 static int notify_override_unchanged(const char *f) {
         if (!(arg_flags & SHOW_UNCHANGED))
                 return 0;

         printf("[UNCHANGED]  %s\n", f);
         return 1;
 }

 static int found_override(const char *top, const char *bottom) {
         _cleanup_free_ char *dest = NULL;
         int k;
         pid_t pid;

         assert(top);
         assert(bottom);

         if (null_or_empty_path(top) > 0)
                 return notify_override_masked(top, bottom);

         k = readlink_malloc(top, &dest);
         if (k >= 0) {
                 if (equivalent(dest, bottom) > 0)
                         return notify_override_equivalent(top, bottom);
                 else
                         return notify_override_redirected(top, bottom);
         }

         k = notify_override_overridden(top, bottom);
         if (!arg_diff)
                 return k;

         putchar('\n');

         fflush(stdout);

         pid = fork();
         if (pid < 0)
                 return log_error_errno(errno, "Failed to fork off diff: %m");
         else if (pid == 0) {

                 (void) reset_all_signal_handlers();
                 (void) reset_signal_mask();
                 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);

                 execlp("diff", "diff", "-us", "--", bottom, top, NULL);
                 log_error_errno(errno, "Failed to execute diff: %m");
                 _exit(EXIT_FAILURE);
         }

         wait_for_terminate_and_warn("diff", pid, false);
         putchar('\n');

         return k;
 }

 static int enumerate_dir_d(
                 OrderedHashmap *top,
                 OrderedHashmap *bottom,
                 OrderedHashmap *drops,
                 const char *toppath, const char *drop) {

         _cleanup_free_ char *unit = NULL;
         _cleanup_free_ char *path = NULL;
         _cleanup_strv_free_ char **list = NULL;
         char **file;
         char *c;
         int r;

         assert(!endswith(drop, "/"));

         path = strjoin(toppath, "/", drop);
         if (!path)
                 return -ENOMEM;

         log_debug("Looking at %s", path);

         unit = strdup(drop);
         if (!unit)
                 return -ENOMEM;

         c = strrchr(unit, '.');
         if (!c)
                 return -EINVAL;
         *c = 0;

         r = get_files_in_directory(path, &list);
         if (r < 0)
                 return log_error_errno(r, "Failed to enumerate %s: %m", path);

         strv_sort(list);

         STRV_FOREACH(file, list) {
                 OrderedHashmap *h;
                 int k;
                 char *p;
                 char *d;

                 if (!endswith(*file, ".conf"))
                         continue;

                 p = strjoin(path, "/", *file);
                 if (!p)
                         return -ENOMEM;
                 d = p + strlen(toppath) + 1;

                 log_debug("Adding at top: %s %s %s", d, special_glyph(ARROW), p);
                 k = ordered_hashmap_put(top, d, p);
                 if (k >= 0) {
                         p = strdup(p);
                         if (!p)
                                 return -ENOMEM;
                         d = p + strlen(toppath) + 1;
                 } else if (k != -EEXIST) {
                         free(p);
                         return k;
                 }

                 log_debug("Adding at bottom: %s %s %s", d, special_glyph(ARROW), p);
                 free(ordered_hashmap_remove(bottom, d));
                 k = ordered_hashmap_put(bottom, d, p);
                 if (k < 0) {
                         free(p);
                         return k;
                 }

                 h = ordered_hashmap_get(drops, unit);
                 if (!h) {
                         h = ordered_hashmap_new(&string_hash_ops);
                         if (!h)
                                 return -ENOMEM;
                         ordered_hashmap_put(drops, unit, h);
                         unit = strdup(unit);
                         if (!unit)
                                 return -ENOMEM;
                 }

                 p = strdup(p);
                 if (!p)
                         return -ENOMEM;

                 log_debug("Adding to drops: %s %s %s %s %s",
                           unit, special_glyph(ARROW), basename(p), special_glyph(ARROW), p);
                 k = ordered_hashmap_put(h, basename(p), p);
                 if (k < 0) {
                         free(p);
                         if (k != -EEXIST)
                                 return k;
                 }
         }
         return 0;
 }

 static int enumerate_dir(
                 OrderedHashmap *top,
                 OrderedHashmap *bottom,
                 OrderedHashmap *drops,
                 const char *path, bool dropins) {

         _cleanup_closedir_ DIR *d = NULL;
         struct dirent *de;
         _cleanup_strv_free_ char **files = NULL, **dirs = NULL;
         size_t n_files = 0, allocated_files = 0, n_dirs = 0, allocated_dirs = 0;
         char **t;
         int r;

         assert(top);
         assert(bottom);
         assert(drops);
         assert(path);

         log_debug("Looking at %s", path);

         d = opendir(path);
         if (!d) {
                 if (errno == ENOENT)
                         return 0;

                 return log_error_errno(errno, "Failed to open %s: %m", path);
         }

         FOREACH_DIRENT_ALL(de, d, return -errno) {
                 dirent_ensure_type(d, de);

                 if (dropins && de->d_type == DT_DIR && endswith(de->d_name, ".d")) {
                         if (!GREEDY_REALLOC0(dirs, allocated_dirs, n_dirs + 2))
                                 return -ENOMEM;

                         dirs[n_dirs] = strdup(de->d_name);
                         if (!dirs[n_dirs])
                                 return -ENOMEM;
                         n_dirs ++;
                 }

                 if (!dirent_is_file(de))
                         continue;

                 if (!GREEDY_REALLOC0(files, allocated_files, n_files + 2))
                         return -ENOMEM;

                 files[n_files] = strdup(de->d_name);
                 if (!files[n_files])
                         return -ENOMEM;
                 n_files ++;
         }

         strv_sort(dirs);
         strv_sort(files);

         STRV_FOREACH(t, dirs) {
                 r = enumerate_dir_d(top, bottom, drops, path, *t);
                 if (r < 0)
                         return r;
         }

         STRV_FOREACH(t, files) {
                 _cleanup_free_ char *p = NULL;

                 p = strjoin(path, "/", *t);
                 if (!p)
                         return -ENOMEM;

                 log_debug("Adding at top: %s %s %s", basename(p), special_glyph(ARROW), p);
                 r = ordered_hashmap_put(top, basename(p), p);
                 if (r >= 0) {
                         p = strdup(p);
                         if (!p)
                                 return -ENOMEM;
                 } else if (r != -EEXIST)
                         return r;

                 log_debug("Adding at bottom: %s %s %s", basename(p), special_glyph(ARROW), p);
                 free(ordered_hashmap_remove(bottom, basename(p)));
                 r = ordered_hashmap_put(bottom, basename(p), p);
                 if (r < 0)
                         return r;
                 p = NULL;
         }

         return 0;
 }

 static int should_skip_prefix(const char* p) {
 #ifdef HAVE_SPLIT_USR
         int r;
         _cleanup_free_ char *target = NULL;

         r = chase_symlinks(p, NULL, 0, &target);
         if (r < 0)
                 return r;

         return !streq(p, target) && nulstr_contains(prefixes, target);
 #else
         return 0;
 #endif
 }

 static int process_suffix(const char *suffix, const char *onlyprefix) {
         const char *p;
         char *f;
         OrderedHashmap *top, *bottom, *drops;
         OrderedHashmap *h;
         char *key;
         int r = 0, k;
         Iterator i, j;
         int n_found = 0;
         bool dropins;

         assert(suffix);
         assert(!startswith(suffix, "/"));
         assert(!strstr(suffix, "//"));

         dropins = nulstr_contains(have_dropins, suffix);

         top = ordered_hashmap_new(&string_hash_ops);
         bottom = ordered_hashmap_new(&string_hash_ops);
         drops = ordered_hashmap_new(&string_hash_ops);
         if (!top || !bottom || !drops) {
                 r = -ENOMEM;
                 goto finish;
         }

         NULSTR_FOREACH(p, prefixes) {
                 _cleanup_free_ char *t = NULL;
                 int skip;

                 skip = should_skip_prefix(p);
                 if (skip < 0) {
                         r = skip;
                         goto finish;
                 }
                 if (skip)
                         continue;

                 t = strjoin(p, "/", suffix);
                 if (!t) {
                         r = -ENOMEM;
                         goto finish;
                 }

                 k = enumerate_dir(top, bottom, drops, t, dropins);
                 if (r == 0)
                         r = k;
         }

         ORDERED_HASHMAP_FOREACH_KEY(f, key, top, i) {
                 char *o;

                 o = ordered_hashmap_get(bottom, key);
                 assert(o);

                 if (!onlyprefix || startswith(o, onlyprefix)) {
                         if (path_equal(o, f)) {
                                 notify_override_unchanged(f);
                         } else {
                                 k = found_override(f, o);
                                 if (k < 0)
                                         r = k;
                                 else
                                         n_found += k;
                         }
                 }

                 h = ordered_hashmap_get(drops, key);
                 if (h)
                         ORDERED_HASHMAP_FOREACH(o, h, j)
                                 if (!onlyprefix || startswith(o, onlyprefix))
                                         n_found += notify_override_extended(f, o);
         }

 finish:
         ordered_hashmap_free_free(top);
         ordered_hashmap_free_free(bottom);

         ORDERED_HASHMAP_FOREACH_KEY(h, key, drops, i) {
                 ordered_hashmap_free_free(ordered_hashmap_remove(drops, key));
                 ordered_hashmap_remove(drops, key);
                 free(key);
         }
         ordered_hashmap_free(drops);

         return r < 0 ? r : n_found;
 }

 static int process_suffixes(const char *onlyprefix) {
         const char *n;
         int n_found = 0, r;

         NULSTR_FOREACH(n, suffixes) {
                 r = process_suffix(n, onlyprefix);
                 if (r < 0)
                         return r;

                 n_found += r;
         }

         return n_found;
 }

 static int process_suffix_chop(const char *arg) {
         const char *p;

         assert(arg);

         if (!path_is_absolute(arg))
                 return process_suffix(arg, NULL);

         /* Strip prefix from the suffix */
         NULSTR_FOREACH(p, prefixes) {
                 const char *suffix;
                 int skip;

                 skip = should_skip_prefix(p);
                 if (skip < 0)
                         return skip;
                 if (skip)
                         continue;

                 suffix = startswith(arg, p);
                 if (suffix) {
                         suffix += strspn(suffix, "/");
                         if (*suffix)
                                 return process_suffix(suffix, NULL);
                         else
                                 return process_suffixes(arg);
                 }
         }

         log_error("Invalid suffix specification %s.", arg);
         return -EINVAL;
 }

 static void help(void) {
         printf("%s [OPTIONS...] [SUFFIX...]\n\n"
                "Find overridden configuration files.\n\n"
                "  -h --help           Show this help\n"
                "     --version        Show package version\n"
                "     --no-pager       Do not pipe output into a pager\n"
                "     --diff[=1|0]     Show a diff when overridden files differ\n"
                "  -t --type=LIST...   Only display a selected set of override types\n"
                , program_invocation_short_name);
 }

 static int parse_flags(const char *flag_str, int flags) {
         const char *word, *state;
         size_t l;

         FOREACH_WORD_SEPARATOR(word, l, flag_str, ",", state) {
                 if (strneq("masked", word, l))
                         flags |= SHOW_MASKED;
                 else if (strneq ("equivalent", word, l))
                         flags |= SHOW_EQUIVALENT;
                 else if (strneq("redirected", word, l))
                         flags |= SHOW_REDIRECTED;
                 else if (strneq("overridden", word, l))
                         flags |= SHOW_OVERRIDDEN;
                 else if (strneq("unchanged", word, l))
                         flags |= SHOW_UNCHANGED;
                 else if (strneq("extended", word, l))
                         flags |= SHOW_EXTENDED;
                 else if (strneq("default", word, l))
                         flags |= SHOW_DEFAULTS;
                 else
                         return -EINVAL;
         }
         return flags;
 }

 static int parse_argv(int argc, char *argv[]) {

         enum {
                 ARG_NO_PAGER = 0x100,
                 ARG_DIFF,
                 ARG_VERSION
         };

         static const struct option options[] = {
                 { "help",      no_argument,       NULL, 'h'          },
                 { "version",   no_argument,       NULL, ARG_VERSION  },
                 { "no-pager",  no_argument,       NULL, ARG_NO_PAGER },
                 { "diff",      optional_argument, NULL, ARG_DIFF     },
                 { "type",      required_argument, NULL, 't'          },
                 {}
         };

         int c;

         assert(argc >= 1);
         assert(argv);

         while ((c = getopt_long(argc, argv, "ht:", options, NULL)) >= 0)

                 switch (c) {

                 case 'h':
                         help();
                         return 0;

                 case ARG_VERSION:
                         return version();

                 case ARG_NO_PAGER:
                         arg_no_pager = true;
                         break;

                 case 't': {
                         int f;
                         f = parse_flags(optarg, arg_flags);
                         if (f < 0) {
                                 log_error("Failed to parse flags field.");
                                 return -EINVAL;
                         }
                         arg_flags = f;
                         break;
                 }

                 case ARG_DIFF:
                         if (!optarg)
                                 arg_diff = 1;
                         else {
                                 int b;

                                 b = parse_boolean(optarg);
                                 if (b < 0) {
                                         log_error("Failed to parse diff boolean.");
                                         return -EINVAL;
                                 }

                                 arg_diff = b;
                         }
                         break;

                 case '?':
                         return -EINVAL;

                 default:
                         assert_not_reached("Unhandled option");
                 }

         return 1;
 }

 int main(int argc, char *argv[]) {
         int r, k, n_found = 0;

         log_parse_environment();
         log_open();

         r = parse_argv(argc, argv);
         if (r <= 0)
                 goto finish;

         if (arg_flags == 0)
                 arg_flags = SHOW_DEFAULTS;

         if (arg_diff < 0)
                 arg_diff = !!(arg_flags & SHOW_OVERRIDDEN);
         else if (arg_diff)
                 arg_flags |= SHOW_OVERRIDDEN;

         pager_open(arg_no_pager, false);

         if (optind < argc) {
                 int i;

                 for (i = optind; i < argc; i++) {
                         path_kill_slashes(argv[i]);

                         k = process_suffix_chop(argv[i]);
                         if (k < 0)
                                 r = k;
                         else
                                 n_found += k;
                 }

         } else {
                 k = process_suffixes(NULL);
                 if (k < 0)
                         r = k;
                 else
                         n_found += k;
         }

         if (r >= 0)
                 printf("%s%i overridden configuration files found.\n", n_found ? "\n" : "", n_found);

 finish:
         pager_close();

         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 }
	/***
	This file is part of systemd.

	Copyright 2012 Lennart Poettering
	Copyright 2013 Zbigniew Jędrzejewski-Szmek

	systemd 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 2.1 of the License, or
	(at your option) any later version.

	systemd 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 Lesser General Public License
	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	***/

	#include <errno.h>
	#include <getopt.h>
	#include <string.h>
	#include <sys/prctl.h>
	#include <unistd.h>

	#include "alloc-util.h"
	#include "dirent-util.h"
	#include "fd-util.h"
	#include "fs-util.h"
	#include "hashmap.h"
	#include "locale-util.h"
	#include "log.h"
	#include "pager.h"
	#include "parse-util.h"
	#include "path-util.h"
	#include "process-util.h"
	#include "signal-util.h"
	#include "stat-util.h"
	#include "string-util.h"
	#include "strv.h"
	#include "terminal-util.h"
	#include "util.h"

	static const char prefixes[] =
	"/etc\0"
	"/run\0"
	"/usr/local/lib\0"
	"/usr/local/share\0"
	"/usr/lib\0"
	"/usr/share\0"
	#ifdef HAVE_SPLIT_USR
	"/lib\0"
	#endif
	;

	static const char suffixes[] =
	"sysctl.d\0"
	"tmpfiles.d\0"
	"modules-load.d\0"
	"binfmt.d\0"
	"systemd/system\0"
	"systemd/user\0"
	"systemd/system-preset\0"
	"systemd/user-preset\0"
	"udev/rules.d\0"
	"modprobe.d\0";

	static const char have_dropins[] =
	"systemd/system\0"
	"systemd/user\0";

	static bool arg_no_pager = false;
	static int arg_diff = -1;

	static enum {
	SHOW_MASKED = 1 << 0,
	SHOW_EQUIVALENT = 1 << 1,
	SHOW_REDIRECTED = 1 << 2,
	SHOW_OVERRIDDEN = 1 << 3,
	SHOW_UNCHANGED = 1 << 4,
	SHOW_EXTENDED = 1 << 5,

	SHOW_DEFAULTS =
	(SHOW_MASKED \| SHOW_EQUIVALENT \| SHOW_REDIRECTED \| SHOW_OVERRIDDEN \| SHOW_EXTENDED)
	} arg_flags = 0;

	static int equivalent(const char a, const char b) {
	_cleanup_free_ char x = NULL, y = NULL;
	int r;

	r = chase_symlinks(a, NULL, 0, &x);
	if (r < 0)
	return r;

	r = chase_symlinks(b, NULL, 0, &y);
	if (r < 0)
	return r;

	return path_equal(x, y);
	}

	static int notify_override_masked(const char top, const char bottom) {
	if (!(arg_flags & SHOW_MASKED))
	return 0;

	printf("%s%s%s %s %s %s\n",
	ansi_highlight_red(), "[MASKED]", ansi_normal(),
	top, special_glyph(ARROW), bottom);
	return 1;
	}

	static int notify_override_equivalent(const char top, const char bottom) {
	if (!(arg_flags & SHOW_EQUIVALENT))
	return 0;

	printf("%s%s%s %s %s %s\n",
	ansi_highlight_green(), "[EQUIVALENT]", ansi_normal(),
	top, special_glyph(ARROW), bottom);
	return 1;
	}

	static int notify_override_redirected(const char top, const char bottom) {
	if (!(arg_flags & SHOW_REDIRECTED))
	return 0;

	printf("%s%s%s %s %s %s\n",
	ansi_highlight(), "[REDIRECTED]", ansi_normal(),
	top, special_glyph(ARROW), bottom);
	return 1;
	}

	static int notify_override_overridden(const char top, const char bottom) {
	if (!(arg_flags & SHOW_OVERRIDDEN))
	return 0;

	printf("%s%s%s %s %s %s\n",
	ansi_highlight(), "[OVERRIDDEN]", ansi_normal(),
	top, special_glyph(ARROW), bottom);
	return 1;
	}

	static int notify_override_extended(const char top, const char bottom) {
	if (!(arg_flags & SHOW_EXTENDED))
	return 0;

	printf("%s%s%s %s %s %s\n",
	ansi_highlight(), "[EXTENDED]", ansi_normal(),
	top, special_glyph(ARROW), bottom);
	return 1;
	}

	static int notify_override_unchanged(const char *f) {
	if (!(arg_flags & SHOW_UNCHANGED))
	return 0;

	printf("[UNCHANGED] %s\n", f);
	return 1;
	}

	static int found_override(const char top, const char bottom) {
	_cleanup_free_ char *dest = NULL;
	int k;
	pid_t pid;

	assert(top);
	assert(bottom);

	if (null_or_empty_path(top) > 0)
	return notify_override_masked(top, bottom);

	k = readlink_malloc(top, &dest);
	if (k >= 0) {
	if (equivalent(dest, bottom) > 0)
	return notify_override_equivalent(top, bottom);
	else
	return notify_override_redirected(top, bottom);
	}

	k = notify_override_overridden(top, bottom);
	if (!arg_diff)
	return k;

	putchar('\n');

	fflush(stdout);

	pid = fork();
	if (pid < 0)
	return log_error_errno(errno, "Failed to fork off diff: %m");
	else if (pid == 0) {

	(void) reset_all_signal_handlers();
	(void) reset_signal_mask();
	assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);

	execlp("diff", "diff", "-us", "--", bottom, top, NULL);
	log_error_errno(errno, "Failed to execute diff: %m");
	_exit(EXIT_FAILURE);
	}

	wait_for_terminate_and_warn("diff", pid, false);
	putchar('\n');

	return k;
	}

	static int enumerate_dir_d(
	OrderedHashmap *top,
	OrderedHashmap *bottom,
	OrderedHashmap *drops,
	const char toppath, const char drop) {

	_cleanup_free_ char *unit = NULL;
	_cleanup_free_ char *path = NULL;
	_cleanup_strv_free_ char **list = NULL;
	char **file;
	char *c;
	int r;

	assert(!endswith(drop, "/"));

	path = strjoin(toppath, "/", drop);
	if (!path)
	return -ENOMEM;

	log_debug("Looking at %s", path);

	unit = strdup(drop);
	if (!unit)
	return -ENOMEM;

	c = strrchr(unit, '.');
	if (!c)
	return -EINVAL;
	*c = 0;

	r = get_files_in_directory(path, &list);
	if (r < 0)
	return log_error_errno(r, "Failed to enumerate %s: %m", path);

	strv_sort(list);

	STRV_FOREACH(file, list) {
	OrderedHashmap *h;
	int k;
	char *p;
	char *d;

	if (!endswith(*file, ".conf"))
	continue;

	p = strjoin(path, "/", *file);
	if (!p)
	return -ENOMEM;
	d = p + strlen(toppath) + 1;

	log_debug("Adding at top: %s %s %s", d, special_glyph(ARROW), p);
	k = ordered_hashmap_put(top, d, p);
	if (k >= 0) {
	p = strdup(p);
	if (!p)
	return -ENOMEM;
	d = p + strlen(toppath) + 1;
	} else if (k != -EEXIST) {
	free(p);
	return k;
	}

	log_debug("Adding at bottom: %s %s %s", d, special_glyph(ARROW), p);
	free(ordered_hashmap_remove(bottom, d));
	k = ordered_hashmap_put(bottom, d, p);
	if (k < 0) {
	free(p);
	return k;
	}

	h = ordered_hashmap_get(drops, unit);
	if (!h) {
	h = ordered_hashmap_new(&string_hash_ops);
	if (!h)
	return -ENOMEM;
	ordered_hashmap_put(drops, unit, h);
	unit = strdup(unit);
	if (!unit)
	return -ENOMEM;
	}

	p = strdup(p);
	if (!p)
	return -ENOMEM;

	log_debug("Adding to drops: %s %s %s %s %s",
	unit, special_glyph(ARROW), basename(p), special_glyph(ARROW), p);
	k = ordered_hashmap_put(h, basename(p), p);
	if (k < 0) {
	free(p);
	if (k != -EEXIST)
	return k;
	}
	}
	return 0;
	}

	static int enumerate_dir(
	OrderedHashmap *top,
	OrderedHashmap *bottom,
	OrderedHashmap *drops,
	const char *path, bool dropins) {

	_cleanup_closedir_ DIR *d = NULL;
	struct dirent *de;
	_cleanup_strv_free_ char files = NULL, dirs = NULL;
	size_t n_files = 0, allocated_files = 0, n_dirs = 0, allocated_dirs = 0;
	char **t;
	int r;

	assert(top);
	assert(bottom);
	assert(drops);
	assert(path);

	log_debug("Looking at %s", path);

	d = opendir(path);
	if (!d) {
	if (errno == ENOENT)
	return 0;

	return log_error_errno(errno, "Failed to open %s: %m", path);
	}

	FOREACH_DIRENT_ALL(de, d, return -errno) {
	dirent_ensure_type(d, de);

	if (dropins && de->d_type == DT_DIR && endswith(de->d_name, ".d")) {
	if (!GREEDY_REALLOC0(dirs, allocated_dirs, n_dirs + 2))
	return -ENOMEM;

	dirs[n_dirs] = strdup(de->d_name);
	if (!dirs[n_dirs])
	return -ENOMEM;
	n_dirs ++;
	}

	if (!dirent_is_file(de))
	continue;

	if (!GREEDY_REALLOC0(files, allocated_files, n_files + 2))
	return -ENOMEM;

	files[n_files] = strdup(de->d_name);
	if (!files[n_files])
	return -ENOMEM;
	n_files ++;
	}

	strv_sort(dirs);
	strv_sort(files);

	STRV_FOREACH(t, dirs) {
	r = enumerate_dir_d(top, bottom, drops, path, *t);
	if (r < 0)
	return r;
	}

	STRV_FOREACH(t, files) {
	_cleanup_free_ char *p = NULL;

	p = strjoin(path, "/", *t);
	if (!p)
	return -ENOMEM;

	log_debug("Adding at top: %s %s %s", basename(p), special_glyph(ARROW), p);
	r = ordered_hashmap_put(top, basename(p), p);
	if (r >= 0) {
	p = strdup(p);
	if (!p)
	return -ENOMEM;
	} else if (r != -EEXIST)
	return r;

	log_debug("Adding at bottom: %s %s %s", basename(p), special_glyph(ARROW), p);
	free(ordered_hashmap_remove(bottom, basename(p)));
	r = ordered_hashmap_put(bottom, basename(p), p);
	if (r < 0)
	return r;
	p = NULL;
	}

	return 0;
	}

	static int should_skip_prefix(const char* p) {
	#ifdef HAVE_SPLIT_USR
	int r;
	_cleanup_free_ char *target = NULL;

	r = chase_symlinks(p, NULL, 0, &target);
	if (r < 0)
	return r;

	return !streq(p, target) && nulstr_contains(prefixes, target);
	#else
	return 0;
	#endif
	}

	static int process_suffix(const char suffix, const char onlyprefix) {
	const char *p;
	char *f;
	OrderedHashmap top, bottom, *drops;
	OrderedHashmap *h;
	char *key;
	int r = 0, k;
	Iterator i, j;
	int n_found = 0;
	bool dropins;

	assert(suffix);
	assert(!startswith(suffix, "/"));
	assert(!strstr(suffix, "//"));

	dropins = nulstr_contains(have_dropins, suffix);

	top = ordered_hashmap_new(&string_hash_ops);
	bottom = ordered_hashmap_new(&string_hash_ops);
	drops = ordered_hashmap_new(&string_hash_ops);
	if (!top \|\| !bottom \|\| !drops) {
	r = -ENOMEM;
	goto finish;
	}

	NULSTR_FOREACH(p, prefixes) {
	_cleanup_free_ char *t = NULL;
	int skip;

	skip = should_skip_prefix(p);
	if (skip < 0) {
	r = skip;
	goto finish;
	}
	if (skip)
	continue;

	t = strjoin(p, "/", suffix);
	if (!t) {
	r = -ENOMEM;
	goto finish;
	}

	k = enumerate_dir(top, bottom, drops, t, dropins);
	if (r == 0)
	r = k;
	}

	ORDERED_HASHMAP_FOREACH_KEY(f, key, top, i) {
	char *o;

	o = ordered_hashmap_get(bottom, key);
	assert(o);

	if (!onlyprefix \|\| startswith(o, onlyprefix)) {
	if (path_equal(o, f)) {
	notify_override_unchanged(f);
	} else {
	k = found_override(f, o);
	if (k < 0)
	r = k;
	else
	n_found += k;
	}
	}

	h = ordered_hashmap_get(drops, key);
	if (h)
	ORDERED_HASHMAP_FOREACH(o, h, j)
	if (!onlyprefix \|\| startswith(o, onlyprefix))
	n_found += notify_override_extended(f, o);
	}

	finish:
	ordered_hashmap_free_free(top);
	ordered_hashmap_free_free(bottom);

	ORDERED_HASHMAP_FOREACH_KEY(h, key, drops, i) {
	ordered_hashmap_free_free(ordered_hashmap_remove(drops, key));
	ordered_hashmap_remove(drops, key);
	free(key);
	}
	ordered_hashmap_free(drops);

	return r < 0 ? r : n_found;
	}

	static int process_suffixes(const char *onlyprefix) {
	const char *n;
	int n_found = 0, r;

	NULSTR_FOREACH(n, suffixes) {
	r = process_suffix(n, onlyprefix);
	if (r < 0)
	return r;

	n_found += r;
	}

	return n_found;
	}

	static int process_suffix_chop(const char *arg) {
	const char *p;

	assert(arg);

	if (!path_is_absolute(arg))
	return process_suffix(arg, NULL);

	/* Strip prefix from the suffix */
	NULSTR_FOREACH(p, prefixes) {
	const char *suffix;
	int skip;

	skip = should_skip_prefix(p);
	if (skip < 0)
	return skip;
	if (skip)
	continue;

	suffix = startswith(arg, p);
	if (suffix) {
	suffix += strspn(suffix, "/");
	if (*suffix)
	return process_suffix(suffix, NULL);
	else
	return process_suffixes(arg);
	}
	}

	log_error("Invalid suffix specification %s.", arg);
	return -EINVAL;
	}

	static void help(void) {
	printf("%s [OPTIONS...] [SUFFIX...]\n\n"
	"Find overridden configuration files.\n\n"
	" -h --help Show this help\n"
	" --version Show package version\n"
	" --no-pager Do not pipe output into a pager\n"
	" --diff[=1\|0] Show a diff when overridden files differ\n"
	" -t --type=LIST... Only display a selected set of override types\n"
	, program_invocation_short_name);
	}

	static int parse_flags(const char *flag_str, int flags) {
	const char word, state;
	size_t l;

	FOREACH_WORD_SEPARATOR(word, l, flag_str, ",", state) {
	if (strneq("masked", word, l))
	flags \|= SHOW_MASKED;
	else if (strneq ("equivalent", word, l))
	flags \|= SHOW_EQUIVALENT;
	else if (strneq("redirected", word, l))
	flags \|= SHOW_REDIRECTED;
	else if (strneq("overridden", word, l))
	flags \|= SHOW_OVERRIDDEN;
	else if (strneq("unchanged", word, l))
	flags \|= SHOW_UNCHANGED;
	else if (strneq("extended", word, l))
	flags \|= SHOW_EXTENDED;
	else if (strneq("default", word, l))
	flags \|= SHOW_DEFAULTS;
	else
	return -EINVAL;
	}
	return flags;
	}

	static int parse_argv(int argc, char *argv[]) {

	enum {
	ARG_NO_PAGER = 0x100,
	ARG_DIFF,
	ARG_VERSION
	};

	static const struct option options[] = {
	{ "help", no_argument, NULL, 'h' },
	{ "version", no_argument, NULL, ARG_VERSION },
	{ "no-pager", no_argument, NULL, ARG_NO_PAGER },
	{ "diff", optional_argument, NULL, ARG_DIFF },
	{ "type", required_argument, NULL, 't' },
	{}
	};

	int c;

	assert(argc >= 1);
	assert(argv);

	while ((c = getopt_long(argc, argv, "ht:", options, NULL)) >= 0)

	switch (c) {

	case 'h':
	help();
	return 0;

	case ARG_VERSION:
	return version();

	case ARG_NO_PAGER:
	arg_no_pager = true;
	break;

	case 't': {
	int f;
	f = parse_flags(optarg, arg_flags);
	if (f < 0) {
	log_error("Failed to parse flags field.");
	return -EINVAL;
	}
	arg_flags = f;
	break;
	}

	case ARG_DIFF:
	if (!optarg)
	arg_diff = 1;
	else {
	int b;

	b = parse_boolean(optarg);
	if (b < 0) {
	log_error("Failed to parse diff boolean.");
	return -EINVAL;
	}

	arg_diff = b;
	}
	break;

	case '?':
	return -EINVAL;

	default:
	assert_not_reached("Unhandled option");
	}

	return 1;
	}

	int main(int argc, char *argv[]) {
	int r, k, n_found = 0;

	log_parse_environment();
	log_open();

	r = parse_argv(argc, argv);
	if (r <= 0)
	goto finish;

	if (arg_flags == 0)
	arg_flags = SHOW_DEFAULTS;

	if (arg_diff < 0)
	arg_diff = !!(arg_flags & SHOW_OVERRIDDEN);
	else if (arg_diff)
	arg_flags \|= SHOW_OVERRIDDEN;

	pager_open(arg_no_pager, false);

	if (optind < argc) {
	int i;

	for (i = optind; i < argc; i++) {
	path_kill_slashes(argv[i]);

	k = process_suffix_chop(argv[i]);
	if (k < 0)
	r = k;
	else
	n_found += k;
	}

	} else {
	k = process_suffixes(NULL);
	if (k < 0)
	r = k;
	else
	n_found += k;
	}

	if (r >= 0)
	printf("%s%i overridden configuration files found.\n", n_found ? "\n" : "", n_found);

	finish:
	pager_close();

	return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
	}