]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/shared/install.c
projects / thirdparty / systemd.git / blob
? search:


a2f84f893e43255f7ce674d2f6e09fc1a193eb9a
[thirdparty/systemd.git] / src / shared / install.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2011 Lennart Poettering
7
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.
12
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.
17
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/>.
20 ***/
21
22 #include <errno.h>
23 #include <fcntl.h>
24 #include <unistd.h>
25 #include <string.h>
26 #include <fnmatch.h>
27
28 #include "util.h"
29 #include "mkdir.h"
30 #include "hashmap.h"
31 #include "set.h"
32 #include "path-util.h"
33 #include "path-lookup.h"
34 #include "strv.h"
35 #include "unit-name.h"
36 #include "install.h"
37 #include "conf-parser.h"
38 #include "conf-files.h"
39 #include "specifier.h"
40 #include "install-printf.h"
41 #include "special.h"
42
43 typedef struct {
44 Hashmap *will_install;
45 Hashmap *have_installed;
46 } InstallContext;
47
48 #define _cleanup_install_context_done_ _cleanup_(install_context_done)
49
50 static int in_search_path(const char *path, char **search) {
51 _cleanup_free_ char *parent = NULL;
52 int r;
53
54 assert(path);
55
56 r = path_get_parent(path, &parent);
57 if (r < 0)
58 return r;
59
60 return strv_contains(search, parent);
61 }
62
63 static int lookup_paths_init_from_scope(LookupPaths *paths,
64 UnitFileScope scope,
65 const char *root_dir) {
66 assert(paths);
67 assert(scope >= 0);
68 assert(scope < _UNIT_FILE_SCOPE_MAX);
69
70 zero(*paths);
71
72 return lookup_paths_init(paths,
73 scope == UNIT_FILE_SYSTEM ? SYSTEMD_SYSTEM : SYSTEMD_USER,
74 scope == UNIT_FILE_USER,
75 root_dir,
76 NULL, NULL, NULL);
77 }
78
79 static int get_config_path(UnitFileScope scope, bool runtime, const char *root_dir, char **ret) {
80 char *p = NULL;
81 int r;
82
83 assert(scope >= 0);
84 assert(scope < _UNIT_FILE_SCOPE_MAX);
85 assert(ret);
86
87 switch (scope) {
88
89 case UNIT_FILE_SYSTEM:
90
91 if (root_dir && runtime)
92 asprintf(&p, "%s/run/systemd/system", root_dir);
93 else if (runtime)
94 p = strdup("/run/systemd/system");
95 else if (root_dir)
96 asprintf(&p, "%s/%s", root_dir, SYSTEM_CONFIG_UNIT_PATH);
97 else
98 p = strdup(SYSTEM_CONFIG_UNIT_PATH);
99
100 break;
101
102 case UNIT_FILE_GLOBAL:
103
104 if (root_dir)
105 return -EINVAL;
106
107 if (runtime)
108 p = strdup("/run/systemd/user");
109 else
110 p = strdup(USER_CONFIG_UNIT_PATH);
111 break;
112
113 case UNIT_FILE_USER:
114
115 if (root_dir || runtime)
116 return -EINVAL;
117
118 r = user_config_home(&p);
119 if (r <= 0)
120 return r < 0 ? r : -ENOENT;
121
122 break;
123
124 default:
125 assert_not_reached("Bad scope");
126 }
127
128 if (!p)
129 return -ENOMEM;
130
131 *ret = p;
132 return 0;
133 }
134
135 static int add_file_change(
136 UnitFileChange **changes,
137 unsigned *n_changes,
138 UnitFileChangeType type,
139 const char *path,
140 const char *source) {
141
142 UnitFileChange *c;
143 unsigned i;
144
145 assert(path);
146 assert(!changes == !n_changes);
147
148 if (!changes)
149 return 0;
150
151 c = realloc(*changes, (*n_changes + 1) * sizeof(UnitFileChange));
152 if (!c)
153 return -ENOMEM;
154
155 *changes = c;
156 i = *n_changes;
157
158 c[i].type = type;
159 c[i].path = strdup(path);
160 if (!c[i].path)
161 return -ENOMEM;
162
163 path_kill_slashes(c[i].path);
164
165 if (source) {
166 c[i].source = strdup(source);
167 if (!c[i].source) {
168 free(c[i].path);
169 return -ENOMEM;
170 }
171
172 path_kill_slashes(c[i].path);
173 } else
174 c[i].source = NULL;
175
176 *n_changes = i+1;
177 return 0;
178 }
179
180 static int mark_symlink_for_removal(
181 Set **remove_symlinks_to,
182 const char *p) {
183
184 char *n;
185 int r;
186
187 assert(p);
188
189 r = set_ensure_allocated(remove_symlinks_to, string_hash_func, string_compare_func);
190 if (r < 0)
191 return r;
192
193 n = strdup(p);
194 if (!n)
195 return -ENOMEM;
196
197 path_kill_slashes(n);
198
199 r = set_consume(*remove_symlinks_to, n);
200 if (r < 0)
201 return r == -EEXIST ? 0 : r;
202
203 return 0;
204 }
205
206 static int remove_marked_symlinks_fd(
207 Set *remove_symlinks_to,
208 int fd,
209 const char *path,
210 const char *config_path,
211 bool *deleted,
212 UnitFileChange **changes,
213 unsigned *n_changes,
214 char** instance_whitelist) {
215
216 _cleanup_closedir_ DIR *d = NULL;
217 int r = 0;
218
219 assert(remove_symlinks_to);
220 assert(fd >= 0);
221 assert(path);
222 assert(config_path);
223 assert(deleted);
224
225 d = fdopendir(fd);
226 if (!d) {
227 safe_close(fd);
228 return -errno;
229 }
230
231 rewinddir(d);
232
233 for (;;) {
234 struct dirent *de;
235
236 errno = 0;
237 de = readdir(d);
238 if (!de && errno != 0) {
239 r = -errno;
240 break;
241 }
242
243 if (!de)
244 break;
245
246 if (ignore_file(de->d_name))
247 continue;
248
249 dirent_ensure_type(d, de);
250
251 if (de->d_type == DT_DIR) {
252 int nfd, q;
253 _cleanup_free_ char *p = NULL;
254
255 nfd = openat(fd, de->d_name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW);
256 if (nfd < 0) {
257 if (errno == ENOENT)
258 continue;
259
260 if (r == 0)
261 r = -errno;
262 continue;
263 }
264
265 p = path_make_absolute(de->d_name, path);
266 if (!p) {
267 safe_close(nfd);
268 return -ENOMEM;
269 }
270
271 /* This will close nfd, regardless whether it succeeds or not */
272 q = remove_marked_symlinks_fd(remove_symlinks_to, nfd, p, config_path, deleted, changes, n_changes, instance_whitelist);
273 if (q < 0 && r == 0)
274 r = q;
275
276 } else if (de->d_type == DT_LNK) {
277 _cleanup_free_ char *p = NULL, *dest = NULL;
278 int q;
279 bool found;
280
281 if (!unit_name_is_valid(de->d_name, TEMPLATE_VALID))
282 continue;
283
284 if (unit_name_is_instance(de->d_name) &&
285 instance_whitelist &&
286 !strv_contains(instance_whitelist, de->d_name)) {
287
288 _cleanup_free_ char *w;
289
290 /* OK, the file is not listed directly
291 * in the whitelist, so let's check if
292 * the template of it might be
293 * listed. */
294
295 w = unit_name_template(de->d_name);
296 if (!w)
297 return -ENOMEM;
298
299 if (!strv_contains(instance_whitelist, w))
300 continue;
301 }
302
303 p = path_make_absolute(de->d_name, path);
304 if (!p)
305 return -ENOMEM;
306
307 q = readlink_and_canonicalize(p, &dest);
308 if (q < 0) {
309 if (q == -ENOENT)
310 continue;
311
312 if (r == 0)
313 r = q;
314 continue;
315 }
316
317 found =
318 set_get(remove_symlinks_to, dest) ||
319 set_get(remove_symlinks_to, basename(dest));
320
321 if (!found)
322 continue;
323
324 if (unlink(p) < 0 && errno != ENOENT) {
325 if (r == 0)
326 r = -errno;
327 continue;
328 }
329
330 path_kill_slashes(p);
331 rmdir_parents(p, config_path);
332 add_file_change(changes, n_changes, UNIT_FILE_UNLINK, p, NULL);
333
334 if (!set_get(remove_symlinks_to, p)) {
335
336 q = mark_symlink_for_removal(&remove_symlinks_to, p);
337 if (q < 0) {
338 if (r == 0)
339 r = q;
340 } else
341 *deleted = true;
342 }
343 }
344 }
345
346 return r;
347 }
348
349 static int remove_marked_symlinks(
350 Set *remove_symlinks_to,
351 const char *config_path,
352 UnitFileChange **changes,
353 unsigned *n_changes,
354 char** instance_whitelist) {
355
356 _cleanup_close_ int fd = -1;
357 int r = 0;
358 bool deleted;
359
360 assert(config_path);
361
362 if (set_size(remove_symlinks_to) <= 0)
363 return 0;
364
365 fd = open(config_path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW);
366 if (fd < 0)
367 return -errno;
368
369 do {
370 int q, cfd;
371 deleted = false;
372
373 cfd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
374 if (cfd < 0) {
375 r = -errno;
376 break;
377 }
378
379 /* This takes possession of cfd and closes it */
380 q = remove_marked_symlinks_fd(remove_symlinks_to, cfd, config_path, config_path, &deleted, changes, n_changes, instance_whitelist);
381 if (r == 0)
382 r = q;
383 } while (deleted);
384
385 return r;
386 }
387
388 static int find_symlinks_fd(
389 const char *name,
390 int fd,
391 const char *path,
392 const char *config_path,
393 bool *same_name_link) {
394
395 int r = 0;
396 _cleanup_closedir_ DIR *d = NULL;
397
398 assert(name);
399 assert(fd >= 0);
400 assert(path);
401 assert(config_path);
402 assert(same_name_link);
403
404 d = fdopendir(fd);
405 if (!d) {
406 safe_close(fd);
407 return -errno;
408 }
409
410 for (;;) {
411 struct dirent *de;
412
413 errno = 0;
414 de = readdir(d);
415 if (!de && errno != 0)
416 return -errno;
417
418 if (!de)
419 return r;
420
421 if (ignore_file(de->d_name))
422 continue;
423
424 dirent_ensure_type(d, de);
425
426 if (de->d_type == DT_DIR) {
427 int nfd, q;
428 _cleanup_free_ char *p = NULL;
429
430 nfd = openat(fd, de->d_name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW);
431 if (nfd < 0) {
432 if (errno == ENOENT)
433 continue;
434
435 if (r == 0)
436 r = -errno;
437 continue;
438 }
439
440 p = path_make_absolute(de->d_name, path);
441 if (!p) {
442 safe_close(nfd);
443 return -ENOMEM;
444 }
445
446 /* This will close nfd, regardless whether it succeeds or not */
447 q = find_symlinks_fd(name, nfd, p, config_path, same_name_link);
448 if (q > 0)
449 return 1;
450 if (r == 0)
451 r = q;
452
453 } else if (de->d_type == DT_LNK) {
454 _cleanup_free_ char *p = NULL, *dest = NULL;
455 bool found_path, found_dest, b = false;
456 int q;
457
458 /* Acquire symlink name */
459 p = path_make_absolute(de->d_name, path);
460 if (!p)
461 return -ENOMEM;
462
463 /* Acquire symlink destination */
464 q = readlink_and_canonicalize(p, &dest);
465 if (q < 0) {
466 if (q == -ENOENT)
467 continue;
468
469 if (r == 0)
470 r = q;
471 continue;
472 }
473
474 /* Check if the symlink itself matches what we
475 * are looking for */
476 if (path_is_absolute(name))
477 found_path = path_equal(p, name);
478 else
479 found_path = streq(de->d_name, name);
480
481 /* Check if what the symlink points to
482 * matches what we are looking for */
483 if (path_is_absolute(name))
484 found_dest = path_equal(dest, name);
485 else
486 found_dest = streq(basename(dest), name);
487
488 if (found_path && found_dest) {
489 _cleanup_free_ char *t = NULL;
490
491 /* Filter out same name links in the main
492 * config path */
493 t = path_make_absolute(name, config_path);
494 if (!t)
495 return -ENOMEM;
496
497 b = path_equal(t, p);
498 }
499
500 if (b)
501 *same_name_link = true;
502 else if (found_path || found_dest)
503 return 1;
504 }
505 }
506 }
507
508 static int find_symlinks(
509 const char *name,
510 const char *config_path,
511 bool *same_name_link) {
512
513 int fd;
514
515 assert(name);
516 assert(config_path);
517 assert(same_name_link);
518
519 fd = open(config_path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW);
520 if (fd < 0) {
521 if (errno == ENOENT)
522 return 0;
523 return -errno;
524 }
525
526 /* This takes possession of fd and closes it */
527 return find_symlinks_fd(name, fd, config_path, config_path, same_name_link);
528 }
529
530 static int find_symlinks_in_scope(
531 UnitFileScope scope,
532 const char *root_dir,
533 const char *name,
534 UnitFileState *state) {
535
536 int r;
537 _cleanup_free_ char *path2 = NULL;
538 bool same_name_link_runtime = false, same_name_link = false;
539
540 assert(scope >= 0);
541 assert(scope < _UNIT_FILE_SCOPE_MAX);
542 assert(name);
543
544 if (scope == UNIT_FILE_SYSTEM || scope == UNIT_FILE_GLOBAL) {
545 _cleanup_free_ char *path = NULL;
546
547 /* First look in runtime config path */
548 r = get_config_path(scope, true, root_dir, &path);
549 if (r < 0)
550 return r;
551
552 r = find_symlinks(name, path, &same_name_link_runtime);
553 if (r < 0)
554 return r;
555 else if (r > 0) {
556 *state = UNIT_FILE_ENABLED_RUNTIME;
557 return r;
558 }
559 }
560
561 /* Then look in the normal config path */
562 r = get_config_path(scope, false, root_dir, &path2);
563 if (r < 0)
564 return r;
565
566 r = find_symlinks(name, path2, &same_name_link);
567 if (r < 0)
568 return r;
569 else if (r > 0) {
570 *state = UNIT_FILE_ENABLED;
571 return r;
572 }
573
574 /* Hmm, we didn't find it, but maybe we found the same name
575 * link? */
576 if (same_name_link_runtime) {
577 *state = UNIT_FILE_LINKED_RUNTIME;
578 return 1;
579 } else if (same_name_link) {
580 *state = UNIT_FILE_LINKED;
581 return 1;
582 }
583
584 return 0;
585 }
586
587 int unit_file_mask(
588 UnitFileScope scope,
589 bool runtime,
590 const char *root_dir,
591 char **files,
592 bool force,
593 UnitFileChange **changes,
594 unsigned *n_changes) {
595
596 char **i;
597 _cleanup_free_ char *prefix = NULL;
598 int r;
599
600 assert(scope >= 0);
601 assert(scope < _UNIT_FILE_SCOPE_MAX);
602
603 r = get_config_path(scope, runtime, root_dir, &prefix);
604 if (r < 0)
605 return r;
606
607 STRV_FOREACH(i, files) {
608 _cleanup_free_ char *path = NULL;
609
610 if (!unit_name_is_valid(*i, TEMPLATE_VALID)) {
611 if (r == 0)
612 r = -EINVAL;
613 continue;
614 }
615
616 path = path_make_absolute(*i, prefix);
617 if (!path) {
618 r = -ENOMEM;
619 break;
620 }
621
622 if (symlink("/dev/null", path) >= 0) {
623 add_file_change(changes, n_changes, UNIT_FILE_SYMLINK, path, "/dev/null");
624 continue;
625 }
626
627 if (errno == EEXIST) {
628
629 if (null_or_empty_path(path) > 0)
630 continue;
631
632 if (force) {
633 if (symlink_atomic("/dev/null", path) >= 0) {
634 add_file_change(changes, n_changes, UNIT_FILE_UNLINK, path, NULL);
635 add_file_change(changes, n_changes, UNIT_FILE_SYMLINK, path, "/dev/null");
636 continue;
637 }
638 }
639
640 if (r == 0)
641 r = -EEXIST;
642 } else {
643 if (r == 0)
644 r = -errno;
645 }
646 }
647
648 return r;
649 }
650
651 int unit_file_unmask(
652 UnitFileScope scope,
653 bool runtime,
654 const char *root_dir,
655 char **files,
656 UnitFileChange **changes,
657 unsigned *n_changes) {
658
659 char **i, *config_path = NULL;
660 int r, q;
661 Set *remove_symlinks_to = NULL;
662
663 assert(scope >= 0);
664 assert(scope < _UNIT_FILE_SCOPE_MAX);
665
666 r = get_config_path(scope, runtime, root_dir, &config_path);
667 if (r < 0)
668 goto finish;
669
670 STRV_FOREACH(i, files) {
671 char *path;
672
673 if (!unit_name_is_valid(*i, TEMPLATE_VALID)) {
674 if (r == 0)
675 r = -EINVAL;
676 continue;
677 }
678
679 path = path_make_absolute(*i, config_path);
680 if (!path) {
681 r = -ENOMEM;
682 break;
683 }
684
685 q = null_or_empty_path(path);
686 if (q > 0) {
687 if (unlink(path) >= 0) {
688 mark_symlink_for_removal(&remove_symlinks_to, path);
689 add_file_change(changes, n_changes, UNIT_FILE_UNLINK, path, NULL);
690
691 free(path);
692 continue;
693 }
694
695 q = -errno;
696 }
697
698 if (q != -ENOENT && r == 0)
699 r = q;
700
701 free(path);
702 }
703
704
705 finish:
706 q = remove_marked_symlinks(remove_symlinks_to, config_path, changes, n_changes, files);
707 if (r == 0)
708 r = q;
709
710 set_free_free(remove_symlinks_to);
711 free(config_path);
712
713 return r;
714 }
715
716 int unit_file_link(
717 UnitFileScope scope,
718 bool runtime,
719 const char *root_dir,
720 char **files,
721 bool force,
722 UnitFileChange **changes,
723 unsigned *n_changes) {
724
725 _cleanup_lookup_paths_free_ LookupPaths paths = {};
726 char **i;
727 _cleanup_free_ char *config_path = NULL;
728 int r, q;
729
730 assert(scope >= 0);
731 assert(scope < _UNIT_FILE_SCOPE_MAX);
732
733 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
734 if (r < 0)
735 return r;
736
737 r = get_config_path(scope, runtime, root_dir, &config_path);
738 if (r < 0)
739 return r;
740
741 STRV_FOREACH(i, files) {
742 _cleanup_free_ char *path = NULL;
743 char *fn;
744 struct stat st;
745
746 fn = basename(*i);
747
748 if (!path_is_absolute(*i) ||
749 !unit_name_is_valid(fn, TEMPLATE_VALID)) {
750 if (r == 0)
751 r = -EINVAL;
752 continue;
753 }
754
755 if (lstat(*i, &st) < 0) {
756 if (r == 0)
757 r = -errno;
758 continue;
759 }
760
761 if (!S_ISREG(st.st_mode)) {
762 r = -ENOENT;
763 continue;
764 }
765
766 q = in_search_path(*i, paths.unit_path);
767 if (q < 0)
768 return q;
769
770 if (q > 0)
771 continue;
772
773 path = path_make_absolute(fn, config_path);
774 if (!path)
775 return -ENOMEM;
776
777 if (symlink(*i, path) >= 0) {
778 add_file_change(changes, n_changes, UNIT_FILE_SYMLINK, path, *i);
779 continue;
780 }
781
782 if (errno == EEXIST) {
783 _cleanup_free_ char *dest = NULL;
784
785 q = readlink_and_make_absolute(path, &dest);
786 if (q < 0 && errno != ENOENT) {
787 if (r == 0)
788 r = q;
789 continue;
790 }
791
792 if (q >= 0 && path_equal(dest, *i))
793 continue;
794
795 if (force) {
796 if (symlink_atomic(*i, path) >= 0) {
797 add_file_change(changes, n_changes, UNIT_FILE_UNLINK, path, NULL);
798 add_file_change(changes, n_changes, UNIT_FILE_SYMLINK, path, *i);
799 continue;
800 }
801 }
802
803 if (r == 0)
804 r = -EEXIST;
805 } else {
806 if (r == 0)
807 r = -errno;
808 }
809 }
810
811 return r;
812 }
813
814 void unit_file_list_free(Hashmap *h) {
815 UnitFileList *i;
816
817 while ((i = hashmap_steal_first(h))) {
818 free(i->path);
819 free(i);
820 }
821
822 hashmap_free(h);
823 }
824
825 void unit_file_changes_free(UnitFileChange *changes, unsigned n_changes) {
826 unsigned i;
827
828 assert(changes || n_changes == 0);
829
830 if (!changes)
831 return;
832
833 for (i = 0; i < n_changes; i++) {
834 free(changes[i].path);
835 free(changes[i].source);
836 }
837
838 free(changes);
839 }
840
841 static void install_info_free(InstallInfo *i) {
842 assert(i);
843
844 free(i->name);
845 free(i->path);
846 strv_free(i->aliases);
847 strv_free(i->wanted_by);
848 strv_free(i->required_by);
849 free(i->default_instance);
850 free(i);
851 }
852
853 static void install_info_hashmap_free(Hashmap *m) {
854 InstallInfo *i;
855
856 if (!m)
857 return;
858
859 while ((i = hashmap_steal_first(m)))
860 install_info_free(i);
861
862 hashmap_free(m);
863 }
864
865 static void install_context_done(InstallContext *c) {
866 assert(c);
867
868 install_info_hashmap_free(c->will_install);
869 install_info_hashmap_free(c->have_installed);
870
871 c->will_install = c->have_installed = NULL;
872 }
873
874 static int install_info_add(
875 InstallContext *c,
876 const char *name,
877 const char *path) {
878 InstallInfo *i = NULL;
879 int r;
880
881 assert(c);
882 assert(name || path);
883
884 if (!name)
885 name = basename(path);
886
887 if (!unit_name_is_valid(name, TEMPLATE_VALID))
888 return -EINVAL;
889
890 if (hashmap_get(c->have_installed, name) ||
891 hashmap_get(c->will_install, name))
892 return 0;
893
894 r = hashmap_ensure_allocated(&c->will_install, string_hash_func, string_compare_func);
895 if (r < 0)
896 return r;
897
898 i = new0(InstallInfo, 1);
899 if (!i)
900 return -ENOMEM;
901
902 i->name = strdup(name);
903 if (!i->name) {
904 r = -ENOMEM;
905 goto fail;
906 }
907
908 if (path) {
909 i->path = strdup(path);
910 if (!i->path) {
911 r = -ENOMEM;
912 goto fail;
913 }
914 }
915
916 r = hashmap_put(c->will_install, i->name, i);
917 if (r < 0)
918 goto fail;
919
920 return 0;
921
922 fail:
923 if (i)
924 install_info_free(i);
925
926 return r;
927 }
928
929 static int install_info_add_auto(
930 InstallContext *c,
931 const char *name_or_path) {
932
933 assert(c);
934 assert(name_or_path);
935
936 if (path_is_absolute(name_or_path))
937 return install_info_add(c, NULL, name_or_path);
938 else
939 return install_info_add(c, name_or_path, NULL);
940 }
941
942 static int config_parse_also(
943 const char *unit,
944 const char *filename,
945 unsigned line,
946 const char *section,
947 unsigned section_line,
948 const char *lvalue,
949 int ltype,
950 const char *rvalue,
951 void *data,
952 void *userdata) {
953
954 char *w;
955 size_t l;
956 char *state;
957 InstallContext *c = data;
958
959 assert(filename);
960 assert(lvalue);
961 assert(rvalue);
962
963 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
964 _cleanup_free_ char *n;
965 int r;
966
967 n = strndup(w, l);
968 if (!n)
969 return -ENOMEM;
970
971 r = install_info_add(c, n, NULL);
972 if (r < 0)
973 return r;
974 }
975
976 return 0;
977 }
978
979 static int config_parse_user(
980 const char *unit,
981 const char *filename,
982 unsigned line,
983 const char *section,
984 unsigned section_line,
985 const char *lvalue,
986 int ltype,
987 const char *rvalue,
988 void *data,
989 void *userdata) {
990
991 InstallInfo *i = data;
992 char *printed;
993 int r;
994
995 assert(filename);
996 assert(lvalue);
997 assert(rvalue);
998
999 r = install_full_printf(i, rvalue, &printed);
1000 if (r < 0)
1001 return r;
1002
1003 free(i->user);
1004 i->user = printed;
1005
1006 return 0;
1007 }
1008
1009 static int config_parse_default_instance(
1010 const char *unit,
1011 const char *filename,
1012 unsigned line,
1013 const char *section,
1014 unsigned section_line,
1015 const char *lvalue,
1016 int ltype,
1017 const char *rvalue,
1018 void *data,
1019 void *userdata) {
1020
1021 InstallInfo *i = data;
1022 char *printed;
1023 int r;
1024
1025 assert(filename);
1026 assert(lvalue);
1027 assert(rvalue);
1028
1029 r = install_full_printf(i, rvalue, &printed);
1030 if (r < 0)
1031 return r;
1032
1033 if (!unit_instance_is_valid(printed))
1034 return -EINVAL;
1035
1036 free(i->default_instance);
1037 i->default_instance = printed;
1038
1039 return 0;
1040 }
1041
1042 static int unit_file_load(
1043 InstallContext *c,
1044 InstallInfo *info,
1045 const char *path,
1046 const char *root_dir,
1047 bool allow_symlink) {
1048
1049 const ConfigTableItem items[] = {
1050 { "Install", "Alias", config_parse_strv, 0, &info->aliases },
1051 { "Install", "WantedBy", config_parse_strv, 0, &info->wanted_by },
1052 { "Install", "RequiredBy", config_parse_strv, 0, &info->required_by },
1053 { "Install", "DefaultInstance", config_parse_default_instance, 0, info },
1054 { "Install", "Also", config_parse_also, 0, c },
1055 { "Exec", "User", config_parse_user, 0, info },
1056 {}
1057 };
1058
1059 _cleanup_fclose_ FILE *f = NULL;
1060 int fd, r;
1061
1062 assert(c);
1063 assert(info);
1064 assert(path);
1065
1066 if (!isempty(root_dir))
1067 path = strappenda3(root_dir, "/", path);
1068
1069 fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|(allow_symlink ? 0 : O_NOFOLLOW));
1070 if (fd < 0)
1071 return -errno;
1072
1073 f = fdopen(fd, "re");
1074 if (!f) {
1075 safe_close(fd);
1076 return -ENOMEM;
1077 }
1078
1079 r = config_parse(NULL, path, f,
1080 NULL,
1081 config_item_table_lookup, items,
1082 true, true, false, info);
1083 if (r < 0)
1084 return r;
1085
1086 return
1087 (int) strv_length(info->aliases) +
1088 (int) strv_length(info->wanted_by) +
1089 (int) strv_length(info->required_by);
1090 }
1091
1092 static int unit_file_search(
1093 InstallContext *c,
1094 InstallInfo *info,
1095 LookupPaths *paths,
1096 const char *root_dir,
1097 bool allow_symlink) {
1098
1099 char **p;
1100 int r;
1101
1102 assert(c);
1103 assert(info);
1104 assert(paths);
1105
1106 if (info->path)
1107 return unit_file_load(c, info, info->path, root_dir, allow_symlink);
1108
1109 assert(info->name);
1110
1111 STRV_FOREACH(p, paths->unit_path) {
1112 _cleanup_free_ char *path = NULL;
1113
1114 path = strjoin(*p, "/", info->name, NULL);
1115 if (!path)
1116 return -ENOMEM;
1117
1118 r = unit_file_load(c, info, path, root_dir, allow_symlink);
1119 if (r >= 0) {
1120 info->path = path;
1121 path = NULL;
1122 return r;
1123 }
1124 if (r != -ENOENT && r != -ELOOP)
1125 return r;
1126 }
1127
1128 if (unit_name_is_instance(info->name)) {
1129
1130 /* Unit file doesn't exist, however instance
1131 * enablement was requested. We will check if it is
1132 * possible to load template unit file. */
1133
1134 _cleanup_free_ char *template = NULL;
1135
1136 template = unit_name_template(info->name);
1137 if (!template)
1138 return -ENOMEM;
1139
1140 STRV_FOREACH(p, paths->unit_path) {
1141 _cleanup_free_ char *path = NULL;
1142
1143 path = strjoin(*p, "/", template, NULL);
1144 if (!path)
1145 return -ENOMEM;
1146
1147 r = unit_file_load(c, info, path, root_dir, allow_symlink);
1148 if (r >= 0) {
1149 info->path = path;
1150 path = NULL;
1151 return r;
1152 }
1153 if (r != -ENOENT && r != -ELOOP)
1154 return r;
1155 }
1156 }
1157
1158 return -ENOENT;
1159 }
1160
1161 static int unit_file_can_install(
1162 LookupPaths *paths,
1163 const char *root_dir,
1164 const char *name,
1165 bool allow_symlink) {
1166
1167 _cleanup_install_context_done_ InstallContext c = {};
1168 InstallInfo *i;
1169 int r;
1170
1171 assert(paths);
1172 assert(name);
1173
1174 r = install_info_add_auto(&c, name);
1175 if (r < 0)
1176 return r;
1177
1178 assert_se(i = hashmap_first(c.will_install));
1179
1180 r = unit_file_search(&c, i, paths, root_dir, allow_symlink);
1181
1182 if (r >= 0)
1183 r =
1184 (int) strv_length(i->aliases) +
1185 (int) strv_length(i->wanted_by) +
1186 (int) strv_length(i->required_by);
1187
1188 return r;
1189 }
1190
1191 static int create_symlink(
1192 const char *old_path,
1193 const char *new_path,
1194 bool force,
1195 UnitFileChange **changes,
1196 unsigned *n_changes) {
1197
1198 _cleanup_free_ char *dest = NULL;
1199 int r;
1200
1201 assert(old_path);
1202 assert(new_path);
1203
1204 mkdir_parents_label(new_path, 0755);
1205
1206 if (symlink(old_path, new_path) >= 0) {
1207 add_file_change(changes, n_changes, UNIT_FILE_SYMLINK, new_path, old_path);
1208 return 0;
1209 }
1210
1211 if (errno != EEXIST)
1212 return -errno;
1213
1214 r = readlink_and_make_absolute(new_path, &dest);
1215 if (r < 0)
1216 return r;
1217
1218 if (path_equal(dest, old_path))
1219 return 0;
1220
1221 if (!force)
1222 return -EEXIST;
1223
1224 r = symlink_atomic(old_path, new_path);
1225 if (r < 0)
1226 return r;
1227
1228 add_file_change(changes, n_changes, UNIT_FILE_UNLINK, new_path, NULL);
1229 add_file_change(changes, n_changes, UNIT_FILE_SYMLINK, new_path, old_path);
1230
1231 return 0;
1232 }
1233
1234 static int install_info_symlink_alias(
1235 InstallInfo *i,
1236 const char *config_path,
1237 bool force,
1238 UnitFileChange **changes,
1239 unsigned *n_changes) {
1240
1241 char **s;
1242 int r = 0, q;
1243
1244 assert(i);
1245 assert(config_path);
1246
1247 STRV_FOREACH(s, i->aliases) {
1248 _cleanup_free_ char *alias_path = NULL, *dst = NULL;
1249
1250 q = install_full_printf(i, *s, &dst);
1251 if (q < 0)
1252 return q;
1253
1254 alias_path = path_make_absolute(dst, config_path);
1255 if (!alias_path)
1256 return -ENOMEM;
1257
1258 q = create_symlink(i->path, alias_path, force, changes, n_changes);
1259 if (r == 0)
1260 r = q;
1261 }
1262
1263 return r;
1264 }
1265
1266 static int install_info_symlink_wants(
1267 InstallInfo *i,
1268 const char *config_path,
1269 char **list,
1270 const char *suffix,
1271 bool force,
1272 UnitFileChange **changes,
1273 unsigned *n_changes) {
1274
1275 _cleanup_free_ char *buf = NULL;
1276 const char *n;
1277 char **s;
1278 int r = 0, q;
1279
1280 assert(i);
1281 assert(config_path);
1282
1283 if (unit_name_is_template(i->name)) {
1284
1285 /* Don't install any symlink if there's no default
1286 * instance configured */
1287
1288 if (!i->default_instance)
1289 return 0;
1290
1291 buf = unit_name_replace_instance(i->name, i->default_instance);
1292 if (!buf)
1293 return -ENOMEM;
1294
1295 n = buf;
1296 } else
1297 n = i->name;
1298
1299 STRV_FOREACH(s, list) {
1300 _cleanup_free_ char *path = NULL, *dst = NULL;
1301
1302 q = install_full_printf(i, *s, &dst);
1303 if (q < 0)
1304 return q;
1305
1306 if (!unit_name_is_valid(dst, TEMPLATE_VALID)) {
1307 r = -EINVAL;
1308 continue;
1309 }
1310
1311 path = strjoin(config_path, "/", dst, suffix, n, NULL);
1312 if (!path)
1313 return -ENOMEM;
1314
1315 q = create_symlink(i->path, path, force, changes, n_changes);
1316 if (r == 0)
1317 r = q;
1318 }
1319
1320 return r;
1321 }
1322
1323 static int install_info_symlink_link(
1324 InstallInfo *i,
1325 LookupPaths *paths,
1326 const char *config_path,
1327 const char *root_dir,
1328 bool force,
1329 UnitFileChange **changes,
1330 unsigned *n_changes) {
1331
1332 _cleanup_free_ char *path = NULL;
1333 int r;
1334
1335 assert(i);
1336 assert(paths);
1337 assert(config_path);
1338 assert(i->path);
1339
1340 r = in_search_path(i->path, paths->unit_path);
1341 if (r != 0)
1342 return r;
1343
1344 path = strjoin(config_path, "/", i->name, NULL);
1345 if (!path)
1346 return -ENOMEM;
1347
1348 return create_symlink(i->path, path, force, changes, n_changes);
1349 }
1350
1351 static int install_info_apply(
1352 InstallInfo *i,
1353 LookupPaths *paths,
1354 const char *config_path,
1355 const char *root_dir,
1356 bool force,
1357 UnitFileChange **changes,
1358 unsigned *n_changes) {
1359
1360 int r, q;
1361
1362 assert(i);
1363 assert(paths);
1364 assert(config_path);
1365
1366 r = install_info_symlink_alias(i, config_path, force, changes, n_changes);
1367
1368 q = install_info_symlink_wants(i, config_path, i->wanted_by, ".wants/", force, changes, n_changes);
1369 if (r == 0)
1370 r = q;
1371
1372 q = install_info_symlink_wants(i, config_path, i->required_by, ".requires/", force, changes, n_changes);
1373 if (r == 0)
1374 r = q;
1375
1376 q = install_info_symlink_link(i, paths, config_path, root_dir, force, changes, n_changes);
1377 if (r == 0)
1378 r = q;
1379
1380 return r;
1381 }
1382
1383 static int install_context_apply(
1384 InstallContext *c,
1385 LookupPaths *paths,
1386 const char *config_path,
1387 const char *root_dir,
1388 bool force,
1389 UnitFileChange **changes,
1390 unsigned *n_changes) {
1391
1392 InstallInfo *i;
1393 int r = 0, q;
1394
1395 assert(c);
1396 assert(paths);
1397 assert(config_path);
1398
1399 while ((i = hashmap_first(c->will_install))) {
1400
1401 q = hashmap_ensure_allocated(&c->have_installed, string_hash_func, string_compare_func);
1402 if (q < 0)
1403 return q;
1404
1405 assert_se(hashmap_move_one(c->have_installed, c->will_install, i->name) == 0);
1406
1407 q = unit_file_search(c, i, paths, root_dir, false);
1408 if (q < 0) {
1409 if (r >= 0)
1410 r = q;
1411
1412 return r;
1413 } else if (r >= 0)
1414 r += q;
1415
1416 q = install_info_apply(i, paths, config_path, root_dir, force, changes, n_changes);
1417 if (r >= 0 && q < 0)
1418 r = q;
1419 }
1420
1421 return r;
1422 }
1423
1424 static int install_context_mark_for_removal(
1425 InstallContext *c,
1426 LookupPaths *paths,
1427 Set **remove_symlinks_to,
1428 const char *config_path,
1429 const char *root_dir) {
1430
1431 InstallInfo *i;
1432 int r = 0, q;
1433
1434 assert(c);
1435 assert(paths);
1436 assert(config_path);
1437
1438 /* Marks all items for removal */
1439
1440 while ((i = hashmap_first(c->will_install))) {
1441
1442 q = hashmap_ensure_allocated(&c->have_installed, string_hash_func, string_compare_func);
1443 if (q < 0)
1444 return q;
1445
1446 assert_se(hashmap_move_one(c->have_installed, c->will_install, i->name) == 0);
1447
1448 q = unit_file_search(c, i, paths, root_dir, false);
1449 if (q == -ENOENT) {
1450 /* do nothing */
1451 } else if (q < 0) {
1452 if (r >= 0)
1453 r = q;
1454
1455 return r;
1456 } else if (r >= 0)
1457 r += q;
1458
1459 if (unit_name_is_instance(i->name)) {
1460 char *unit_file;
1461
1462 if (i->path) {
1463 unit_file = basename(i->path);
1464
1465 if (unit_name_is_instance(unit_file))
1466 /* unit file named as instance exists, thus all symlinks
1467 * pointing to it will be removed */
1468 q = mark_symlink_for_removal(remove_symlinks_to, i->name);
1469 else
1470 /* does not exist, thus we will mark for removal symlinks
1471 * to template unit file */
1472 q = mark_symlink_for_removal(remove_symlinks_to, unit_file);
1473 } else {
1474 /* If i->path is not set, it means that we didn't actually find
1475 * the unit file. But we can still remove symlinks to the
1476 * nonexistent template. */
1477 unit_file = unit_name_template(i->name);
1478 if (!unit_file)
1479 return log_oom();
1480
1481 q = mark_symlink_for_removal(remove_symlinks_to, unit_file);
1482 free(unit_file);
1483 }
1484 } else
1485 q = mark_symlink_for_removal(remove_symlinks_to, i->name);
1486
1487 if (r >= 0 && q < 0)
1488 r = q;
1489 }
1490
1491 return r;
1492 }
1493
1494 int unit_file_enable(
1495 UnitFileScope scope,
1496 bool runtime,
1497 const char *root_dir,
1498 char **files,
1499 bool force,
1500 UnitFileChange **changes,
1501 unsigned *n_changes) {
1502
1503 _cleanup_lookup_paths_free_ LookupPaths paths = {};
1504 _cleanup_install_context_done_ InstallContext c = {};
1505 char **i;
1506 _cleanup_free_ char *config_path = NULL;
1507 int r;
1508
1509 assert(scope >= 0);
1510 assert(scope < _UNIT_FILE_SCOPE_MAX);
1511
1512 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1513 if (r < 0)
1514 return r;
1515
1516 r = get_config_path(scope, runtime, root_dir, &config_path);
1517 if (r < 0)
1518 return r;
1519
1520 STRV_FOREACH(i, files) {
1521 r = install_info_add_auto(&c, *i);
1522 if (r < 0)
1523 return r;
1524 }
1525
1526 /* This will return the number of symlink rules that were
1527 supposed to be created, not the ones actually created. This is
1528 useful to determine whether the passed files had any
1529 installation data at all. */
1530
1531 return install_context_apply(&c, &paths, config_path, root_dir, force, changes, n_changes);
1532 }
1533
1534 int unit_file_disable(
1535 UnitFileScope scope,
1536 bool runtime,
1537 const char *root_dir,
1538 char **files,
1539 UnitFileChange **changes,
1540 unsigned *n_changes) {
1541
1542 _cleanup_lookup_paths_free_ LookupPaths paths = {};
1543 _cleanup_install_context_done_ InstallContext c = {};
1544 char **i;
1545 _cleanup_free_ char *config_path = NULL;
1546 _cleanup_set_free_free_ Set *remove_symlinks_to = NULL;
1547 int r, q;
1548
1549 assert(scope >= 0);
1550 assert(scope < _UNIT_FILE_SCOPE_MAX);
1551
1552 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1553 if (r < 0)
1554 return r;
1555
1556 r = get_config_path(scope, runtime, root_dir, &config_path);
1557 if (r < 0)
1558 return r;
1559
1560 STRV_FOREACH(i, files) {
1561 r = install_info_add_auto(&c, *i);
1562 if (r < 0)
1563 return r;
1564 }
1565
1566 r = install_context_mark_for_removal(&c, &paths, &remove_symlinks_to, config_path, root_dir);
1567
1568 q = remove_marked_symlinks(remove_symlinks_to, config_path, changes, n_changes, files);
1569 if (r == 0)
1570 r = q;
1571
1572 return r;
1573 }
1574
1575 int unit_file_reenable(
1576 UnitFileScope scope,
1577 bool runtime,
1578 const char *root_dir,
1579 char **files,
1580 bool force,
1581 UnitFileChange **changes,
1582 unsigned *n_changes) {
1583 int r;
1584
1585 r = unit_file_disable(scope, runtime, root_dir, files,
1586 changes, n_changes);
1587 if (r < 0)
1588 return r;
1589
1590 return unit_file_enable(scope, runtime, root_dir, files, force,
1591 changes, n_changes);
1592 }
1593
1594 int unit_file_set_default(
1595 UnitFileScope scope,
1596 const char *root_dir,
1597 const char *file,
1598 bool force,
1599 UnitFileChange **changes,
1600 unsigned *n_changes) {
1601
1602 _cleanup_lookup_paths_free_ LookupPaths paths = {};
1603 _cleanup_install_context_done_ InstallContext c = {};
1604 _cleanup_free_ char *config_path = NULL;
1605 char *path;
1606 int r;
1607 InstallInfo *i = NULL;
1608
1609 assert(scope >= 0);
1610 assert(scope < _UNIT_FILE_SCOPE_MAX);
1611 assert(file);
1612
1613 if (unit_name_to_type(file) != UNIT_TARGET)
1614 return -EINVAL;
1615
1616 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1617 if (r < 0)
1618 return r;
1619
1620 r = get_config_path(scope, false, root_dir, &config_path);
1621 if (r < 0)
1622 return r;
1623
1624 r = install_info_add_auto(&c, file);
1625 if (r < 0)
1626 return r;
1627
1628 assert_se(i = hashmap_first(c.will_install));
1629
1630 r = unit_file_search(&c, i, &paths, root_dir, false);
1631 if (r < 0)
1632 return r;
1633
1634 path = strappenda(config_path, "/" SPECIAL_DEFAULT_TARGET);
1635
1636 r = create_symlink(i->path, path, force, changes, n_changes);
1637 if (r < 0)
1638 return r;
1639
1640 return 0;
1641 }
1642
1643 int unit_file_get_default(
1644 UnitFileScope scope,
1645 const char *root_dir,
1646 char **name) {
1647
1648 _cleanup_lookup_paths_free_ LookupPaths paths = {};
1649 char **p;
1650 int r;
1651
1652 assert(scope >= 0);
1653 assert(scope < _UNIT_FILE_SCOPE_MAX);
1654 assert(name);
1655
1656 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1657 if (r < 0)
1658 return r;
1659
1660 STRV_FOREACH(p, paths.unit_path) {
1661 _cleanup_free_ char *path = NULL, *tmp = NULL;
1662 char *n;
1663
1664 if (isempty(root_dir))
1665 path = strappend(*p, "/" SPECIAL_DEFAULT_TARGET);
1666 else
1667 path = strjoin(root_dir, "/", *p, "/" SPECIAL_DEFAULT_TARGET, NULL);
1668
1669 if (!path)
1670 return -ENOMEM;
1671
1672 r = readlink_malloc(path, &tmp);
1673 if (r == -ENOENT)
1674 continue;
1675 else if (r == -EINVAL)
1676 /* not a symlink */
1677 n = strdup(SPECIAL_DEFAULT_TARGET);
1678 else if (r < 0)
1679 return r;
1680 else
1681 n = strdup(basename(tmp));
1682
1683 if (!n)
1684 return -ENOMEM;
1685
1686 *name = n;
1687 return 0;
1688 }
1689
1690 return -ENOENT;
1691 }
1692
1693 UnitFileState unit_file_get_state(
1694 UnitFileScope scope,
1695 const char *root_dir,
1696 const char *name) {
1697
1698 _cleanup_lookup_paths_free_ LookupPaths paths = {};
1699 UnitFileState state = _UNIT_FILE_STATE_INVALID;
1700 char **i;
1701 _cleanup_free_ char *path = NULL;
1702 int r;
1703
1704 assert(scope >= 0);
1705 assert(scope < _UNIT_FILE_SCOPE_MAX);
1706 assert(name);
1707
1708 if (root_dir && scope != UNIT_FILE_SYSTEM)
1709 return -EINVAL;
1710
1711 if (!unit_name_is_valid(name, TEMPLATE_VALID))
1712 return -EINVAL;
1713
1714 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1715 if (r < 0)
1716 return r;
1717
1718 STRV_FOREACH(i, paths.unit_path) {
1719 struct stat st;
1720 char *partial;
1721
1722 free(path);
1723 path = NULL;
1724
1725 if (root_dir)
1726 asprintf(&path, "%s/%s/%s", root_dir, *i, name);
1727 else
1728 asprintf(&path, "%s/%s", *i, name);
1729 if (!path)
1730 return -ENOMEM;
1731
1732 if (root_dir)
1733 partial = path + strlen(root_dir) + 1;
1734 else
1735 partial = path;
1736
1737 /*
1738 * Search for a unit file in our default paths, to
1739 * be sure, that there are no broken symlinks.
1740 */
1741 if (lstat(path, &st) < 0) {
1742 r = -errno;
1743 if (errno != ENOENT)
1744 return r;
1745
1746 if (!unit_name_is_instance(name))
1747 continue;
1748 } else {
1749 if (!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode))
1750 return -ENOENT;
1751
1752 r = null_or_empty_path(path);
1753 if (r < 0 && r != -ENOENT)
1754 return r;
1755 else if (r > 0) {
1756 state = path_startswith(*i, "/run") ?
1757 UNIT_FILE_MASKED_RUNTIME : UNIT_FILE_MASKED;
1758 return state;
1759 }
1760 }
1761
1762 r = find_symlinks_in_scope(scope, root_dir, name, &state);
1763 if (r < 0)
1764 return r;
1765 else if (r > 0)
1766 return state;
1767
1768 r = unit_file_can_install(&paths, root_dir, partial, true);
1769 if (r < 0 && errno != ENOENT)
1770 return r;
1771 else if (r > 0)
1772 return UNIT_FILE_DISABLED;
1773 else if (r == 0)
1774 return UNIT_FILE_STATIC;
1775 }
1776
1777 return r < 0 ? r : state;
1778 }
1779
1780 int unit_file_query_preset(UnitFileScope scope, const char *root_dir, const char *name) {
1781 _cleanup_strv_free_ char **files = NULL;
1782 char **p;
1783 int r;
1784
1785 assert(scope >= 0);
1786 assert(scope < _UNIT_FILE_SCOPE_MAX);
1787 assert(name);
1788
1789 if (scope == UNIT_FILE_SYSTEM)
1790 r = conf_files_list(&files, ".preset", root_dir,
1791 "/etc/systemd/system-preset",
1792 "/usr/local/lib/systemd/system-preset",
1793 "/usr/lib/systemd/system-preset",
1794 #ifdef HAVE_SPLIT_USR
1795 "/lib/systemd/system-preset",
1796 #endif
1797 NULL);
1798 else if (scope == UNIT_FILE_GLOBAL)
1799 r = conf_files_list(&files, ".preset", root_dir,
1800 "/etc/systemd/user-preset",
1801 "/usr/local/lib/systemd/user-preset",
1802 "/usr/lib/systemd/user-preset",
1803 NULL);
1804 else
1805 return 1;
1806
1807 if (r < 0)
1808 return r;
1809
1810 STRV_FOREACH(p, files) {
1811 _cleanup_fclose_ FILE *f;
1812
1813 f = fopen(*p, "re");
1814 if (!f) {
1815 if (errno == ENOENT)
1816 continue;
1817
1818 return -errno;
1819 }
1820
1821 for (;;) {
1822 char line[LINE_MAX], *l;
1823
1824 if (!fgets(line, sizeof(line), f))
1825 break;
1826
1827 l = strstrip(line);
1828 if (!*l)
1829 continue;
1830
1831 if (strchr(COMMENTS "\n", *l))
1832 continue;
1833
1834 if (first_word(l, "enable")) {
1835 l += 6;
1836 l += strspn(l, WHITESPACE);
1837
1838 if (fnmatch(l, name, FNM_NOESCAPE) == 0) {
1839 log_debug("Preset file says enable %s.", name);
1840 return 1;
1841 }
1842
1843 } else if (first_word(l, "disable")) {
1844 l += 7;
1845 l += strspn(l, WHITESPACE);
1846
1847 if (fnmatch(l, name, FNM_NOESCAPE) == 0) {
1848 log_debug("Preset file says disable %s.", name);
1849 return 0;
1850 }
1851
1852 } else
1853 log_debug("Couldn't parse line '%s'", l);
1854 }
1855 }
1856
1857 /* Default is "enable" */
1858 log_debug("Preset file doesn't say anything about %s, enabling.", name);
1859 return 1;
1860 }
1861
1862 int unit_file_preset(
1863 UnitFileScope scope,
1864 bool runtime,
1865 const char *root_dir,
1866 char **files,
1867 UnitFilePresetMode mode,
1868 bool force,
1869 UnitFileChange **changes,
1870 unsigned *n_changes) {
1871
1872 _cleanup_install_context_done_ InstallContext plus = {}, minus = {};
1873 _cleanup_lookup_paths_free_ LookupPaths paths = {};
1874 _cleanup_free_ char *config_path = NULL;
1875 char **i;
1876 int r, q;
1877
1878 assert(scope >= 0);
1879 assert(scope < _UNIT_FILE_SCOPE_MAX);
1880 assert(mode < _UNIT_FILE_PRESET_MAX);
1881
1882 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1883 if (r < 0)
1884 return r;
1885
1886 r = get_config_path(scope, runtime, root_dir, &config_path);
1887 if (r < 0)
1888 return r;
1889
1890 STRV_FOREACH(i, files) {
1891
1892 if (!unit_name_is_valid(*i, TEMPLATE_VALID))
1893 return -EINVAL;
1894
1895 r = unit_file_query_preset(scope, root_dir, *i);
1896 if (r < 0)
1897 return r;
1898
1899 if (r && mode != UNIT_FILE_PRESET_DISABLE_ONLY)
1900 r = install_info_add_auto(&plus, *i);
1901 else if (!r && mode != UNIT_FILE_PRESET_ENABLE_ONLY)
1902 r = install_info_add_auto(&minus, *i);
1903 else
1904 r = 0;
1905 if (r < 0)
1906 return r;
1907 }
1908
1909 r = 0;
1910
1911 if (mode != UNIT_FILE_PRESET_ENABLE_ONLY) {
1912 _cleanup_set_free_free_ Set *remove_symlinks_to = NULL;
1913
1914 r = install_context_mark_for_removal(&minus, &paths, &remove_symlinks_to, config_path, root_dir);
1915
1916 q = remove_marked_symlinks(remove_symlinks_to, config_path, changes, n_changes, files);
1917 if (r == 0)
1918 r = q;
1919 }
1920
1921 if (mode != UNIT_FILE_PRESET_DISABLE_ONLY) {
1922 /* Returns number of symlinks that where supposed to be installed. */
1923 q = install_context_apply(&plus, &paths, config_path, root_dir, force, changes, n_changes);
1924 if (r == 0)
1925 r = q;
1926 }
1927
1928 return r;
1929 }
1930
1931 int unit_file_preset_all(
1932 UnitFileScope scope,
1933 bool runtime,
1934 const char *root_dir,
1935 UnitFilePresetMode mode,
1936 bool force,
1937 UnitFileChange **changes,
1938 unsigned *n_changes) {
1939
1940 _cleanup_install_context_done_ InstallContext plus = {}, minus = {};
1941 _cleanup_lookup_paths_free_ LookupPaths paths = {};
1942 _cleanup_free_ char *config_path = NULL;
1943 char **i;
1944 int r, q;
1945
1946 assert(scope >= 0);
1947 assert(scope < _UNIT_FILE_SCOPE_MAX);
1948 assert(mode < _UNIT_FILE_PRESET_MAX);
1949
1950 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
1951 if (r < 0)
1952 return r;
1953
1954 r = get_config_path(scope, runtime, root_dir, &config_path);
1955 if (r < 0)
1956 return r;
1957
1958 STRV_FOREACH(i, paths.unit_path) {
1959 _cleanup_closedir_ DIR *d = NULL;
1960 _cleanup_free_ char *buf = NULL;
1961 const char *units_dir;
1962
1963 if (!isempty(root_dir)) {
1964 buf = strjoin(root_dir, "/", *i, NULL);
1965 if (!buf)
1966 return -ENOMEM;
1967
1968 units_dir = buf;
1969 } else
1970 units_dir = *i;
1971
1972 d = opendir(units_dir);
1973 if (!d) {
1974 if (errno == ENOENT)
1975 continue;
1976
1977 return -errno;
1978 }
1979
1980 for (;;) {
1981 struct dirent *de;
1982
1983 errno = 0;
1984 de = readdir(d);
1985 if (!de && errno != 0)
1986 return -errno;
1987
1988 if (!de)
1989 break;
1990
1991 if (ignore_file(de->d_name))
1992 continue;
1993
1994 if (!unit_name_is_valid(de->d_name, TEMPLATE_VALID))
1995 continue;
1996
1997 dirent_ensure_type(d, de);
1998
1999 if (de->d_type != DT_REG)
2000 continue;
2001
2002 r = unit_file_query_preset(scope, root_dir, de->d_name);
2003 if (r < 0)
2004 return r;
2005
2006 if (r && mode != UNIT_FILE_PRESET_DISABLE_ONLY)
2007 r = install_info_add_auto(&plus, de->d_name);
2008 else if (!r && mode != UNIT_FILE_PRESET_ENABLE_ONLY)
2009 r = install_info_add_auto(&minus, de->d_name);
2010 else
2011 r = 0;
2012 if (r < 0)
2013 return r;
2014 }
2015 }
2016
2017 r = 0;
2018
2019 if (mode != UNIT_FILE_PRESET_ENABLE_ONLY) {
2020 _cleanup_set_free_free_ Set *remove_symlinks_to = NULL;
2021
2022 r = install_context_mark_for_removal(&minus, &paths, &remove_symlinks_to, config_path, root_dir);
2023
2024 q = remove_marked_symlinks(remove_symlinks_to, config_path, changes, n_changes, NULL);
2025 if (r == 0)
2026 r = q;
2027 }
2028
2029 if (mode != UNIT_FILE_PRESET_DISABLE_ONLY) {
2030 q = install_context_apply(&plus, &paths, config_path, root_dir, force, changes, n_changes);
2031 if (r == 0)
2032 r = q;
2033 }
2034
2035 return r;
2036 }
2037
2038 static void unitfilelist_free(UnitFileList **f) {
2039 if (!*f)
2040 return;
2041
2042 free((*f)->path);
2043 free(*f);
2044 }
2045 #define _cleanup_unitfilelist_free_ _cleanup_(unitfilelist_free)
2046
2047 int unit_file_get_list(
2048 UnitFileScope scope,
2049 const char *root_dir,
2050 Hashmap *h) {
2051
2052 _cleanup_lookup_paths_free_ LookupPaths paths = {};
2053 char **i;
2054 int r;
2055
2056 assert(scope >= 0);
2057 assert(scope < _UNIT_FILE_SCOPE_MAX);
2058 assert(h);
2059
2060 if (root_dir && scope != UNIT_FILE_SYSTEM)
2061 return -EINVAL;
2062
2063 r = lookup_paths_init_from_scope(&paths, scope, root_dir);
2064 if (r < 0)
2065 return r;
2066
2067 STRV_FOREACH(i, paths.unit_path) {
2068 _cleanup_closedir_ DIR *d = NULL;
2069 _cleanup_free_ char *buf = NULL;
2070 const char *units_dir;
2071
2072 if (!isempty(root_dir)) {
2073 buf = strjoin(root_dir, "/", *i, NULL);
2074 if (!buf)
2075 return -ENOMEM;
2076
2077 units_dir = buf;
2078 } else
2079 units_dir = *i;
2080
2081 d = opendir(units_dir);
2082 if (!d) {
2083 if (errno == ENOENT)
2084 continue;
2085
2086 return -errno;
2087 }
2088
2089 for (;;) {
2090 _cleanup_unitfilelist_free_ UnitFileList *f = NULL;
2091 struct dirent *de;
2092
2093 errno = 0;
2094 de = readdir(d);
2095 if (!de && errno != 0)
2096 return -errno;
2097
2098 if (!de)
2099 break;
2100
2101 if (ignore_file(de->d_name))
2102 continue;
2103
2104 if (!unit_name_is_valid(de->d_name, TEMPLATE_VALID))
2105 continue;
2106
2107 if (hashmap_get(h, de->d_name))
2108 continue;
2109
2110 dirent_ensure_type(d, de);
2111
2112 if (!IN_SET(de->d_type, DT_LNK, DT_REG))
2113 continue;
2114
2115 f = new0(UnitFileList, 1);
2116 if (!f)
2117 return -ENOMEM;
2118
2119 f->path = path_make_absolute(de->d_name, units_dir);
2120 if (!f->path)
2121 return -ENOMEM;
2122
2123 r = null_or_empty_path(f->path);
2124 if (r < 0 && r != -ENOENT)
2125 return r;
2126 else if (r > 0) {
2127 f->state =
2128 path_startswith(*i, "/run") ?
2129 UNIT_FILE_MASKED_RUNTIME : UNIT_FILE_MASKED;
2130 goto found;
2131 }
2132
2133 r = find_symlinks_in_scope(scope, root_dir, de->d_name, &f->state);
2134 if (r < 0)
2135 return r;
2136 else if (r > 0) {
2137 f->state = UNIT_FILE_ENABLED;
2138 goto found;
2139 }
2140
2141 r = unit_file_can_install(&paths, root_dir, f->path, true);
2142 if (r == -EINVAL || /* Invalid setting? */
2143 r == -EBADMSG || /* Invalid format? */
2144 r == -ENOENT /* Included file not found? */)
2145 f->state = UNIT_FILE_INVALID;
2146 else if (r < 0)
2147 return r;
2148 else if (r > 0)
2149 f->state = UNIT_FILE_DISABLED;
2150 else
2151 f->state = UNIT_FILE_STATIC;
2152
2153 found:
2154 r = hashmap_put(h, basename(f->path), f);
2155 if (r < 0)
2156 return r;
2157 f = NULL; /* prevent cleanup */
2158 }
2159 }
2160
2161 return r;
2162 }
2163
2164 static const char* const unit_file_state_table[_UNIT_FILE_STATE_MAX] = {
2165 [UNIT_FILE_ENABLED] = "enabled",
2166 [UNIT_FILE_ENABLED_RUNTIME] = "enabled-runtime",
2167 [UNIT_FILE_LINKED] = "linked",
2168 [UNIT_FILE_LINKED_RUNTIME] = "linked-runtime",
2169 [UNIT_FILE_MASKED] = "masked",
2170 [UNIT_FILE_MASKED_RUNTIME] = "masked-runtime",
2171 [UNIT_FILE_STATIC] = "static",
2172 [UNIT_FILE_DISABLED] = "disabled",
2173 [UNIT_FILE_INVALID] = "invalid",
2174 };
2175
2176 DEFINE_STRING_TABLE_LOOKUP(unit_file_state, UnitFileState);
2177
2178 static const char* const unit_file_change_type_table[_UNIT_FILE_CHANGE_TYPE_MAX] = {
2179 [UNIT_FILE_SYMLINK] = "symlink",
2180 [UNIT_FILE_UNLINK] = "unlink",
2181 };
2182
2183 DEFINE_STRING_TABLE_LOOKUP(unit_file_change_type, UnitFileChangeType);
2184
2185 static const char* const unit_file_preset_mode_table[_UNIT_FILE_PRESET_MAX] = {
2186 [UNIT_FILE_PRESET_FULL] = "full",
2187 [UNIT_FILE_PRESET_ENABLE_ONLY] = "enable-only",
2188 [UNIT_FILE_PRESET_DISABLE_ONLY] = "disable-only",
2189 };
2190
2191 DEFINE_STRING_TABLE_LOOKUP(unit_file_preset_mode, UnitFilePresetMode);
Unnamed repository; edit this file 'description' to name the repository.