[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 <assert.h>
#include <string.h>
#include <unistd.h>
#include <getopt.h>

#include "hashmap.h"
#include "util.h"
#include "path-util.h"
#include "log.h"
#include "pager.h"
#include "build.h"
#include "strv.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\n",
               ansi_highlight_red(), "[MASKED]", ansi_highlight_off(), top, 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\n",
               ansi_highlight_green(), "[EQUIVALENT]", ansi_highlight_off(), top, 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\n",
               ansi_highlight(), "[REDIRECTED]", ansi_highlight_off(), top, 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\n",
               ansi_highlight(), "[OVERRIDDEN]", ansi_highlight_off(), top, 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\n",
               ansi_highlight(), "[EXTENDED]", ansi_highlight_off(), top, 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) {
                log_error("Failed to fork off diff: %m");
                return -errno;
        } else if (pid == 0) {
                execlp("diff", "diff", "-us", "--", bottom, top, NULL);
                log_error("Failed to execute diff: %m");
                _exit(1);
        }

        wait_for_terminate(pid, NULL);

        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){
                log_error("Failed to enumerate %s: %s", path, strerror(-r));
                return r;
        }

        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", d, 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", d, 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_func, string_compare_func);
                        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", unit, basename(p), 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("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", basename(p), 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", basename(p), 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_func, string_compare_func);
        bottom = hashmap_new(string_hash_func, string_compare_func);
        drops = hashmap_new(string_hash_func, string_compare_func);
        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 int 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);

        return 0;
}

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

        FOREACH_WORD(w, l, flag_str, state) {
                if (strneq("masked", w, l))
                        flags |= SHOW_MASKED;
                else if (strneq ("equivalent", w, l))
                        flags |= SHOW_EQUIVALENT;
                else if (strneq("redirected", w, l))
                        flags |= SHOW_REDIRECTED;
                else if (strneq("overridden", w, l))
                        flags |= SHOW_OVERRIDDEN;
                else if (strneq("unchanged", w, l))
                        flags |= SHOW_UNCHANGED;
                else if (strneq("extended", w, l))
                        flags |= SHOW_EXTENDED;
                else if (strneq("default", w, 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:
                        puts(PACKAGE_STRING);
                        puts(SYSTEMD_FEATURES);
                        return 0;

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