[thirdparty/systemd.git] / src / delta / delta.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  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 void pager_open_if_enabled(void) {

        if (arg_no_pager)
                return;

        pager_open(false);
}

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

        x = canonicalize_file_name(a);
        if (!x)
                return -errno;

        y = canonicalize_file_name(b);
        if (!y)
                return -errno;

        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, draw_special_char(DRAW_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, draw_special_char(DRAW_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, draw_special_char(DRAW_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, draw_special_char(DRAW_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, draw_special_char(DRAW_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(Hashmap *top, Hashmap *bottom, Hashmap *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, NULL);
        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_FOREACH(file, list) {
                Hashmap *h;
                int k;
                char *p;
                char *d;

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

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

                log_debug("Adding at top: %s %s %s", d, draw_special_char(DRAW_ARROW), p);
                k = 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, draw_special_char(DRAW_ARROW), p);
                free(hashmap_remove(bottom, d));
                k = hashmap_put(bottom, d, p);
                if (k < 0) {
                        free(p);
                        return k;
                }

                h = hashmap_get(drops, unit);
                if (!h) {
                        h = hashmap_new(&string_hash_ops);
                        if (!h)
                                return -ENOMEM;
                        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, draw_special_char(DRAW_ARROW), basename(p), draw_special_char(DRAW_ARROW), p);
                k = hashmap_put(h, basename(p), p);
                if (k < 0) {
                        free(p);
                        if (k != -EEXIST)
                                return k;
                }
        }
        return 0;
}

static int enumerate_dir(Hashmap *top, Hashmap *bottom, Hashmap *drops, const char *path, bool dropins) {
        _cleanup_closedir_ DIR *d;

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

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

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

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

        for (;;) {
                struct dirent *de;
                int k;
                char *p;

                errno = 0;
                de = readdir(d);
                if (!de)
                        return -errno;

                dirent_ensure_type(d, de);

                if (dropins && de->d_type == DT_DIR && endswith(de->d_name, ".d"))
                        enumerate_dir_d(top, bottom, drops, path, de->d_name);

                if (!dirent_is_file(de))
                        continue;

                p = strjoin(path, "/", de->d_name, NULL);
                if (!p)
                        return -ENOMEM;

                log_debug("Adding at top: %s %s %s", basename(p), draw_special_char(DRAW_ARROW), p);
                k = hashmap_put(top, basename(p), p);
                if (k >= 0) {
                        p = strdup(p);
                        if (!p)
                                return -ENOMEM;
                } else if (k != -EEXIST) {
                        free(p);
                        return k;
                }

                log_debug("Adding at bottom: %s %s %s", basename(p), draw_special_char(DRAW_ARROW), p);
                free(hashmap_remove(bottom, basename(p)));
                k = hashmap_put(bottom, basename(p), p);
                if (k < 0) {
                        free(p);
                        return k;
                }
        }
}

static int process_suffix(const char *suffix, const char *onlyprefix) {
        const char *p;
        char *f;
        Hashmap *top, *bottom, *drops;
        Hashmap *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 = hashmap_new(&string_hash_ops);
        bottom = hashmap_new(&string_hash_ops);
        drops = hashmap_new(&string_hash_ops);
        if (!top || !bottom || !drops) {
                r = -ENOMEM;
                goto finish;
        }

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

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

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

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

                o = 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 = hashmap_get(drops, key);
                if (h)
                        HASHMAP_FOREACH(o, h, j)
                                if (!onlyprefix || startswith(o, onlyprefix))
                                        n_found += notify_override_extended(f, o);
        }

finish:
        if (top)
                hashmap_free_free(top);
        if (bottom)
                hashmap_free_free(bottom);
        if (drops) {
                HASHMAP_FOREACH_KEY(h, key, drops, i){
                        hashmap_free_free(hashmap_remove(drops, key));
                        hashmap_remove(drops, key);
                        free(key);
                }
                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;
                else
                        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 = 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;
                                } else if (b)
                                        arg_diff = 1;
                                else
                                        arg_diff = 0;
                        }
                        break;

                case '?':
                        return -EINVAL;

                default:
                        assert_not_reached("Unhandled option");
                }

        return 1;
}

int main(int argc, char *argv[]) {
        int r = 0, k;
        int 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_if_enabled();

        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;
}
Commit	Line	Data
7e8d5761 LP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2012 Lennart Poettering
6096dfd6	7	Copyright 2013 Zbigniew Jędrzejewski-Szmek
7e8d5761 LP	8
	9	systemd is free software; you can redistribute it and/or modify it
	10	under the terms of the GNU Lesser General Public License as published by
	11	the Free Software Foundation; either version 2.1 of the License, or
	12	(at your option) any later version.
	13
	14	systemd is distributed in the hope that it will be useful, but
	15	WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	Lesser General Public License for more details.
	18
	19	You should have received a copy of the GNU Lesser General Public License
	20	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	21	***/
	22
	23	#include <errno.h>
7e8d5761	24	#include <getopt.h>
3f6fd1ba	25	#include <string.h>
ce30c8dc	26	#include <sys/prctl.h>
3f6fd1ba	27	#include <unistd.h>
7e8d5761	28
b5efdb8a	29	#include "alloc-util.h"
a0956174	30	#include "dirent-util.h"
3ffd4af2	31	#include "fd-util.h"
f4f15635	32	#include "fs-util.h"
7e8d5761	33	#include "hashmap.h"
8752c575	34	#include "locale-util.h"
7e8d5761 LP	35	#include "log.h"
7e8d5761 LP	36	#include "pager.h"
6bedfcbb	37	#include "parse-util.h"
3f6fd1ba	38	#include "path-util.h"
0b452006	39	#include "process-util.h"
ce30c8dc	40	#include "signal-util.h"
8fcde012	41	#include "stat-util.h"
07630cea	42	#include "string-util.h"
3f6fd1ba LP	43	#include "strv.h"
	44	#include "terminal-util.h"
	45	#include "util.h"
7e8d5761	46
f939e9a4 ZJS	47	static const char prefixes[] =
	48	"/etc\0"
	49	"/run\0"
	50	"/usr/local/lib\0"
	51	"/usr/local/share\0"
	52	"/usr/lib\0"
	53	"/usr/share\0"
	54	#ifdef HAVE_SPLIT_USR
	55	"/lib\0"
	56	#endif
	57	;
	58
	59	static const char suffixes[] =
	60	"sysctl.d\0"
	61	"tmpfiles.d\0"
	62	"modules-load.d\0"
	63	"binfmt.d\0"
	64	"systemd/system\0"
	65	"systemd/user\0"
	66	"systemd/system-preset\0"
	67	"systemd/user-preset\0"
	68	"udev/rules.d\0"
	69	"modprobe.d\0";
	70
	71	static const char have_dropins[] =
	72	"systemd/system\0"
	73	"systemd/user\0";
	74
7e8d5761	75	static bool arg_no_pager = false;
866062b1	76	static int arg_diff = -1;
7e8d5761	77
866062b1	78	static enum {
4c4e6431	79	SHOW_MASKED = 1 << 0,
c8021373 LP	80	SHOW_EQUIVALENT = 1 << 1,
c8021373 LP	81	SHOW_REDIRECTED = 1 << 2,
386da858	82	SHOW_OVERRIDDEN = 1 << 3,
4c4e6431	83	SHOW_UNCHANGED = 1 << 4,
0000ce05	84	SHOW_EXTENDED = 1 << 5,
4c4e6431 LP	85
4c4e6431 LP	86	SHOW_DEFAULTS =
0000ce05	87	(SHOW_MASKED \| SHOW_EQUIVALENT \| SHOW_REDIRECTED \| SHOW_OVERRIDDEN \| SHOW_EXTENDED)
866062b1	88	} arg_flags = 0;
4c4e6431	89
f939e9a4 ZJS	90	static void pager_open_if_enabled(void) {
	91
	92	if (arg_no_pager)
	93	return;
	94
	95	pager_open(false);
	96	}
	97
7e8d5761	98	static int equivalent(const char a, const char b) {
e26970a8	99	_cleanup_free_ char x = NULL, y = NULL;
7e8d5761 LP	100
	101	x = canonicalize_file_name(a);
	102	if (!x)
	103	return -errno;
	104
	105	y = canonicalize_file_name(b);
e26970a8	106	if (!y)
7e8d5761	107	return -errno;
7e8d5761	108
e26970a8	109	return path_equal(x, y);
7e8d5761 LP	110	}
7e8d5761 LP	111
866062b1 LP	112	static int notify_override_masked(const char top, const char bottom) {
866062b1 LP	113	if (!(arg_flags & SHOW_MASKED))
807f4645 GN	114	return 0;
807f4645 GN	115
00a5cc3a	116	printf("%s%s%s %s %s %s\n",
1fc464f6	117	ansi_highlight_red(), "[MASKED]", ansi_normal(),
6b01f1d3	118	top, draw_special_char(DRAW_ARROW), bottom);
807f4645 GN	119	return 1;
	120	}
	121
866062b1 LP	122	static int notify_override_equivalent(const char top, const char bottom) {
866062b1 LP	123	if (!(arg_flags & SHOW_EQUIVALENT))
807f4645 GN	124	return 0;
807f4645 GN	125
00a5cc3a	126	printf("%s%s%s %s %s %s\n",
1fc464f6	127	ansi_highlight_green(), "[EQUIVALENT]", ansi_normal(),
6b01f1d3	128	top, draw_special_char(DRAW_ARROW), bottom);
807f4645 GN	129	return 1;
	130	}
	131
866062b1 LP	132	static int notify_override_redirected(const char top, const char bottom) {
866062b1 LP	133	if (!(arg_flags & SHOW_REDIRECTED))
807f4645 GN	134	return 0;
807f4645 GN	135
9b6e0ce5	136	printf("%s%s%s %s %s %s\n",
1fc464f6	137	ansi_highlight(), "[REDIRECTED]", ansi_normal(),
6b01f1d3	138	top, draw_special_char(DRAW_ARROW), bottom);
807f4645 GN	139	return 1;
	140	}
	141
386da858 NM	142	static int notify_override_overridden(const char top, const char bottom) {
386da858 NM	143	if (!(arg_flags & SHOW_OVERRIDDEN))
807f4645 GN	144	return 0;
807f4645 GN	145
00a5cc3a	146	printf("%s%s%s %s %s %s\n",
1fc464f6	147	ansi_highlight(), "[OVERRIDDEN]", ansi_normal(),
6b01f1d3	148	top, draw_special_char(DRAW_ARROW), bottom);
807f4645 GN	149	return 1;
	150	}
	151
0000ce05 LN	152	static int notify_override_extended(const char top, const char bottom) {
	153	if (!(arg_flags & SHOW_EXTENDED))
	154	return 0;
	155
00a5cc3a	156	printf("%s%s%s %s %s %s\n",
1fc464f6	157	ansi_highlight(), "[EXTENDED]", ansi_normal(),
6b01f1d3	158	top, draw_special_char(DRAW_ARROW), bottom);
0000ce05 LN	159	return 1;
	160	}
	161
866062b1 LP	162	static int notify_override_unchanged(const char *f) {
866062b1 LP	163	if (!(arg_flags & SHOW_UNCHANGED))
807f4645 GN	164	return 0;
807f4645 GN	165
8e812a23	166	printf("[UNCHANGED] %s\n", f);
807f4645 GN	167	return 1;
	168	}
	169
866062b1	170	static int found_override(const char top, const char bottom) {
e26970a8	171	_cleanup_free_ char *dest = NULL;
a572b2e0	172	int k;
7e8d5761 LP	173	pid_t pid;
	174
	175	assert(top);
	176	assert(bottom);
	177
8fd57568 ZJS	178	if (null_or_empty_path(top) > 0)
8fd57568 ZJS	179	return notify_override_masked(top, bottom);
7e8d5761 LP	180
	181	k = readlink_malloc(top, &dest);
	182	if (k >= 0) {
	183	if (equivalent(dest, bottom) > 0)
8fd57568	184	return notify_override_equivalent(top, bottom);
7e8d5761	185	else
8fd57568	186	return notify_override_redirected(top, bottom);
7e8d5761 LP	187	}
7e8d5761 LP	188
8fd57568	189	k = notify_override_overridden(top, bottom);
866062b1	190	if (!arg_diff)
8fd57568	191	return k;
7e8d5761 LP	192
	193	putchar('\n');
	194
	195	fflush(stdout);
	196
	197	pid = fork();
4a62c710 MS	198	if (pid < 0)
	199	return log_error_errno(errno, "Failed to fork off diff: %m");
	200	else if (pid == 0) {
ce30c8dc LP	201
	202	(void) reset_all_signal_handlers();
	203	(void) reset_signal_mask();
	204	assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
	205
7e8d5761	206	execlp("diff", "diff", "-us", "--", bottom, top, NULL);
56f64d95	207	log_error_errno(errno, "Failed to execute diff: %m");
ce30c8dc	208	_exit(EXIT_FAILURE);
7e8d5761 LP	209	}
7e8d5761 LP	210
820d3acf	211	wait_for_terminate_and_warn("diff", pid, false);
7e8d5761 LP	212	putchar('\n');
7e8d5761 LP	213
8fd57568	214	return k;
7e8d5761 LP	215	}
7e8d5761 LP	216
0000ce05	217	static int enumerate_dir_d(Hashmap top, Hashmap bottom, Hashmap drops, const char toppath, const char *drop) {
f939e9a4	218	_cleanup_free_ char *unit = NULL;
0000ce05 LN	219	_cleanup_free_ char *path = NULL;
	220	_cleanup_strv_free_ char **list = NULL;
	221	char **file;
	222	char *c;
	223	int r;
	224
f939e9a4 ZJS	225	assert(!endswith(drop, "/"));
f939e9a4 ZJS	226
0000ce05 LN	227	path = strjoin(toppath, "/", drop, NULL);
	228	if (!path)
	229	return -ENOMEM;
	230
f939e9a4	231	log_debug("Looking at %s", path);
0000ce05	232
f939e9a4 ZJS	233	unit = strdup(drop);
f939e9a4 ZJS	234	if (!unit)
0000ce05 LN	235	return -ENOMEM;
0000ce05 LN	236
f939e9a4	237	c = strrchr(unit, '.');
0000ce05 LN	238	if (!c)
	239	return -EINVAL;
	240	*c = 0;
	241
	242	r = get_files_in_directory(path, &list);
23bbb0de MS	243	if (r < 0)
23bbb0de MS	244	return log_error_errno(r, "Failed to enumerate %s: %m", path);
0000ce05 LN	245
	246	STRV_FOREACH(file, list) {
	247	Hashmap *h;
	248	int k;
	249	char *p;
	250	char *d;
	251
	252	if (!endswith(*file, ".conf"))
	253	continue;
	254
	255	p = strjoin(path, "/", *file, NULL);
	256	if (!p)
	257	return -ENOMEM;
f939e9a4	258	d = p + strlen(toppath) + 1;
0000ce05	259
6b01f1d3	260	log_debug("Adding at top: %s %s %s", d, draw_special_char(DRAW_ARROW), p);
0000ce05 LN	261	k = hashmap_put(top, d, p);
	262	if (k >= 0) {
	263	p = strdup(p);
	264	if (!p)
	265	return -ENOMEM;
f939e9a4	266	d = p + strlen(toppath) + 1;
0000ce05 LN	267	} else if (k != -EEXIST) {
	268	free(p);
	269	return k;
	270	}
	271
6b01f1d3	272	log_debug("Adding at bottom: %s %s %s", d, draw_special_char(DRAW_ARROW), p);
0000ce05 LN	273	free(hashmap_remove(bottom, d));
	274	k = hashmap_put(bottom, d, p);
	275	if (k < 0) {
	276	free(p);
	277	return k;
	278	}
	279
f939e9a4	280	h = hashmap_get(drops, unit);
0000ce05	281	if (!h) {
d5099efc	282	h = hashmap_new(&string_hash_ops);
0000ce05 LN	283	if (!h)
0000ce05 LN	284	return -ENOMEM;
f939e9a4 ZJS	285	hashmap_put(drops, unit, h);
	286	unit = strdup(unit);
	287	if (!unit)
0000ce05 LN	288	return -ENOMEM;
	289	}
	290
	291	p = strdup(p);
	292	if (!p)
	293	return -ENOMEM;
	294
00a5cc3a	295	log_debug("Adding to drops: %s %s %s %s %s",
6b01f1d3	296	unit, draw_special_char(DRAW_ARROW), basename(p), draw_special_char(DRAW_ARROW), p);
2b6bf07d	297	k = hashmap_put(h, basename(p), p);
0000ce05 LN	298	if (k < 0) {
	299	free(p);
	300	if (k != -EEXIST)
	301	return k;
	302	}
	303	}
	304	return 0;
	305	}
	306
	307	static int enumerate_dir(Hashmap top, Hashmap bottom, Hashmap drops, const char path, bool dropins) {
e26970a8	308	_cleanup_closedir_ DIR *d;
7e8d5761 LP	309
	310	assert(top);
	311	assert(bottom);
0000ce05	312	assert(drops);
7e8d5761 LP	313	assert(path);
7e8d5761 LP	314
f939e9a4 ZJS	315	log_debug("Looking at %s", path);
f939e9a4 ZJS	316
7e8d5761 LP	317	d = opendir(path);
	318	if (!d) {
	319	if (errno == ENOENT)
	320	return 0;
	321
56f64d95	322	log_error_errno(errno, "Failed to open %s: %m", path);
7e8d5761 LP	323	return -errno;
	324	}
	325
	326	for (;;) {
7d5e9c0f	327	struct dirent *de;
7e8d5761 LP	328	int k;
	329	char *p;
	330
6887ec4f FW	331	errno = 0;
6887ec4f FW	332	de = readdir(d);
7e8d5761	333	if (!de)
f939e9a4	334	return -errno;
7e8d5761	335
277f2f75 LN	336	dirent_ensure_type(d, de);
277f2f75 LN	337
0000ce05 LN	338	if (dropins && de->d_type == DT_DIR && endswith(de->d_name, ".d"))
	339	enumerate_dir_d(top, bottom, drops, path, de->d_name);
	340
7e8d5761 LP	341	if (!dirent_is_file(de))
	342	continue;
	343
b7def684	344	p = strjoin(path, "/", de->d_name, NULL);
e26970a8 TA	345	if (!p)
e26970a8 TA	346	return -ENOMEM;
7e8d5761	347
6b01f1d3	348	log_debug("Adding at top: %s %s %s", basename(p), draw_special_char(DRAW_ARROW), p);
2b6bf07d	349	k = hashmap_put(top, basename(p), p);
7e8d5761 LP	350	if (k >= 0) {
7e8d5761 LP	351	p = strdup(p);
e26970a8 TA	352	if (!p)
e26970a8 TA	353	return -ENOMEM;
7e8d5761 LP	354	} else if (k != -EEXIST) {
7e8d5761 LP	355	free(p);
e26970a8	356	return k;
7e8d5761 LP	357	}
7e8d5761 LP	358
6b01f1d3	359	log_debug("Adding at bottom: %s %s %s", basename(p), draw_special_char(DRAW_ARROW), p);
2b6bf07d ZJS	360	free(hashmap_remove(bottom, basename(p)));
2b6bf07d ZJS	361	k = hashmap_put(bottom, basename(p), p);
7e8d5761 LP	362	if (k < 0) {
7e8d5761 LP	363	free(p);
e26970a8	364	return k;
7e8d5761 LP	365	}
7e8d5761 LP	366	}
7e8d5761 LP	367	}
7e8d5761 LP	368
6096dfd6	369	static int process_suffix(const char suffix, const char onlyprefix) {
7e8d5761 LP	370	const char *p;
7e8d5761 LP	371	char *f;
f939e9a4	372	Hashmap top, bottom, *drops;
0000ce05 LN	373	Hashmap *h;
0000ce05 LN	374	char *key;
7e8d5761	375	int r = 0, k;
0000ce05	376	Iterator i, j;
7e8d5761	377	int n_found = 0;
f939e9a4	378	bool dropins;
7e8d5761	379
7e8d5761	380	assert(suffix);
f939e9a4 ZJS	381	assert(!startswith(suffix, "/"));
f939e9a4 ZJS	382	assert(!strstr(suffix, "//"));
7e8d5761	383
f939e9a4	384	dropins = nulstr_contains(have_dropins, suffix);
7e8d5761	385
d5099efc MS	386	top = hashmap_new(&string_hash_ops);
	387	bottom = hashmap_new(&string_hash_ops);
	388	drops = hashmap_new(&string_hash_ops);
f939e9a4	389	if (!top \|\| !bottom \|\| !drops) {
0000ce05 LN	390	r = -ENOMEM;
	391	goto finish;
	392	}
	393
7e8d5761	394	NULSTR_FOREACH(p, prefixes) {
e26970a8	395	_cleanup_free_ char *t = NULL;
7e8d5761	396
b7def684	397	t = strjoin(p, "/", suffix, NULL);
7e8d5761 LP	398	if (!t) {
	399	r = -ENOMEM;
	400	goto finish;
	401	}
	402
0000ce05	403	k = enumerate_dir(top, bottom, drops, t, dropins);
f939e9a4	404	if (r == 0)
7e8d5761	405	r = k;
7e8d5761 LP	406	}
7e8d5761 LP	407
0000ce05	408	HASHMAP_FOREACH_KEY(f, key, top, i) {
7e8d5761 LP	409	char *o;
7e8d5761 LP	410
0000ce05	411	o = hashmap_get(bottom, key);
7e8d5761 LP	412	assert(o);
7e8d5761 LP	413
6096dfd6 ZJS	414	if (!onlyprefix \|\| startswith(o, onlyprefix)) {
	415	if (path_equal(o, f)) {
	416	notify_override_unchanged(f);
	417	} else {
	418	k = found_override(f, o);
	419	if (k < 0)
	420	r = k;
	421	else
	422	n_found += k;
	423	}
807f4645	424	}
7e8d5761	425
0000ce05 LN	426	h = hashmap_get(drops, key);
0000ce05 LN	427	if (h)
8fd57568	428	HASHMAP_FOREACH(o, h, j)
6096dfd6 ZJS	429	if (!onlyprefix \|\| startswith(o, onlyprefix))
6096dfd6 ZJS	430	n_found += notify_override_extended(f, o);
7e8d5761 LP	431	}
	432
	433	finish:
	434	if (top)
	435	hashmap_free_free(top);
	436	if (bottom)
	437	hashmap_free_free(bottom);
0000ce05 LN	438	if (drops) {
	439	HASHMAP_FOREACH_KEY(h, key, drops, i){
	440	hashmap_free_free(hashmap_remove(drops, key));
	441	hashmap_remove(drops, key);
	442	free(key);
	443	}
	444	hashmap_free(drops);
	445	}
7e8d5761 LP	446	return r < 0 ? r : n_found;
	447	}
	448
6096dfd6 ZJS	449	static int process_suffixes(const char *onlyprefix) {
	450	const char *n;
	451	int n_found = 0, r;
	452
	453	NULSTR_FOREACH(n, suffixes) {
	454	r = process_suffix(n, onlyprefix);
	455	if (r < 0)
	456	return r;
	457	else
	458	n_found += r;
	459	}
	460	return n_found;
	461	}
	462
	463	static int process_suffix_chop(const char *arg) {
7e8d5761 LP	464	const char *p;
7e8d5761 LP	465
6096dfd6	466	assert(arg);
7e8d5761	467
6096dfd6 ZJS	468	if (!path_is_absolute(arg))
6096dfd6 ZJS	469	return process_suffix(arg, NULL);
7e8d5761 LP	470
	471	/* Strip prefix from the suffix */
	472	NULSTR_FOREACH(p, prefixes) {
6096dfd6 ZJS	473	const char *suffix = startswith(arg, p);
6096dfd6 ZJS	474	if (suffix) {
7e8d5761	475	suffix += strspn(suffix, "/");
6096dfd6 ZJS	476	if (*suffix)
	477	return process_suffix(suffix, NULL);
	478	else
	479	return process_suffixes(arg);
7e8d5761 LP	480	}
	481	}
	482
6096dfd6	483	log_error("Invalid suffix specification %s.", arg);
7e8d5761 LP	484	return -EINVAL;
	485	}
	486
601185b4	487	static void help(void) {
7e8d5761 LP	488	printf("%s [OPTIONS...] [SUFFIX...]\n\n"
	489	"Find overridden configuration files.\n\n"
	490	" -h --help Show this help\n"
	491	" --version Show package version\n"
807f4645	492	" --no-pager Do not pipe output into a pager\n"
386da858	493	" --diff[=1\|0] Show a diff when overridden files differ\n"
601185b4 ZJS	494	" -t --type=LIST... Only display a selected set of override types\n"
601185b4 ZJS	495	, program_invocation_short_name);
7e8d5761 LP	496	}
7e8d5761 LP	497
866062b1	498	static int parse_flags(const char *flag_str, int flags) {
a2a5291b	499	const char word, state;
807f4645 GN	500	size_t l;
807f4645 GN	501
d0a2e1c3	502	FOREACH_WORD_SEPARATOR(word, l, flag_str, ",", state) {
a2a5291b	503	if (strneq("masked", word, l))
807f4645	504	flags \|= SHOW_MASKED;
a2a5291b	505	else if (strneq ("equivalent", word, l))
c8021373	506	flags \|= SHOW_EQUIVALENT;
a2a5291b	507	else if (strneq("redirected", word, l))
c8021373	508	flags \|= SHOW_REDIRECTED;
a2a5291b	509	else if (strneq("overridden", word, l))
386da858	510	flags \|= SHOW_OVERRIDDEN;
a2a5291b	511	else if (strneq("unchanged", word, l))
807f4645	512	flags \|= SHOW_UNCHANGED;
a2a5291b	513	else if (strneq("extended", word, l))
0000ce05	514	flags \|= SHOW_EXTENDED;
a2a5291b	515	else if (strneq("default", word, l))
807f4645	516	flags \|= SHOW_DEFAULTS;
866062b1 LP	517	else
866062b1 LP	518	return -EINVAL;
807f4645 GN	519	}
	520	return flags;
	521	}
	522
866062b1	523	static int parse_argv(int argc, char *argv[]) {
7e8d5761 LP	524
	525	enum {
	526	ARG_NO_PAGER = 0x100,
807f4645	527	ARG_DIFF,
7e8d5761 LP	528	ARG_VERSION
	529	};
	530
	531	static const struct option options[] = {
	532	{ "help", no_argument, NULL, 'h' },
	533	{ "version", no_argument, NULL, ARG_VERSION },
	534	{ "no-pager", no_argument, NULL, ARG_NO_PAGER },
807f4645 GN	535	{ "diff", optional_argument, NULL, ARG_DIFF },
807f4645 GN	536	{ "type", required_argument, NULL, 't' },
eb9da376	537	{}
7e8d5761 LP	538	};
	539
	540	int c;
	541
	542	assert(argc >= 1);
	543	assert(argv);
	544
601185b4	545	while ((c = getopt_long(argc, argv, "ht:", options, NULL)) >= 0)
7e8d5761 LP	546
	547	switch (c) {
	548
	549	case 'h':
	550	help();
	551	return 0;
	552
	553	case ARG_VERSION:
3f6fd1ba	554	return version();
7e8d5761 LP	555
	556	case ARG_NO_PAGER:
	557	arg_no_pager = true;
	558	break;
	559
866062b1 LP	560	case 't': {
	561	int f;
	562	f = parse_flags(optarg, arg_flags);
	563	if (f < 0) {
	564	log_error("Failed to parse flags field.");
807f4645	565	return -EINVAL;
866062b1 LP	566	}
866062b1 LP	567	arg_flags = f;
807f4645	568	break;
866062b1	569	}
807f4645 GN	570
807f4645 GN	571	case ARG_DIFF:
866062b1 LP	572	if (!optarg)
	573	arg_diff = 1;
	574	else {
	575	int b;
	576
	577	b = parse_boolean(optarg);
	578	if (b < 0) {
	579	log_error("Failed to parse diff boolean.");
	580	return -EINVAL;
	581	} else if (b)
	582	arg_diff = 1;
807f4645	583	else
866062b1	584	arg_diff = 0;
807f4645 GN	585	}
	586	break;
	587
eb9da376	588	case '?':
7e8d5761	589	return -EINVAL;
eb9da376 LP	590
	591	default:
	592	assert_not_reached("Unhandled option");
7e8d5761	593	}
7e8d5761 LP	594
	595	return 1;
	596	}
	597
	598	int main(int argc, char *argv[]) {
7e8d5761 LP	599	int r = 0, k;
	600	int n_found = 0;
	601
	602	log_parse_environment();
	603	log_open();
	604
866062b1	605	r = parse_argv(argc, argv);
7e8d5761 LP	606	if (r <= 0)
	607	goto finish;
	608
866062b1 LP	609	if (arg_flags == 0)
	610	arg_flags = SHOW_DEFAULTS;
	611
	612	if (arg_diff < 0)
386da858	613	arg_diff = !!(arg_flags & SHOW_OVERRIDDEN);
866062b1	614	else if (arg_diff)
386da858	615	arg_flags \|= SHOW_OVERRIDDEN;
807f4645	616
f939e9a4	617	pager_open_if_enabled();
7e8d5761 LP	618
	619	if (optind < argc) {
	620	int i;
	621
	622	for (i = optind; i < argc; i++) {
f939e9a4 ZJS	623	path_kill_slashes(argv[i]);
f939e9a4 ZJS	624	k = process_suffix_chop(argv[i]);
7e8d5761 LP	625	if (k < 0)
	626	r = k;
	627	else
	628	n_found += k;
	629	}
	630
	631	} else {
6096dfd6 ZJS	632	k = process_suffixes(NULL);
	633	if (k < 0)
	634	r = k;
	635	else
	636	n_found += k;
7e8d5761 LP	637	}
	638
	639	if (r >= 0)
8fd57568 ZJS	640	printf("%s%i overridden configuration files found.\n",
8fd57568 ZJS	641	n_found ? "\n" : "", n_found);
7e8d5761 LP	642
	643	finish:
	644	pager_close();
	645
	646	return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
	647	}