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