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