1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2011 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty <of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
32 #include "path-util.h"
33 #include "path-lookup.h"
35 #include "unit-name.h"
37 #include "conf-parser.h"
38 #include "conf-files.h"
39 #include "specifier.h"
40 #include "install-printf.h"
44 OrderedHashmap *will_install;
45 OrderedHashmap *have_installed;
48 static int in_search_path(const char *path, char **search) {
49 _cleanup_free_ char *parent = NULL;
54 r = path_get_parent(path, &parent);
58 return strv_contains(search, parent);
61 static int lookup_paths_init_from_scope(LookupPaths *paths,
63 const char *root_dir) {
66 assert(scope < _UNIT_FILE_SCOPE_MAX);
70 return lookup_paths_init(paths,
71 scope == UNIT_FILE_SYSTEM ? SYSTEMD_SYSTEM : SYSTEMD_USER,
72 scope == UNIT_FILE_USER,
77 static int get_config_path(UnitFileScope scope, bool runtime, const char *root_dir, char **ret) {
82 assert(scope < _UNIT_FILE_SCOPE_MAX);
87 case UNIT_FILE_SYSTEM:
90 p = path_join(root_dir, "/run/systemd/system", NULL);
92 p = path_join(root_dir, SYSTEM_CONFIG_UNIT_PATH, NULL);
95 case UNIT_FILE_GLOBAL:
101 p = strdup("/run/systemd/user");
103 p = strdup(USER_CONFIG_UNIT_PATH);
112 r = user_runtime_dir(&p);
114 r = user_config_home(&p);
117 return r < 0 ? r : -ENOENT;
122 assert_not_reached("Bad scope");
132 static int add_file_change(
133 UnitFileChange **changes,
135 UnitFileChangeType type,
137 const char *source) {
143 assert(!changes == !n_changes);
148 c = realloc(*changes, (*n_changes + 1) * sizeof(UnitFileChange));
156 c[i].path = strdup(path);
160 path_kill_slashes(c[i].path);
163 c[i].source = strdup(source);
169 path_kill_slashes(c[i].path);
177 static int mark_symlink_for_removal(
178 Set **remove_symlinks_to,
186 r = set_ensure_allocated(remove_symlinks_to, &string_hash_ops);
194 path_kill_slashes(n);
196 r = set_consume(*remove_symlinks_to, n);
198 return r == -EEXIST ? 0 : r;
203 static int remove_marked_symlinks_fd(
204 Set *remove_symlinks_to,
207 const char *config_path,
209 UnitFileChange **changes,
211 char** instance_whitelist) {
213 _cleanup_closedir_ DIR *d = NULL;
216 assert(remove_symlinks_to);
235 if (!de && errno != 0) {
243 if (ignore_file(de->d_name))
246 dirent_ensure_type(d, de);
248 if (de->d_type == DT_DIR) {
250 _cleanup_free_ char *p = NULL;
252 nfd = openat(fd, de->d_name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW);
262 p = path_make_absolute(de->d_name, path);
268 /* This will close nfd, regardless whether it succeeds or not */
269 q = remove_marked_symlinks_fd(remove_symlinks_to, nfd, p, config_path, deleted, changes, n_changes, instance_whitelist);
273 } else if (de->d_type == DT_LNK) {
274 _cleanup_free_ char *p = NULL, *dest = NULL;
278 if (!unit_name_is_valid(de->d_name, TEMPLATE_VALID))
281 if (unit_name_is_instance(de->d_name) &&
282 instance_whitelist &&
283 !strv_contains(instance_whitelist, de->d_name)) {
285 _cleanup_free_ char *w;
287 /* OK, the file is not listed directly
288 * in the whitelist, so let's check if
289 * the template of it might be
292 w = unit_name_template(de->d_name);
296 if (!strv_contains(instance_whitelist, w))
300 p = path_make_absolute(de->d_name, path);
304 q = readlink_and_canonicalize(p, &dest);
315 set_get(remove_symlinks_to, dest) ||
316 set_get(remove_symlinks_to, basename(dest));
321 if (unlink(p) < 0 && errno != ENOENT) {
327 path_kill_slashes(p);
328 rmdir_parents(p, config_path);
329 add_file_change(changes, n_changes, UNIT_FILE_UNLINK, p, NULL);
331 if (!set_get(remove_symlinks_to, p)) {
333 q = mark_symlink_for_removal(&remove_symlinks_to, p);
346 static int remove_marked_symlinks(
347 Set *remove_symlinks_to,
348 const char *config_path,
349 UnitFileChange **changes,
351 char** instance_whitelist) {
353 _cleanup_close_ int fd = -1;
359 if (set_size(remove_symlinks_to) <= 0)
362 fd = open(config_path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW);
370 cfd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
376 /* This takes possession of cfd and closes it */
377 q = remove_marked_symlinks_fd(remove_symlinks_to, cfd, config_path, config_path, &deleted, changes, n_changes, instance_whitelist);
385 static int find_symlinks_fd(
389 const char *config_path,
390 bool *same_name_link) {
393 _cleanup_closedir_ DIR *d = NULL;
399 assert(same_name_link);
412 if (!de && errno != 0)
418 if (ignore_file(de->d_name))
421 dirent_ensure_type(d, de);
423 if (de->d_type == DT_DIR) {
425 _cleanup_free_ char *p = NULL;
427 nfd = openat(fd, de->d_name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW);
437 p = path_make_absolute(de->d_name, path);
443 /* This will close nfd, regardless whether it succeeds or not */
444 q = find_symlinks_fd(name, nfd, p, config_path, same_name_link);
450 } else if (de->d_type == DT_LNK) {
451 _cleanup_free_ char *p = NULL, *dest = NULL;
452 bool found_path, found_dest, b = false;
455 /* Acquire symlink name */
456 p = path_make_absolute(de->d_name, path);
460 /* Acquire symlink destination */
461 q = readlink_and_canonicalize(p, &dest);
471 /* Check if the symlink itself matches what we
473 if (path_is_absolute(name))
474 found_path = path_equal(p, name);
476 found_path = streq(de->d_name, name);
478 /* Check if what the symlink points to
479 * matches what we are looking for */
480 if (path_is_absolute(name))
481 found_dest = path_equal(dest, name);
483 found_dest = streq(basename(dest), name);
485 if (found_path && found_dest) {
486 _cleanup_free_ char *t = NULL;
488 /* Filter out same name links in the main
490 t = path_make_absolute(name, config_path);
494 b = path_equal(t, p);
498 *same_name_link = true;
499 else if (found_path || found_dest)
505 static int find_symlinks(
507 const char *config_path,
508 bool *same_name_link) {
514 assert(same_name_link);
516 fd = open(config_path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW);
523 /* This takes possession of fd and closes it */
524 return find_symlinks_fd(name, fd, config_path, config_path, same_name_link);
527 static int find_symlinks_in_scope(
529 const char *root_dir,
531 UnitFileState *state) {
534 _cleanup_free_ char *path = NULL;
535 bool same_name_link_runtime = false, same_name_link = false;
538 assert(scope < _UNIT_FILE_SCOPE_MAX);
542 /* First look in runtime config path */
543 r = get_config_path(scope, true, root_dir, &path);
547 r = find_symlinks(name, path, &same_name_link_runtime);
551 *state = UNIT_FILE_ENABLED_RUNTIME;
555 /* Then look in the normal config path */
556 r = get_config_path(scope, false, root_dir, &path);
560 r = find_symlinks(name, path, &same_name_link);
564 *state = UNIT_FILE_ENABLED;
568 /* Hmm, we didn't find it, but maybe we found the same name
570 if (same_name_link_runtime) {
571 *state = UNIT_FILE_LINKED_RUNTIME;
573 } else if (same_name_link) {
574 *state = UNIT_FILE_LINKED;
584 const char *root_dir,
587 UnitFileChange **changes,
588 unsigned *n_changes) {
591 _cleanup_free_ char *prefix = NULL;
595 assert(scope < _UNIT_FILE_SCOPE_MAX);
597 r = get_config_path(scope, runtime, root_dir, &prefix);
601 STRV_FOREACH(i, files) {
602 _cleanup_free_ char *path = NULL;
604 if (!unit_name_is_valid(*i, TEMPLATE_VALID)) {
610 path = path_make_absolute(*i, prefix);
616 if (symlink("/dev/null", path) >= 0) {
617 add_file_change(changes, n_changes, UNIT_FILE_SYMLINK, path, "/dev/null");
621 if (errno == EEXIST) {
623 if (null_or_empty_path(path) > 0)
627 if (symlink_atomic("/dev/null", path) >= 0) {
628 add_file_change(changes, n_changes, UNIT_FILE_UNLINK, path, NULL);
629 add_file_change(changes, n_changes, UNIT_FILE_SYMLINK, path, "/dev/null");
645 int unit_file_unmask(
648 const char *root_dir,
650 UnitFileChange **changes,
651 unsigned *n_changes) {
653 char **i, *config_path = NULL;
655 Set *remove_symlinks_to = NULL;
658 assert(scope < _UNIT_FILE_SCOPE_MAX);
660 r = get_config_path(scope, runtime, root_dir, &config_path);
664 STRV_FOREACH(i, files) {
667 if (!unit_name_is_valid(*i, TEMPLATE_VALID)) {
673 path = path_make_absolute(*i, config_path);
679 q = null_or_empty_path(path);
681 if (unlink(path) >= 0) {
682 mark_symlink_for_removal(&remove_symlinks_to, path);
683 add_file_change(changes, n_changes, UNIT_FILE_UNLINK, path, NULL);
692 if (q != -ENOENT && r == 0)
700 q = remove_marked_symlinks(remove_symlinks_to, config_path, changes, n_changes, files);
704 set_free_free(remove_symlinks_to);
713 const char *root_dir,
716 UnitFileChange **changes,
717 unsigned *n_changes) {
719 _cleanup_lookup_paths_free_ LookupPaths paths = {};
721 _cleanup_free_ char *config_path = NULL;
725 assert(scope < _UNIT_FILE_SCOPE_MAX);
727 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
731 r = get_config_path(scope, runtime, root_dir, &config_path);
735 STRV_FOREACH(i, files) {
736 _cleanup_free_ char *path = NULL;
742 if (!path_is_absolute(*i) ||
743 !unit_name_is_valid(fn, TEMPLATE_VALID)) {
749 if (lstat(*i, &st) < 0) {
755 if (!S_ISREG(st.st_mode)) {
760 q = in_search_path(*i, paths.unit_path);
767 path = path_make_absolute(fn, config_path);
771 if (symlink(*i, path) >= 0) {
772 add_file_change(changes, n_changes, UNIT_FILE_SYMLINK, path, *i);
776 if (errno == EEXIST) {
777 _cleanup_free_ char *dest = NULL;
779 q = readlink_and_make_absolute(path, &dest);
780 if (q < 0 && errno != ENOENT) {
786 if (q >= 0 && path_equal(dest, *i))
790 if (symlink_atomic(*i, path) >= 0) {
791 add_file_change(changes, n_changes, UNIT_FILE_UNLINK, path, NULL);
792 add_file_change(changes, n_changes, UNIT_FILE_SYMLINK, path, *i);
808 void unit_file_list_free(Hashmap *h) {
811 while ((i = hashmap_steal_first(h))) {
819 void unit_file_changes_free(UnitFileChange *changes, unsigned n_changes) {
822 assert(changes || n_changes == 0);
827 for (i = 0; i < n_changes; i++) {
828 free(changes[i].path);
829 free(changes[i].source);
835 static void install_info_free(InstallInfo *i) {
840 strv_free(i->aliases);
841 strv_free(i->wanted_by);
842 strv_free(i->required_by);
844 free(i->default_instance);
848 static void install_info_hashmap_free(OrderedHashmap *m) {
854 while ((i = ordered_hashmap_steal_first(m)))
855 install_info_free(i);
857 ordered_hashmap_free(m);
860 static void install_context_done(InstallContext *c) {
863 install_info_hashmap_free(c->will_install);
864 install_info_hashmap_free(c->have_installed);
866 c->will_install = c->have_installed = NULL;
869 static int install_info_add(
873 InstallInfo *i = NULL;
877 assert(name || path);
880 name = basename(path);
882 if (!unit_name_is_valid(name, TEMPLATE_VALID))
885 if (ordered_hashmap_get(c->have_installed, name) ||
886 ordered_hashmap_get(c->will_install, name))
889 r = ordered_hashmap_ensure_allocated(&c->will_install, &string_hash_ops);
893 i = new0(InstallInfo, 1);
897 i->name = strdup(name);
904 i->path = strdup(path);
911 r = ordered_hashmap_put(c->will_install, i->name, i);
919 install_info_free(i);
924 static int install_info_add_auto(
926 const char *name_or_path) {
929 assert(name_or_path);
931 if (path_is_absolute(name_or_path))
932 return install_info_add(c, NULL, name_or_path);
934 return install_info_add(c, name_or_path, NULL);
937 static int config_parse_also(
939 const char *filename,
942 unsigned section_line,
950 const char *word, *state;
951 InstallContext *c = data;
952 InstallInfo *i = userdata;
958 FOREACH_WORD_QUOTED(word, l, rvalue, state) {
959 _cleanup_free_ char *n;
962 n = strndup(word, l);
966 r = install_info_add(c, n, NULL);
970 r = strv_extend(&i->also, n);
975 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
976 "Trailing garbage, ignoring.");
981 static int config_parse_user(
983 const char *filename,
986 unsigned section_line,
993 InstallInfo *i = data;
1001 r = install_full_printf(i, rvalue, &printed);
1011 static int config_parse_default_instance(
1013 const char *filename,
1015 const char *section,
1016 unsigned section_line,
1023 InstallInfo *i = data;
1031 r = install_full_printf(i, rvalue, &printed);
1035 if (!unit_instance_is_valid(printed)) {
1040 free(i->default_instance);
1041 i->default_instance = printed;
1046 static int unit_file_load(
1050 const char *root_dir,
1055 const ConfigTableItem items[] = {
1056 { "Install", "Alias", config_parse_strv, 0, &info->aliases },
1057 { "Install", "WantedBy", config_parse_strv, 0, &info->wanted_by },
1058 { "Install", "RequiredBy", config_parse_strv, 0, &info->required_by },
1059 { "Install", "DefaultInstance", config_parse_default_instance, 0, info },
1060 { "Install", "Also", config_parse_also, 0, c },
1061 { "Exec", "User", config_parse_user, 0, info },
1065 _cleanup_fclose_ FILE *f = NULL;
1072 if (!isempty(root_dir))
1073 path = strappenda(root_dir, "/", path);
1076 r = access(path, F_OK) ? -errno : 0;
1080 fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|(allow_symlink ? 0 : O_NOFOLLOW));
1084 f = fdopen(fd, "re");
1090 r = config_parse(NULL, path, f,
1092 config_item_table_lookup, items,
1093 true, true, false, info);
1098 *also = !strv_isempty(info->also);
1101 (int) strv_length(info->aliases) +
1102 (int) strv_length(info->wanted_by) +
1103 (int) strv_length(info->required_by);
1106 static int unit_file_search(
1110 const char *root_dir,
1123 return unit_file_load(c, info, info->path, root_dir, allow_symlink, load, also);
1127 STRV_FOREACH(p, paths->unit_path) {
1128 _cleanup_free_ char *path = NULL;
1130 path = strjoin(*p, "/", info->name, NULL);
1134 r = unit_file_load(c, info, path, root_dir, allow_symlink, load, also);
1140 if (r != -ENOENT && r != -ELOOP)
1144 if (unit_name_is_instance(info->name)) {
1146 /* Unit file doesn't exist, however instance
1147 * enablement was requested. We will check if it is
1148 * possible to load template unit file. */
1150 _cleanup_free_ char *template = NULL;
1152 template = unit_name_template(info->name);
1156 STRV_FOREACH(p, paths->unit_path) {
1157 _cleanup_free_ char *path = NULL;
1159 path = strjoin(*p, "/", template, NULL);
1163 r = unit_file_load(c, info, path, root_dir, allow_symlink, load, also);
1169 if (r != -ENOENT && r != -ELOOP)
1177 static int unit_file_can_install(
1179 const char *root_dir,
1184 _cleanup_(install_context_done) InstallContext c = {};
1191 r = install_info_add_auto(&c, name);
1195 assert_se(i = ordered_hashmap_first(c.will_install));
1197 r = unit_file_search(&c, i, paths, root_dir, allow_symlink, true, also);
1201 (int) strv_length(i->aliases) +
1202 (int) strv_length(i->wanted_by) +
1203 (int) strv_length(i->required_by);
1208 static int create_symlink(
1209 const char *old_path,
1210 const char *new_path,
1212 UnitFileChange **changes,
1213 unsigned *n_changes) {
1215 _cleanup_free_ char *dest = NULL;
1221 mkdir_parents_label(new_path, 0755);
1223 if (symlink(old_path, new_path) >= 0) {
1224 add_file_change(changes, n_changes, UNIT_FILE_SYMLINK, new_path, old_path);
1228 if (errno != EEXIST)
1231 r = readlink_and_make_absolute(new_path, &dest);
1235 if (path_equal(dest, old_path))
1241 r = symlink_atomic(old_path, new_path);
1245 add_file_change(changes, n_changes, UNIT_FILE_UNLINK, new_path, NULL);
1246 add_file_change(changes, n_changes, UNIT_FILE_SYMLINK, new_path, old_path);
1251 static int install_info_symlink_alias(
1253 const char *config_path,
1255 UnitFileChange **changes,
1256 unsigned *n_changes) {
1262 assert(config_path);
1264 STRV_FOREACH(s, i->aliases) {
1265 _cleanup_free_ char *alias_path = NULL, *dst = NULL;
1267 q = install_full_printf(i, *s, &dst);
1271 alias_path = path_make_absolute(dst, config_path);
1275 q = create_symlink(i->path, alias_path, force, changes, n_changes);
1283 static int install_info_symlink_wants(
1285 const char *config_path,
1289 UnitFileChange **changes,
1290 unsigned *n_changes) {
1292 _cleanup_free_ char *buf = NULL;
1298 assert(config_path);
1300 if (unit_name_is_template(i->name)) {
1302 /* Don't install any symlink if there's no default
1303 * instance configured */
1305 if (!i->default_instance)
1308 buf = unit_name_replace_instance(i->name, i->default_instance);
1316 STRV_FOREACH(s, list) {
1317 _cleanup_free_ char *path = NULL, *dst = NULL;
1319 q = install_full_printf(i, *s, &dst);
1323 if (!unit_name_is_valid(dst, TEMPLATE_VALID)) {
1328 path = strjoin(config_path, "/", dst, suffix, n, NULL);
1332 q = create_symlink(i->path, path, force, changes, n_changes);
1340 static int install_info_symlink_link(
1343 const char *config_path,
1344 const char *root_dir,
1346 UnitFileChange **changes,
1347 unsigned *n_changes) {
1349 _cleanup_free_ char *path = NULL;
1354 assert(config_path);
1357 r = in_search_path(i->path, paths->unit_path);
1361 path = strjoin(config_path, "/", i->name, NULL);
1365 return create_symlink(i->path, path, force, changes, n_changes);
1368 static int install_info_apply(
1371 const char *config_path,
1372 const char *root_dir,
1374 UnitFileChange **changes,
1375 unsigned *n_changes) {
1381 assert(config_path);
1383 r = install_info_symlink_alias(i, config_path, force, changes, n_changes);
1385 q = install_info_symlink_wants(i, config_path, i->wanted_by, ".wants/", force, changes, n_changes);
1389 q = install_info_symlink_wants(i, config_path, i->required_by, ".requires/", force, changes, n_changes);
1393 q = install_info_symlink_link(i, paths, config_path, root_dir, force, changes, n_changes);
1400 static int install_context_apply(
1403 const char *config_path,
1404 const char *root_dir,
1406 UnitFileChange **changes,
1407 unsigned *n_changes) {
1414 assert(config_path);
1416 if (!ordered_hashmap_isempty(c->will_install)) {
1417 r = ordered_hashmap_ensure_allocated(&c->have_installed, &string_hash_ops);
1421 r = ordered_hashmap_reserve(c->have_installed, ordered_hashmap_size(c->will_install));
1427 while ((i = ordered_hashmap_first(c->will_install))) {
1428 assert_se(ordered_hashmap_move_one(c->have_installed, c->will_install, i->name) == 0);
1430 q = unit_file_search(c, i, paths, root_dir, false, true, NULL);
1439 q = install_info_apply(i, paths, config_path, root_dir, force, changes, n_changes);
1440 if (r >= 0 && q < 0)
1447 static int install_context_mark_for_removal(
1450 Set **remove_symlinks_to,
1451 const char *config_path,
1452 const char *root_dir) {
1459 assert(config_path);
1461 /* Marks all items for removal */
1463 if (!ordered_hashmap_isempty(c->will_install)) {
1464 r = ordered_hashmap_ensure_allocated(&c->have_installed, &string_hash_ops);
1468 r = ordered_hashmap_reserve(c->have_installed, ordered_hashmap_size(c->will_install));
1474 while ((i = ordered_hashmap_first(c->will_install))) {
1475 assert_se(ordered_hashmap_move_one(c->have_installed, c->will_install, i->name) == 0);
1477 q = unit_file_search(c, i, paths, root_dir, false, true, NULL);
1488 if (unit_name_is_instance(i->name)) {
1492 unit_file = basename(i->path);
1494 if (unit_name_is_instance(unit_file))
1495 /* unit file named as instance exists, thus all symlinks
1496 * pointing to it will be removed */
1497 q = mark_symlink_for_removal(remove_symlinks_to, i->name);
1499 /* does not exist, thus we will mark for removal symlinks
1500 * to template unit file */
1501 q = mark_symlink_for_removal(remove_symlinks_to, unit_file);
1503 /* If i->path is not set, it means that we didn't actually find
1504 * the unit file. But we can still remove symlinks to the
1505 * nonexistent template. */
1506 unit_file = unit_name_template(i->name);
1510 q = mark_symlink_for_removal(remove_symlinks_to, unit_file);
1514 q = mark_symlink_for_removal(remove_symlinks_to, i->name);
1516 if (r >= 0 && q < 0)
1523 int unit_file_add_dependency(
1524 UnitFileScope scope,
1526 const char *root_dir,
1531 UnitFileChange **changes,
1532 unsigned *n_changes) {
1534 _cleanup_lookup_paths_free_ LookupPaths paths = {};
1535 _cleanup_(install_context_done) InstallContext c = {};
1536 _cleanup_free_ char *config_path = NULL;
1542 assert(scope < _UNIT_FILE_SCOPE_MAX);
1544 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1548 r = get_config_path(scope, runtime, root_dir, &config_path);
1552 STRV_FOREACH(i, files) {
1553 UnitFileState state;
1555 state = unit_file_get_state(scope, root_dir, *i);
1557 log_error_errno(state, "Failed to get unit file state for %s: %m", *i);
1561 if (state == UNIT_FILE_MASKED || state == UNIT_FILE_MASKED_RUNTIME) {
1562 log_error("Failed to enable unit: Unit %s is masked", *i);
1566 r = install_info_add_auto(&c, *i);
1571 if (!ordered_hashmap_isempty(c.will_install)) {
1572 r = ordered_hashmap_ensure_allocated(&c.have_installed, &string_hash_ops);
1576 r = ordered_hashmap_reserve(c.have_installed, ordered_hashmap_size(c.will_install));
1581 while ((info = ordered_hashmap_first(c.will_install))) {
1582 assert_se(ordered_hashmap_move_one(c.have_installed, c.will_install, info->name) == 0);
1584 r = unit_file_search(&c, info, &paths, root_dir, false, false, NULL);
1588 if (dep == UNIT_WANTS)
1589 r = strv_extend(&info->wanted_by, target);
1590 else if (dep == UNIT_REQUIRES)
1591 r = strv_extend(&info->required_by, target);
1598 r = install_info_apply(info, &paths, config_path, root_dir, force, changes, n_changes);
1606 int unit_file_enable(
1607 UnitFileScope scope,
1609 const char *root_dir,
1612 UnitFileChange **changes,
1613 unsigned *n_changes) {
1615 _cleanup_lookup_paths_free_ LookupPaths paths = {};
1616 _cleanup_(install_context_done) InstallContext c = {};
1618 _cleanup_free_ char *config_path = NULL;
1622 assert(scope < _UNIT_FILE_SCOPE_MAX);
1624 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1628 r = get_config_path(scope, runtime, root_dir, &config_path);
1632 STRV_FOREACH(i, files) {
1633 UnitFileState state;
1635 /* We only want to know if this unit is masked, so we ignore
1636 * errors from unit_file_get_state, deferring other checks.
1637 * This allows templated units to be enabled on the fly. */
1638 state = unit_file_get_state(scope, root_dir, *i);
1639 if (state == UNIT_FILE_MASKED || state == UNIT_FILE_MASKED_RUNTIME) {
1640 log_error("Failed to enable unit: Unit %s is masked", *i);
1644 r = install_info_add_auto(&c, *i);
1649 /* This will return the number of symlink rules that were
1650 supposed to be created, not the ones actually created. This is
1651 useful to determine whether the passed files had any
1652 installation data at all. */
1654 return install_context_apply(&c, &paths, config_path, root_dir, force, changes, n_changes);
1657 int unit_file_disable(
1658 UnitFileScope scope,
1660 const char *root_dir,
1662 UnitFileChange **changes,
1663 unsigned *n_changes) {
1665 _cleanup_lookup_paths_free_ LookupPaths paths = {};
1666 _cleanup_(install_context_done) InstallContext c = {};
1668 _cleanup_free_ char *config_path = NULL;
1669 _cleanup_set_free_free_ Set *remove_symlinks_to = NULL;
1673 assert(scope < _UNIT_FILE_SCOPE_MAX);
1675 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1679 r = get_config_path(scope, runtime, root_dir, &config_path);
1683 STRV_FOREACH(i, files) {
1684 r = install_info_add_auto(&c, *i);
1689 r = install_context_mark_for_removal(&c, &paths, &remove_symlinks_to, config_path, root_dir);
1691 q = remove_marked_symlinks(remove_symlinks_to, config_path, changes, n_changes, files);
1698 int unit_file_reenable(
1699 UnitFileScope scope,
1701 const char *root_dir,
1704 UnitFileChange **changes,
1705 unsigned *n_changes) {
1708 r = unit_file_disable(scope, runtime, root_dir, files,
1709 changes, n_changes);
1713 return unit_file_enable(scope, runtime, root_dir, files, force,
1714 changes, n_changes);
1717 int unit_file_set_default(
1718 UnitFileScope scope,
1719 const char *root_dir,
1722 UnitFileChange **changes,
1723 unsigned *n_changes) {
1725 _cleanup_lookup_paths_free_ LookupPaths paths = {};
1726 _cleanup_(install_context_done) InstallContext c = {};
1727 _cleanup_free_ char *config_path = NULL;
1730 InstallInfo *i = NULL;
1733 assert(scope < _UNIT_FILE_SCOPE_MAX);
1736 if (unit_name_to_type(file) != UNIT_TARGET)
1739 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1743 r = get_config_path(scope, false, root_dir, &config_path);
1747 r = install_info_add_auto(&c, file);
1751 assert_se(i = ordered_hashmap_first(c.will_install));
1753 r = unit_file_search(&c, i, &paths, root_dir, false, true, NULL);
1757 path = strappenda(config_path, "/" SPECIAL_DEFAULT_TARGET);
1759 r = create_symlink(i->path, path, force, changes, n_changes);
1766 int unit_file_get_default(
1767 UnitFileScope scope,
1768 const char *root_dir,
1771 _cleanup_lookup_paths_free_ LookupPaths paths = {};
1776 assert(scope < _UNIT_FILE_SCOPE_MAX);
1779 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1783 STRV_FOREACH(p, paths.unit_path) {
1784 _cleanup_free_ char *path = NULL, *tmp = NULL;
1787 path = path_join(root_dir, *p, SPECIAL_DEFAULT_TARGET);
1791 r = readlink_malloc(path, &tmp);
1794 else if (r == -EINVAL)
1796 n = strdup(SPECIAL_DEFAULT_TARGET);
1800 n = strdup(basename(tmp));
1812 UnitFileState unit_file_get_state(
1813 UnitFileScope scope,
1814 const char *root_dir,
1817 _cleanup_lookup_paths_free_ LookupPaths paths = {};
1818 UnitFileState state = _UNIT_FILE_STATE_INVALID;
1820 _cleanup_free_ char *path = NULL;
1824 assert(scope < _UNIT_FILE_SCOPE_MAX);
1827 if (root_dir && scope != UNIT_FILE_SYSTEM)
1830 if (!unit_name_is_valid(name, TEMPLATE_VALID))
1833 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1837 STRV_FOREACH(i, paths.unit_path) {
1845 path = path_join(root_dir, *i, name);
1850 partial = path + strlen(root_dir);
1855 * Search for a unit file in our default paths, to
1856 * be sure, that there are no broken symlinks.
1858 if (lstat(path, &st) < 0) {
1860 if (errno != ENOENT)
1863 if (!unit_name_is_instance(name))
1866 if (!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode))
1869 r = null_or_empty_path(path);
1870 if (r < 0 && r != -ENOENT)
1873 state = path_startswith(*i, "/run") ?
1874 UNIT_FILE_MASKED_RUNTIME : UNIT_FILE_MASKED;
1879 r = find_symlinks_in_scope(scope, root_dir, name, &state);
1885 r = unit_file_can_install(&paths, root_dir, partial, true, &also);
1886 if (r < 0 && errno != ENOENT)
1889 return UNIT_FILE_DISABLED;
1892 return UNIT_FILE_INDIRECT;
1893 return UNIT_FILE_STATIC;
1897 return r < 0 ? r : state;
1900 int unit_file_query_preset(UnitFileScope scope, const char *root_dir, const char *name) {
1901 _cleanup_strv_free_ char **files = NULL;
1906 assert(scope < _UNIT_FILE_SCOPE_MAX);
1909 if (scope == UNIT_FILE_SYSTEM)
1910 r = conf_files_list(&files, ".preset", root_dir,
1911 "/etc/systemd/system-preset",
1912 "/usr/local/lib/systemd/system-preset",
1913 "/usr/lib/systemd/system-preset",
1914 #ifdef HAVE_SPLIT_USR
1915 "/lib/systemd/system-preset",
1918 else if (scope == UNIT_FILE_GLOBAL)
1919 r = conf_files_list(&files, ".preset", root_dir,
1920 "/etc/systemd/user-preset",
1921 "/usr/local/lib/systemd/user-preset",
1922 "/usr/lib/systemd/user-preset",
1930 STRV_FOREACH(p, files) {
1931 _cleanup_fclose_ FILE *f;
1933 f = fopen(*p, "re");
1935 if (errno == ENOENT)
1942 char line[LINE_MAX], *l;
1944 if (!fgets(line, sizeof(line), f))
1951 if (strchr(COMMENTS "\n", *l))
1954 if (first_word(l, "enable")) {
1956 l += strspn(l, WHITESPACE);
1958 if (fnmatch(l, name, FNM_NOESCAPE) == 0) {
1959 log_debug("Preset file says enable %s.", name);
1963 } else if (first_word(l, "disable")) {
1965 l += strspn(l, WHITESPACE);
1967 if (fnmatch(l, name, FNM_NOESCAPE) == 0) {
1968 log_debug("Preset file says disable %s.", name);
1973 log_debug("Couldn't parse line '%s'", l);
1977 /* Default is "enable" */
1978 log_debug("Preset file doesn't say anything about %s, enabling.", name);
1982 int unit_file_preset(
1983 UnitFileScope scope,
1985 const char *root_dir,
1987 UnitFilePresetMode mode,
1989 UnitFileChange **changes,
1990 unsigned *n_changes) {
1992 _cleanup_(install_context_done) InstallContext plus = {}, minus = {};
1993 _cleanup_lookup_paths_free_ LookupPaths paths = {};
1994 _cleanup_free_ char *config_path = NULL;
1999 assert(scope < _UNIT_FILE_SCOPE_MAX);
2000 assert(mode < _UNIT_FILE_PRESET_MAX);
2002 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
2006 r = get_config_path(scope, runtime, root_dir, &config_path);
2010 STRV_FOREACH(i, files) {
2012 if (!unit_name_is_valid(*i, TEMPLATE_VALID))
2015 r = unit_file_query_preset(scope, root_dir, *i);
2019 if (r && mode != UNIT_FILE_PRESET_DISABLE_ONLY)
2020 r = install_info_add_auto(&plus, *i);
2021 else if (!r && mode != UNIT_FILE_PRESET_ENABLE_ONLY)
2022 r = install_info_add_auto(&minus, *i);
2031 if (mode != UNIT_FILE_PRESET_ENABLE_ONLY) {
2032 _cleanup_set_free_free_ Set *remove_symlinks_to = NULL;
2034 r = install_context_mark_for_removal(&minus, &paths, &remove_symlinks_to, config_path, root_dir);
2036 q = remove_marked_symlinks(remove_symlinks_to, config_path, changes, n_changes, files);
2041 if (mode != UNIT_FILE_PRESET_DISABLE_ONLY) {
2042 /* Returns number of symlinks that where supposed to be installed. */
2043 q = install_context_apply(&plus, &paths, config_path, root_dir, force, changes, n_changes);
2051 int unit_file_preset_all(
2052 UnitFileScope scope,
2054 const char *root_dir,
2055 UnitFilePresetMode mode,
2057 UnitFileChange **changes,
2058 unsigned *n_changes) {
2060 _cleanup_(install_context_done) InstallContext plus = {}, minus = {};
2061 _cleanup_lookup_paths_free_ LookupPaths paths = {};
2062 _cleanup_free_ char *config_path = NULL;
2067 assert(scope < _UNIT_FILE_SCOPE_MAX);
2068 assert(mode < _UNIT_FILE_PRESET_MAX);
2070 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
2074 r = get_config_path(scope, runtime, root_dir, &config_path);
2078 STRV_FOREACH(i, paths.unit_path) {
2079 _cleanup_closedir_ DIR *d = NULL;
2080 _cleanup_free_ char *units_dir;
2082 units_dir = path_join(root_dir, *i, NULL);
2086 d = opendir(units_dir);
2088 if (errno == ENOENT)
2099 if (!de && errno != 0)
2105 if (ignore_file(de->d_name))
2108 if (!unit_name_is_valid(de->d_name, TEMPLATE_VALID))
2111 dirent_ensure_type(d, de);
2113 if (de->d_type != DT_REG)
2116 r = unit_file_query_preset(scope, root_dir, de->d_name);
2120 if (r && mode != UNIT_FILE_PRESET_DISABLE_ONLY)
2121 r = install_info_add_auto(&plus, de->d_name);
2122 else if (!r && mode != UNIT_FILE_PRESET_ENABLE_ONLY)
2123 r = install_info_add_auto(&minus, de->d_name);
2133 if (mode != UNIT_FILE_PRESET_ENABLE_ONLY) {
2134 _cleanup_set_free_free_ Set *remove_symlinks_to = NULL;
2136 r = install_context_mark_for_removal(&minus, &paths, &remove_symlinks_to, config_path, root_dir);
2138 q = remove_marked_symlinks(remove_symlinks_to, config_path, changes, n_changes, NULL);
2143 if (mode != UNIT_FILE_PRESET_DISABLE_ONLY) {
2144 q = install_context_apply(&plus, &paths, config_path, root_dir, force, changes, n_changes);
2152 static void unit_file_list_free_one(UnitFileList *f) {
2160 DEFINE_TRIVIAL_CLEANUP_FUNC(UnitFileList*, unit_file_list_free_one);
2162 int unit_file_get_list(
2163 UnitFileScope scope,
2164 const char *root_dir,
2167 _cleanup_lookup_paths_free_ LookupPaths paths = {};
2172 assert(scope < _UNIT_FILE_SCOPE_MAX);
2175 if (root_dir && scope != UNIT_FILE_SYSTEM)
2179 r = access(root_dir, F_OK);
2184 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
2188 STRV_FOREACH(i, paths.unit_path) {
2189 _cleanup_closedir_ DIR *d = NULL;
2190 _cleanup_free_ char *units_dir;
2192 units_dir = path_join(root_dir, *i, NULL);
2196 d = opendir(units_dir);
2198 if (errno == ENOENT)
2205 _cleanup_(unit_file_list_free_onep) UnitFileList *f = NULL;
2207 _cleanup_free_ char *path = NULL;
2211 if (!de && errno != 0)
2217 if (ignore_file(de->d_name))
2220 if (!unit_name_is_valid(de->d_name, TEMPLATE_VALID))
2223 if (hashmap_get(h, de->d_name))
2226 dirent_ensure_type(d, de);
2228 if (!IN_SET(de->d_type, DT_LNK, DT_REG))
2231 f = new0(UnitFileList, 1);
2235 f->path = path_make_absolute(de->d_name, units_dir);
2239 r = null_or_empty_path(f->path);
2240 if (r < 0 && r != -ENOENT)
2244 path_startswith(*i, "/run") ?
2245 UNIT_FILE_MASKED_RUNTIME : UNIT_FILE_MASKED;
2249 r = find_symlinks_in_scope(scope, root_dir, de->d_name, &f->state);
2253 f->state = UNIT_FILE_ENABLED;
2257 path = path_make_absolute(de->d_name, *i);
2261 r = unit_file_can_install(&paths, root_dir, path, true, NULL);
2262 if (r == -EINVAL || /* Invalid setting? */
2263 r == -EBADMSG || /* Invalid format? */
2264 r == -ENOENT /* Included file not found? */)
2265 f->state = UNIT_FILE_INVALID;
2269 f->state = UNIT_FILE_DISABLED;
2271 f->state = UNIT_FILE_STATIC;
2274 r = hashmap_put(h, basename(f->path), f);
2277 f = NULL; /* prevent cleanup */
2284 static const char* const unit_file_state_table[_UNIT_FILE_STATE_MAX] = {
2285 [UNIT_FILE_ENABLED] = "enabled",
2286 [UNIT_FILE_ENABLED_RUNTIME] = "enabled-runtime",
2287 [UNIT_FILE_LINKED] = "linked",
2288 [UNIT_FILE_LINKED_RUNTIME] = "linked-runtime",
2289 [UNIT_FILE_MASKED] = "masked",
2290 [UNIT_FILE_MASKED_RUNTIME] = "masked-runtime",
2291 [UNIT_FILE_STATIC] = "static",
2292 [UNIT_FILE_DISABLED] = "disabled",
2293 [UNIT_FILE_INDIRECT] = "indirect",
2294 [UNIT_FILE_INVALID] = "invalid",
2297 DEFINE_STRING_TABLE_LOOKUP(unit_file_state, UnitFileState);
2299 static const char* const unit_file_change_type_table[_UNIT_FILE_CHANGE_TYPE_MAX] = {
2300 [UNIT_FILE_SYMLINK] = "symlink",
2301 [UNIT_FILE_UNLINK] = "unlink",
2304 DEFINE_STRING_TABLE_LOOKUP(unit_file_change_type, UnitFileChangeType);
2306 static const char* const unit_file_preset_mode_table[_UNIT_FILE_PRESET_MAX] = {
2307 [UNIT_FILE_PRESET_FULL] = "full",
2308 [UNIT_FILE_PRESET_ENABLE_ONLY] = "enable-only",
2309 [UNIT_FILE_PRESET_DISABLE_ONLY] = "disable-only",
2312 DEFINE_STRING_TABLE_LOOKUP(unit_file_preset_mode, UnitFilePresetMode);