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