install: add systemd-install tool for managing alias/wants symlinks

7 files changed, 647 insertions, 24 deletions

diff --git a/src/conf-parser.c b/src/conf-parser.c
index 20f7641b13..a6d4d92aa2 100644
--- a/src/conf-parser.c
+++ b/src/conf-parser.c
@@ -40,6 +40,7 @@ static int next_assignment(
                 unsigned line,
                 const char *section,
                 const ConfigItem *t,
+                bool relaxed,
                 const char *lvalue,
                 const char *rvalue,
                 void *userdata) {
@@ -60,18 +61,21 @@ static int next_assignment(
                 if (t->section && !streq(section, t->section))
                         continue;
 
+                if (!t->parse)
+                        return 0;
+
                 return t->parse(filename, line, section, lvalue, rvalue, t->data, userdata);
         }
 
         /* Warn about unknown non-extension fields. */
-        if (!startswith(lvalue, "X-"))
+        if (!relaxed && !startswith(lvalue, "X-"))
                 log_info("[%s:%u] Unknown lvalue '%s' in section '%s'. Ignoring.", filename, line, lvalue, strna(section));
 
         return 0;
 }
 
 /* Parse a variable assignment line */
-static int parse_line(const char *filename, unsigned line, char **section, const char* const * sections, const ConfigItem *t, char *l, void *userdata) {
+static int parse_line(const char *filename, unsigned line, char **section, const char* const * sections, const ConfigItem *t, bool relaxed, char *l, void *userdata) {
         char *e;
 
         l = strstrip(l);
@@ -89,7 +93,7 @@ static int parse_line(const char *filename, unsigned line, char **section, const
                 if (!(fn = file_in_same_dir(filename, strstrip(l+9))))
                         return -ENOMEM;
 
-                r = config_parse(fn, NULL, sections, t, userdata);
+                r = config_parse(fn, NULL, sections, t, relaxed, userdata);
                 free(fn);
 
                 return r;
@@ -110,11 +114,8 @@ static int parse_line(const char *filename, unsigned line, char **section, const
                 if (!(n = strndup(l+1, k-2)))
                         return -ENOMEM;
 
-                if (sections && !strv_contains((char**) sections, n)) {
-                        log_error("[%s:%u] Unknown section '%s'.", filename, line, n);
-                        free(n);
-                        return -EBADMSG;
-                }
+                if (!relaxed && sections && !strv_contains((char**) sections, n))
+                        log_info("[%s:%u] Unknown section '%s'. Ignoring.", filename, line, n);
 
                 free(*section);
                 *section = n;
@@ -122,6 +123,9 @@ static int parse_line(const char *filename, unsigned line, char **section, const
                 return 0;
         }
 
+        if (sections && !strv_contains((char**) sections, *section))
+                return 0;
+
         if (!(e = strchr(l, '='))) {
                 log_error("[%s:%u] Missing '='.", filename, line);
                 return -EBADMSG;
@@ -130,11 +134,11 @@ static int parse_line(const char *filename, unsigned line, char **section, const
         *e = 0;
         e++;
 
-        return next_assignment(filename, line, *section, t, strstrip(l), strstrip(e), userdata);
+        return next_assignment(filename, line, *section, t, relaxed, strstrip(l), strstrip(e), userdata);
 }
 
 /* Go through the file and parse each line */
-int config_parse(const char *filename, FILE *f, const char* const * sections, const ConfigItem *t, void *userdata) {
+int config_parse(const char *filename, FILE *f, const char* const * sections, const ConfigItem *t, bool relaxed, void *userdata) {
         unsigned line = 0;
         char *section = NULL;
         int r;
@@ -165,7 +169,7 @@ int config_parse(const char *filename, FILE *f, const char* const * sections, co
                         goto finish;
                 }
 
-                if ((r = parse_line(filename, ++line, &section, sections, t, l, userdata)) < 0)
+                if ((r = parse_line(filename, ++line, &section, sections, t, relaxed, l, userdata)) < 0)
                         goto finish;
         }
 
diff --git a/src/conf-parser.h b/src/conf-parser.h
index bea2a8e9be..b3b2915d41 100644
--- a/src/conf-parser.h
+++ b/src/conf-parser.h
@@ -23,6 +23,7 @@
 ***/
 
 #include <stdio.h>
+#include <stdbool.h>
 
 /* An abstract parser for simple, line based, shallow configuration
  * files consisting of variable assignments only. */
@@ -40,7 +41,7 @@ typedef struct ConfigItem {
 /* The configuration file parsing routine. Expects a table of
  * config_items in *t that is terminated by an item where lvalue is
  * NULL */
-int config_parse(const char *filename, FILE *f, const char* const * sections, const ConfigItem *t, void *userdata);
+int config_parse(const char *filename, FILE *f, const char* const *sections, const ConfigItem *t, bool relaxed, void *userdata);
 
 /* Generic parsers */
 int config_parse_int(const char *filename, unsigned line, const char *section, const char *lvalue, const char *rvalue, void *data, void *userdata);
diff --git a/src/install.c b/src/install.c
new file mode 100644
index 0000000000..e3db63769f
--- /dev/null
+++ b/src/install.c
@@ -0,0 +1,593 @@
+/*-*- Mode: C; c-basic-offset: 8 -*-*/
+
+/***
+  This file is part of systemd.
+
+  Copyright 2010 Lennart Poettering
+
+  systemd is free software; you can redistribute it and/or modify it
+  under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 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
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with systemd; If not, see <http://www.gnu.org/licenses/>.
+***/
+
+#include <sys/stat.h>
+#include <stdio.h>
+#include <getopt.h>
+#include <errno.h>
+#include <unistd.h>
+
+#include "log.h"
+#include "path-lookup.h"
+#include "util.h"
+#include "macro.h"
+#include "strv.h"
+#include "conf-parser.h"
+
+static bool arg_force = false;
+
+static enum {
+        WHERE_SYSTEM,
+        WHERE_SESSION,
+        WHERE_GLOBAL,
+} arg_where = WHERE_SYSTEM;
+
+static enum {
+        ACTION_INVALID,
+        ACTION_ENABLE,
+        ACTION_DISABLE,
+        ACTION_TEST
+} arg_action = ACTION_INVALID;
+
+typedef struct {
+        char *name;
+        char *path;
+
+        char **aliases;
+        char **wanted_by;
+} InstallInfo;
+
+Hashmap *will_install = NULL, *have_installed = NULL;
+
+static int help(void) {
+
+        printf("%s [options]\n\n"
+               "  -h --help        Show this help\n"
+               "     --force       Override existing links\n"
+               "     --system      Install into system\n"
+               "     --session     Install into session\n"
+               "     --global      Install into all sessions\n"
+               "Commands:\n"
+               "  enable [NAME...]    Enable one or more units\n"
+               "  disable [NAME...]   Disable one or more units\n"
+               "  test [NAME...]      Test whether any of the specified units are enabled\n",
+               __progname);
+
+        return 0;
+}
+
+static int parse_argv(int argc, char *argv[]) {
+
+        enum {
+                ARG_SESSION = 0x100,
+                ARG_SYSTEM,
+                ARG_GLOBAL,
+                ARG_FORCE
+        };
+
+        static const struct option options[] = {
+                { "help",      no_argument,       NULL, 'h'         },
+                { "session",   no_argument,       NULL, ARG_SESSION },
+                { "system",    no_argument,       NULL, ARG_SYSTEM  },
+                { "global",    no_argument,       NULL, ARG_GLOBAL  },
+                { "force",     no_argument,       NULL, ARG_FORCE   },
+                { NULL,        0,                 NULL, 0           }
+        };
+
+        int c;
+
+        assert(argc >= 1);
+        assert(argv);
+
+        while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0) {
+
+                switch (c) {
+
+                case 'h':
+                        help();
+                        return 0;
+
+                case ARG_SESSION:
+                        arg_where = WHERE_SESSION;
+                        break;
+
+                case ARG_SYSTEM:
+                        arg_where = WHERE_SYSTEM;
+                        break;
+
+                case ARG_GLOBAL:
+                        arg_where = WHERE_GLOBAL;
+                        break;
+
+                case ARG_FORCE:
+                        arg_force = true;
+                        break;
+
+                case '?':
+                        return -EINVAL;
+
+                default:
+                        log_error("Unknown option code %c", c);
+                        return -EINVAL;
+                }
+        }
+
+        if (optind >= argc) {
+                log_error("Missing verb.");
+                return -EINVAL;
+        }
+
+        if (streq(argv[optind], "enable"))
+                arg_action = ACTION_ENABLE;
+        else if (streq(argv[optind], "disable"))
+                arg_action = ACTION_DISABLE;
+        else if (streq(argv[optind], "test"))
+                arg_action = ACTION_TEST;
+        else {
+                log_error("Unknown verb %s", argv[optind]);
+                return -EINVAL;
+        }
+
+        optind++;
+
+        if (optind >= argc) {
+                log_error("Missing unit name.");
+                return -EINVAL;
+        }
+
+        return 1;
+}
+
+static void install_info_free(InstallInfo *i) {
+        assert(i);
+
+        free(i->name);
+        free(i->path);
+        strv_free(i->aliases);
+        strv_free(i->wanted_by);
+        free(i);
+}
+
+static void install_info_hashmap_free(Hashmap *m) {
+        InstallInfo *i;
+
+        while ((i = hashmap_steal_first(m)))
+                install_info_free(i);
+
+        hashmap_free(m);
+}
+
+static bool unit_name_valid(const char *name) {
+
+        /* This is a minimal version of unit_name_valid() from
+         * unit-name.c */
+
+        if (strchr(name, '/'))
+                return false;
+
+        if (!*name)
+                return false;
+
+        if (ignore_file(name))
+                return false;
+
+        return true;
+}
+
+static int install_info_add(const char *name) {
+        InstallInfo *i;
+        int r;
+
+        if (!unit_name_valid(name))
+                return -EINVAL;
+
+        if (hashmap_get(have_installed, name) ||
+            hashmap_get(will_install, name))
+                return 0;
+
+        if (!(i = new0(InstallInfo, 1))) {
+                r = -ENOMEM;
+                goto fail;
+        }
+
+        if (!(i->name = strdup(name))) {
+                r = -ENOMEM;
+                goto fail;
+        }
+
+        if ((r = hashmap_put(will_install, i->name, i)) < 0)
+                goto fail;
+
+        return 0;
+
+fail:
+        if (i)
+                install_info_free(i);
+
+        return r;
+}
+
+static int config_parse_also(
+                const char *filename,
+                unsigned line,
+                const char *section,
+                const char *lvalue,
+                const char *rvalue,
+                void *data,
+                void *userdata) {
+
+        char *w;
+        size_t l;
+        char *state;
+
+        assert(filename);
+        assert(lvalue);
+        assert(rvalue);
+
+        FOREACH_WORD_QUOTED(w, l, rvalue, state) {
+                char *n;
+                int r;
+
+                if (!(n = strndup(w, l)))
+                        return -ENOMEM;
+
+                r = install_info_add(n);
+                free(n);
+
+                if (r < 0)
+                        return r;
+        }
+
+        return 0;
+}
+
+static int create_symlink(const char *old_path, const char *new_path) {
+        int r;
+
+        assert(old_path);
+        assert(new_path);
+
+        if (arg_action == ACTION_ENABLE) {
+                char *dest;
+
+                mkdir_parents(new_path, 0755);
+
+                if (symlink(old_path, new_path) >= 0)
+                        return 0;
+
+                if (errno != EEXIST) {
+                        log_error("Cannot link %s to %s: %m", old_path, new_path);
+                        return -errno;
+                }
+
+                if ((r = readlink_and_make_absolute(new_path, &dest)) < 0) {
+
+                        if (errno == EINVAL) {
+                                log_error("Cannot link %s to %s, file exists already and is not a symlink.", old_path, new_path);
+                                return -EEXIST;
+                        }
+
+                        log_error("readlink() failed: %s", strerror(-r));
+                        return r;
+                }
+
+                if (streq(dest, old_path)) {
+                        free(dest);
+                        return 0;
+                }
+
+                if (!arg_force) {
+                        log_error("Cannot link %s to %s, symlink exists already and points to %s.", old_path, new_path, dest);
+                        free(dest);
+                        return -EEXIST;
+                }
+
+                free(dest);
+                unlink(new_path);
+
+                if (symlink(old_path, new_path) >= 0)
+                        return 0;
+
+                log_error("Cannot link %s to %s: %m", old_path, new_path);
+                return -errno;
+
+        } else if (arg_action == ACTION_DISABLE) {
+                char *dest;
+
+                if ((r = readlink_and_make_absolute(new_path, &dest)) < 0) {
+                        if (errno == ENOENT)
+                                return 0;
+
+                        if (errno == EINVAL) {
+                                log_warning("File %s not a symlink, ignoring.", old_path);
+                                return 0;
+                        }
+
+                        log_error("readlink() failed: %s", strerror(-r));
+                        return r;
+                }
+
+                if (!streq(dest, old_path)) {
+                        log_warning("File %s not a symlink to %s but points to %s, ignoring.", new_path, old_path, dest);
+                        free(dest);
+                        return 0;
+                }
+
+                free(dest);
+                if (unlink(new_path) >= 0)
+                        return 0;
+
+                log_error("Cannot unlink %s: %m", new_path);
+                return -errno;
+
+        } else if (arg_action == ACTION_TEST) {
+                char *dest;
+
+                if ((r = readlink_and_make_absolute(new_path, &dest)) < 0) {
+
+                        if (errno == ENOENT || errno == EINVAL)
+                                return 0;
+
+                        log_error("readlink() failed: %s", strerror(-r));
+                        return r;
+                }
+
+                if (streq(dest, old_path)) {
+                        free(dest);
+                        return 1;
+                }
+
+                return 0;
+        }
+
+        assert_not_reached("Unknown action.");
+}
+
+static int install_info_symlink_alias(InstallInfo *i, const char *config_path) {
+        char **s;
+        char *alias_path = NULL;
+        int r;
+
+        assert(i);
+
+        STRV_FOREACH(s, i->aliases) {
+
+                if (!unit_name_valid(*s)) {
+                        log_error("Invalid name %s.", *s);
+                        r = -EINVAL;
+                        goto finish;
+                }
+
+                free(alias_path);
+                if (!(alias_path = path_make_absolute(*s, config_path))) {
+                        log_error("Out of memory");
+                        r = -ENOMEM;
+                        goto finish;
+                }
+
+                if ((r = create_symlink(i->path, alias_path)) != 0)
+                        goto finish;
+        }
+
+        r = 0;
+
+finish:
+        free(alias_path);
+
+        return r;
+}
+
+static int install_info_symlink_wants(InstallInfo *i, const char *config_path) {
+        char **s;
+        char *alias_path = NULL;
+        int r;
+
+        assert(i);
+
+        STRV_FOREACH(s, i->wanted_by) {
+                if (!unit_name_valid(*s)) {
+                        log_error("Invalid name %s.", *s);
+                        r = -EINVAL;
+                        goto finish;
+                }
+
+                free(alias_path);
+                alias_path = NULL;
+
+                if (asprintf(&alias_path, "%s/%s.wants/%s", config_path, *s, i->name) < 0) {
+                        log_error("Out of memory");
+                        r = -ENOMEM;
+                        goto finish;
+                }
+
+                if ((r = create_symlink(i->path, alias_path)) != 0)
+                        goto finish;
+
+                if (arg_action == ACTION_DISABLE) {
+                        char *t;
+
+                        /* Try to remove .wants dir if we don't need it anymore */
+                        if (asprintf(&t, "%s/%s.wants", config_path, *s) >= 0) {
+                                rmdir(t);
+                                free(t);
+                        }
+                }
+        }
+
+        r = 0;
+
+finish:
+        free(alias_path);
+
+        return r;
+}
+
+static int install_info_apply(LookupPaths *paths, InstallInfo *i, const char *config_path) {
+
+        const ConfigItem items[] = {
+                { "Alias",    config_parse_strv, &i->aliases,   "Install" },
+                { "WantedBy", config_parse_strv, &i->wanted_by, "Install" },
+                { "Also",     config_parse_also, NULL,          "Install" },
+
+                { NULL, NULL, NULL, NULL }
+        };
+
+        char **p;
+        char *filename = NULL;
+        FILE *f = NULL;
+        int r;
+
+        assert(paths);
+        assert(i);
+
+        STRV_FOREACH(p, paths->unit_path) {
+
+                if (!(filename = path_make_absolute(i->name, *p))) {
+                        log_error("Out of memory");
+                        return -ENOMEM;
+                }
+
+                if ((f = fopen(filename, "re")))
+                        break;
+
+                free(filename);
+                filename = NULL;
+
+                if (errno != ENOENT) {
+                        log_error("Failed to open %s: %m", filename);
+                        return -errno;
+                }
+        }
+
+        if (!f) {
+                log_error("Couldn't find %s.", i->name);
+                return -ENOENT;
+        }
+
+        i->path = filename;
+
+        if ((r = config_parse(filename, f, NULL, items, true, i)) < 0) {
+                fclose(f);
+                return r;
+        }
+
+        fclose(f);
+
+        if ((r = install_info_symlink_alias(i, config_path)) != 0)
+                return r;
+
+        if ((r = install_info_symlink_wants(i, config_path)) != 0)
+                return r;
+
+        return 0;
+}
+
+static char *get_config_path(void) {
+
+        switch (arg_where) {
+
+        case WHERE_SYSTEM:
+                return strdup(SYSTEM_CONFIG_UNIT_PATH);
+
+        case WHERE_GLOBAL:
+                return strdup(SESSION_CONFIG_UNIT_PATH);
+
+        case WHERE_SESSION: {
+                char *p;
+
+                if (session_config_home(&p) < 0)
+                        return NULL;
+
+                return p;
+        }
+
+        default:
+                assert_not_reached("Unknown config path.");
+        }
+}
+
+int main(int argc, char *argv[]) {
+        int r, retval = 1, j;
+        LookupPaths paths;
+        InstallInfo *i;
+        char *config_path = NULL;
+
+        zero(paths);
+
+        log_set_target(LOG_TARGET_CONSOLE);
+        log_set_max_level(LOG_INFO);
+        log_parse_environment();
+
+        if ((r = parse_argv(argc, argv)) < 0)
+                goto finish;
+        else if (r == 0) {
+                retval = 0;
+                goto finish;
+        }
+
+        if ((r = lookup_paths_init(&paths, arg_where == WHERE_SYSTEM ? MANAGER_INIT : MANAGER_SESSION)) < 0) {
+                log_error("Failed to determine lookup paths: %s", strerror(-r));
+                goto finish;
+        }
+
+        if (!(config_path = get_config_path())) {
+                log_error("Failed to determine config path");
+                goto finish;
+        }
+
+        will_install = hashmap_new(string_hash_func, string_compare_func);
+        have_installed = hashmap_new(string_hash_func, string_compare_func);
+
+        if (!will_install || !have_installed) {
+                log_error("Failed to allocate unit sets.");
+                goto finish;
+        }
+
+        for (j = optind; j < argc; j++)
+                if ((r = install_info_add(argv[j])) < 0)
+                        goto finish;
+
+        while ((i = hashmap_first(will_install))) {
+                assert_se(hashmap_move_one(have_installed, will_install, i->name) == 0);
+
+                if ((r = install_info_apply(&paths, i, config_path)) != 0) {
+
+                        if (r < 0)
+                                goto finish;
+
+                        /* In test mode and found something */
+                        retval = 0;
+                        goto finish;
+                }
+        }
+
+        retval = arg_action == ACTION_TEST ? 1 : 0;
+
+finish:
+        install_info_hashmap_free(will_install);
+        install_info_hashmap_free(have_installed);
+
+        lookup_paths_free(&paths);
+
+        free(config_path);
+
+        return retval;
+}
diff --git a/src/load-fragment.c b/src/load-fragment.c
index 793c952594..cf1434eb1e 100644
--- a/src/load-fragment.c
+++ b/src/load-fragment.c
@@ -1471,12 +1471,17 @@ static int load_from_path(Unit *u, const char *path) {
                 { "DirectoryNotEmpty",      config_parse_path_spec,       &u->path,                                        "Path"    },
                 { "Unit",                   config_parse_path_unit,       &u->path,                                        "Path"    },
 
+                /* The [Install] section is ignored here. */
+                { "Alias",                  NULL,                         NULL,                                            "Install" },
+                { "WantedBy",               NULL,                         NULL,                                            "Install" },
+                { "Also",                   NULL,                         NULL,                                            "Install" },
+
                 { NULL, NULL, NULL, NULL }
         };
 
 #undef EXEC_CONTEXT_CONFIG_ITEMS
 
-        const char *sections[3];
+        const char *sections[4];
         int r;
         Set *symlink_names;
         FILE *f = NULL;
@@ -1494,7 +1499,8 @@ static int load_from_path(Unit *u, const char *path) {
 
         sections[0] = "Unit";
         sections[1] = section_table[u->meta.type];
-        sections[2] = NULL;
+        sections[2] = "Install";
+        sections[3] = NULL;
 
         if (!(symlink_names = set_new(string_hash_func, string_compare_func)))
                 return -ENOMEM;
@@ -1563,7 +1569,7 @@ static int load_from_path(Unit *u, const char *path) {
         }
 
         /* Now, parse the file contents */
-        if ((r = config_parse(filename, f, sections, items, u)) < 0)
+        if ((r = config_parse(filename, f, sections, items, false, u)) < 0)
                 goto finish;
 
         free(u->meta.fragment_path);
diff --git a/src/path-lookup.c b/src/path-lookup.c
index 1c4b5dc4e1..7a5b9b813e 100644
--- a/src/path-lookup.c
+++ b/src/path-lookup.c
@@ -30,6 +30,28 @@
 
 #include "path-lookup.h"
 
+int session_config_home(char **config_home) {
+        const char *e;
+
+        if ((e = getenv("XDG_CONFIG_HOME"))) {
+                if (asprintf(config_home, "%s/systemd/session", e) < 0)
+                        return -ENOMEM;
+
+                return 1;
+        } else {
+                const char *home;
+
+                if ((home = getenv("HOME"))) {
+                        if (asprintf(config_home, "%s/.config/systemd/session", home) < 0)
+                                return -ENOMEM;
+
+                        return 1;
+                }
+        }
+
+        return 0;
+}
+
 static char** session_dirs(void) {
         const char *home, *e;
         char *config_home = NULL, *data_home = NULL;
@@ -45,16 +67,10 @@ static char** session_dirs(void) {
          * as data, and allow overriding as configuration.
          */
 
-        home = getenv("HOME");
-
-        if ((e = getenv("XDG_CONFIG_HOME"))) {
-                if (asprintf(&config_home, "%s/systemd/session", e) < 0)
-                        goto fail;
+        if (session_config_home(&config_home) < 0)
+                goto fail;
 
-        } else if (home) {
-                if (asprintf(&config_home, "%s/.config/systemd/session", home) < 0)
-                        goto fail;
-        }
+        home = getenv("HOME");
 
         if ((e = getenv("XDG_CONFIG_DIRS")))
                 if (!(config_dirs = strv_split(e, ":")))
diff --git a/src/path-lookup.h b/src/path-lookup.h
index a04d5a0fab..e5a10925fd 100644
--- a/src/path-lookup.h
+++ b/src/path-lookup.h
@@ -30,6 +30,8 @@ typedef struct LookupPaths {
 
 #include "manager.h"
 
+int session_config_home(char **config_home);
+
 int lookup_paths_init(LookupPaths *p, ManagerRunningAs running_as);
 void lookup_paths_free(LookupPaths *p);
 
diff --git a/src/systemctl.c b/src/systemctl.c
index 4afe53e18d..663cb833bc 100644
--- a/src/systemctl.c
+++ b/src/systemctl.c
@@ -1437,6 +1437,7 @@ int main(int argc, char*argv[]) {
         dbus_error_init(&error);
 
         log_set_target(LOG_TARGET_CONSOLE);
+        log_set_max_level(LOG_INFO);
         log_parse_environment();
 
         if ((r = parse_argv(argc, argv)) < 0)