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 return log_error_errno(state, "Failed to get unit file state for %s: %m", *i);
1559 if (state == UNIT_FILE_MASKED || state == UNIT_FILE_MASKED_RUNTIME) {
1560 log_error("Failed to enable unit: Unit %s is masked", *i);
1564 r = install_info_add_auto(&c, *i);
1569 if (!ordered_hashmap_isempty(c.will_install)) {
1570 r = ordered_hashmap_ensure_allocated(&c.have_installed, &string_hash_ops);
1574 r = ordered_hashmap_reserve(c.have_installed, ordered_hashmap_size(c.will_install));
1579 while ((info = ordered_hashmap_first(c.will_install))) {
1580 assert_se(ordered_hashmap_move_one(c.have_installed, c.will_install, info->name) == 0);
1582 r = unit_file_search(&c, info, &paths, root_dir, false, false, NULL);
1586 if (dep == UNIT_WANTS)
1587 r = strv_extend(&info->wanted_by, target);
1588 else if (dep == UNIT_REQUIRES)
1589 r = strv_extend(&info->required_by, target);
1596 r = install_info_apply(info, &paths, config_path, root_dir, force, changes, n_changes);
1604 int unit_file_enable(
1605 UnitFileScope scope,
1607 const char *root_dir,
1610 UnitFileChange **changes,
1611 unsigned *n_changes) {
1613 _cleanup_lookup_paths_free_ LookupPaths paths = {};
1614 _cleanup_(install_context_done) InstallContext c = {};
1616 _cleanup_free_ char *config_path = NULL;
1620 assert(scope < _UNIT_FILE_SCOPE_MAX);
1622 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1626 r = get_config_path(scope, runtime, root_dir, &config_path);
1630 STRV_FOREACH(i, files) {
1631 UnitFileState state;
1633 /* We only want to know if this unit is masked, so we ignore
1634 * errors from unit_file_get_state, deferring other checks.
1635 * This allows templated units to be enabled on the fly. */
1636 state = unit_file_get_state(scope, root_dir, *i);
1637 if (state == UNIT_FILE_MASKED || state == UNIT_FILE_MASKED_RUNTIME) {
1638 log_error("Failed to enable unit: Unit %s is masked", *i);
1642 r = install_info_add_auto(&c, *i);
1647 /* This will return the number of symlink rules that were
1648 supposed to be created, not the ones actually created. This is
1649 useful to determine whether the passed files had any
1650 installation data at all. */
1652 return install_context_apply(&c, &paths, config_path, root_dir, force, changes, n_changes);
1655 int unit_file_disable(
1656 UnitFileScope scope,
1658 const char *root_dir,
1660 UnitFileChange **changes,
1661 unsigned *n_changes) {
1663 _cleanup_lookup_paths_free_ LookupPaths paths = {};
1664 _cleanup_(install_context_done) InstallContext c = {};
1666 _cleanup_free_ char *config_path = NULL;
1667 _cleanup_set_free_free_ Set *remove_symlinks_to = NULL;
1671 assert(scope < _UNIT_FILE_SCOPE_MAX);
1673 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1677 r = get_config_path(scope, runtime, root_dir, &config_path);
1681 STRV_FOREACH(i, files) {
1682 r = install_info_add_auto(&c, *i);
1687 r = install_context_mark_for_removal(&c, &paths, &remove_symlinks_to, config_path, root_dir);
1689 q = remove_marked_symlinks(remove_symlinks_to, config_path, changes, n_changes, files);
1696 int unit_file_reenable(
1697 UnitFileScope scope,
1699 const char *root_dir,
1702 UnitFileChange **changes,
1703 unsigned *n_changes) {
1706 r = unit_file_disable(scope, runtime, root_dir, files,
1707 changes, n_changes);
1711 return unit_file_enable(scope, runtime, root_dir, files, force,
1712 changes, n_changes);
1715 int unit_file_set_default(
1716 UnitFileScope scope,
1717 const char *root_dir,
1720 UnitFileChange **changes,
1721 unsigned *n_changes) {
1723 _cleanup_lookup_paths_free_ LookupPaths paths = {};
1724 _cleanup_(install_context_done) InstallContext c = {};
1725 _cleanup_free_ char *config_path = NULL;
1728 InstallInfo *i = NULL;
1731 assert(scope < _UNIT_FILE_SCOPE_MAX);
1734 if (unit_name_to_type(file) != UNIT_TARGET)
1737 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1741 r = get_config_path(scope, false, root_dir, &config_path);
1745 r = install_info_add_auto(&c, file);
1749 assert_se(i = ordered_hashmap_first(c.will_install));
1751 r = unit_file_search(&c, i, &paths, root_dir, false, true, NULL);
1755 path = strappenda(config_path, "/" SPECIAL_DEFAULT_TARGET);
1757 r = create_symlink(i->path, path, force, changes, n_changes);
1764 int unit_file_get_default(
1765 UnitFileScope scope,
1766 const char *root_dir,
1769 _cleanup_lookup_paths_free_ LookupPaths paths = {};
1774 assert(scope < _UNIT_FILE_SCOPE_MAX);
1777 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1781 STRV_FOREACH(p, paths.unit_path) {
1782 _cleanup_free_ char *path = NULL, *tmp = NULL;
1785 path = path_join(root_dir, *p, SPECIAL_DEFAULT_TARGET);
1789 r = readlink_malloc(path, &tmp);
1792 else if (r == -EINVAL)
1794 n = strdup(SPECIAL_DEFAULT_TARGET);
1798 n = strdup(basename(tmp));
1810 UnitFileState unit_file_get_state(
1811 UnitFileScope scope,
1812 const char *root_dir,
1815 _cleanup_lookup_paths_free_ LookupPaths paths = {};
1816 UnitFileState state = _UNIT_FILE_STATE_INVALID;
1818 _cleanup_free_ char *path = NULL;
1822 assert(scope < _UNIT_FILE_SCOPE_MAX);
1825 if (root_dir && scope != UNIT_FILE_SYSTEM)
1828 if (!unit_name_is_valid(name, TEMPLATE_VALID))
1831 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1835 STRV_FOREACH(i, paths.unit_path) {
1843 path = path_join(root_dir, *i, name);
1848 partial = path + strlen(root_dir);
1853 * Search for a unit file in our default paths, to
1854 * be sure, that there are no broken symlinks.
1856 if (lstat(path, &st) < 0) {
1858 if (errno != ENOENT)
1861 if (!unit_name_is_instance(name))
1864 if (!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode))
1867 r = null_or_empty_path(path);
1868 if (r < 0 && r != -ENOENT)
1871 state = path_startswith(*i, "/run") ?
1872 UNIT_FILE_MASKED_RUNTIME : UNIT_FILE_MASKED;
1877 r = find_symlinks_in_scope(scope, root_dir, name, &state);
1883 r = unit_file_can_install(&paths, root_dir, partial, true, &also);
1884 if (r < 0 && errno != ENOENT)
1887 return UNIT_FILE_DISABLED;
1890 return UNIT_FILE_INDIRECT;
1891 return UNIT_FILE_STATIC;
1895 return r < 0 ? r : state;
1898 int unit_file_query_preset(UnitFileScope scope, const char *root_dir, const char *name) {
1899 _cleanup_strv_free_ char **files = NULL;
1904 assert(scope < _UNIT_FILE_SCOPE_MAX);
1907 if (scope == UNIT_FILE_SYSTEM)
1908 r = conf_files_list(&files, ".preset", root_dir,
1909 "/etc/systemd/system-preset",
1910 "/usr/local/lib/systemd/system-preset",
1911 "/usr/lib/systemd/system-preset",
1912 #ifdef HAVE_SPLIT_USR
1913 "/lib/systemd/system-preset",
1916 else if (scope == UNIT_FILE_GLOBAL)
1917 r = conf_files_list(&files, ".preset", root_dir,
1918 "/etc/systemd/user-preset",
1919 "/usr/local/lib/systemd/user-preset",
1920 "/usr/lib/systemd/user-preset",
1928 STRV_FOREACH(p, files) {
1929 _cleanup_fclose_ FILE *f;
1931 f = fopen(*p, "re");
1933 if (errno == ENOENT)
1940 char line[LINE_MAX], *l;
1942 if (!fgets(line, sizeof(line), f))
1949 if (strchr(COMMENTS "\n", *l))
1952 if (first_word(l, "enable")) {
1954 l += strspn(l, WHITESPACE);
1956 if (fnmatch(l, name, FNM_NOESCAPE) == 0) {
1957 log_debug("Preset file says enable %s.", name);
1961 } else if (first_word(l, "disable")) {
1963 l += strspn(l, WHITESPACE);
1965 if (fnmatch(l, name, FNM_NOESCAPE) == 0) {
1966 log_debug("Preset file says disable %s.", name);
1971 log_debug("Couldn't parse line '%s'", l);
1975 /* Default is "enable" */
1976 log_debug("Preset file doesn't say anything about %s, enabling.", name);
1980 int unit_file_preset(
1981 UnitFileScope scope,
1983 const char *root_dir,
1985 UnitFilePresetMode mode,
1987 UnitFileChange **changes,
1988 unsigned *n_changes) {
1990 _cleanup_(install_context_done) InstallContext plus = {}, minus = {};
1991 _cleanup_lookup_paths_free_ LookupPaths paths = {};
1992 _cleanup_free_ char *config_path = NULL;
1997 assert(scope < _UNIT_FILE_SCOPE_MAX);
1998 assert(mode < _UNIT_FILE_PRESET_MAX);
2000 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
2004 r = get_config_path(scope, runtime, root_dir, &config_path);
2008 STRV_FOREACH(i, files) {
2010 if (!unit_name_is_valid(*i, TEMPLATE_VALID))
2013 r = unit_file_query_preset(scope, root_dir, *i);
2017 if (r && mode != UNIT_FILE_PRESET_DISABLE_ONLY)
2018 r = install_info_add_auto(&plus, *i);
2019 else if (!r && mode != UNIT_FILE_PRESET_ENABLE_ONLY)
2020 r = install_info_add_auto(&minus, *i);
2029 if (mode != UNIT_FILE_PRESET_ENABLE_ONLY) {
2030 _cleanup_set_free_free_ Set *remove_symlinks_to = NULL;
2032 r = install_context_mark_for_removal(&minus, &paths, &remove_symlinks_to, config_path, root_dir);
2034 q = remove_marked_symlinks(remove_symlinks_to, config_path, changes, n_changes, files);
2039 if (mode != UNIT_FILE_PRESET_DISABLE_ONLY) {
2040 /* Returns number of symlinks that where supposed to be installed. */
2041 q = install_context_apply(&plus, &paths, config_path, root_dir, force, changes, n_changes);
2049 int unit_file_preset_all(
2050 UnitFileScope scope,
2052 const char *root_dir,
2053 UnitFilePresetMode mode,
2055 UnitFileChange **changes,
2056 unsigned *n_changes) {
2058 _cleanup_(install_context_done) InstallContext plus = {}, minus = {};
2059 _cleanup_lookup_paths_free_ LookupPaths paths = {};
2060 _cleanup_free_ char *config_path = NULL;
2065 assert(scope < _UNIT_FILE_SCOPE_MAX);
2066 assert(mode < _UNIT_FILE_PRESET_MAX);
2068 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
2072 r = get_config_path(scope, runtime, root_dir, &config_path);
2076 STRV_FOREACH(i, paths.unit_path) {
2077 _cleanup_closedir_ DIR *d = NULL;
2078 _cleanup_free_ char *units_dir;
2080 units_dir = path_join(root_dir, *i, NULL);
2084 d = opendir(units_dir);
2086 if (errno == ENOENT)
2097 if (!de && errno != 0)
2103 if (ignore_file(de->d_name))
2106 if (!unit_name_is_valid(de->d_name, TEMPLATE_VALID))
2109 dirent_ensure_type(d, de);
2111 if (de->d_type != DT_REG)
2114 r = unit_file_query_preset(scope, root_dir, de->d_name);
2118 if (r && mode != UNIT_FILE_PRESET_DISABLE_ONLY)
2119 r = install_info_add_auto(&plus, de->d_name);
2120 else if (!r && mode != UNIT_FILE_PRESET_ENABLE_ONLY)
2121 r = install_info_add_auto(&minus, de->d_name);
2131 if (mode != UNIT_FILE_PRESET_ENABLE_ONLY) {
2132 _cleanup_set_free_free_ Set *remove_symlinks_to = NULL;
2134 r = install_context_mark_for_removal(&minus, &paths, &remove_symlinks_to, config_path, root_dir);
2136 q = remove_marked_symlinks(remove_symlinks_to, config_path, changes, n_changes, NULL);
2141 if (mode != UNIT_FILE_PRESET_DISABLE_ONLY) {
2142 q = install_context_apply(&plus, &paths, config_path, root_dir, force, changes, n_changes);
2150 static void unit_file_list_free_one(UnitFileList *f) {
2158 DEFINE_TRIVIAL_CLEANUP_FUNC(UnitFileList*, unit_file_list_free_one);
2160 int unit_file_get_list(
2161 UnitFileScope scope,
2162 const char *root_dir,
2165 _cleanup_lookup_paths_free_ LookupPaths paths = {};
2170 assert(scope < _UNIT_FILE_SCOPE_MAX);
2173 if (root_dir && scope != UNIT_FILE_SYSTEM)
2177 r = access(root_dir, F_OK);
2182 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
2186 STRV_FOREACH(i, paths.unit_path) {
2187 _cleanup_closedir_ DIR *d = NULL;
2188 _cleanup_free_ char *units_dir;
2190 units_dir = path_join(root_dir, *i, NULL);
2194 d = opendir(units_dir);
2196 if (errno == ENOENT)
2203 _cleanup_(unit_file_list_free_onep) UnitFileList *f = NULL;
2205 _cleanup_free_ char *path = NULL;
2209 if (!de && errno != 0)
2215 if (ignore_file(de->d_name))
2218 if (!unit_name_is_valid(de->d_name, TEMPLATE_VALID))
2221 if (hashmap_get(h, de->d_name))
2224 dirent_ensure_type(d, de);
2226 if (!IN_SET(de->d_type, DT_LNK, DT_REG))
2229 f = new0(UnitFileList, 1);
2233 f->path = path_make_absolute(de->d_name, units_dir);
2237 r = null_or_empty_path(f->path);
2238 if (r < 0 && r != -ENOENT)
2242 path_startswith(*i, "/run") ?
2243 UNIT_FILE_MASKED_RUNTIME : UNIT_FILE_MASKED;
2247 r = find_symlinks_in_scope(scope, root_dir, de->d_name, &f->state);
2251 f->state = UNIT_FILE_ENABLED;
2255 path = path_make_absolute(de->d_name, *i);
2259 r = unit_file_can_install(&paths, root_dir, path, true, NULL);
2260 if (r == -EINVAL || /* Invalid setting? */
2261 r == -EBADMSG || /* Invalid format? */
2262 r == -ENOENT /* Included file not found? */)
2263 f->state = UNIT_FILE_INVALID;
2267 f->state = UNIT_FILE_DISABLED;
2269 f->state = UNIT_FILE_STATIC;
2272 r = hashmap_put(h, basename(f->path), f);
2275 f = NULL; /* prevent cleanup */
2282 static const char* const unit_file_state_table[_UNIT_FILE_STATE_MAX] = {
2283 [UNIT_FILE_ENABLED] = "enabled",
2284 [UNIT_FILE_ENABLED_RUNTIME] = "enabled-runtime",
2285 [UNIT_FILE_LINKED] = "linked",
2286 [UNIT_FILE_LINKED_RUNTIME] = "linked-runtime",
2287 [UNIT_FILE_MASKED] = "masked",
2288 [UNIT_FILE_MASKED_RUNTIME] = "masked-runtime",
2289 [UNIT_FILE_STATIC] = "static",
2290 [UNIT_FILE_DISABLED] = "disabled",
2291 [UNIT_FILE_INDIRECT] = "indirect",
2292 [UNIT_FILE_INVALID] = "invalid",
2295 DEFINE_STRING_TABLE_LOOKUP(unit_file_state, UnitFileState);
2297 static const char* const unit_file_change_type_table[_UNIT_FILE_CHANGE_TYPE_MAX] = {
2298 [UNIT_FILE_SYMLINK] = "symlink",
2299 [UNIT_FILE_UNLINK] = "unlink",
2302 DEFINE_STRING_TABLE_LOOKUP(unit_file_change_type, UnitFileChangeType);
2304 static const char* const unit_file_preset_mode_table[_UNIT_FILE_PRESET_MAX] = {
2305 [UNIT_FILE_PRESET_FULL] = "full",
2306 [UNIT_FILE_PRESET_ENABLE_ONLY] = "enable-only",
2307 [UNIT_FILE_PRESET_DISABLE_ONLY] = "disable-only",
2310 DEFINE_STRING_TABLE_LOOKUP(unit_file_preset_mode, UnitFilePresetMode);