src/core/load-dropin.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include "conf-parser.h"
   4 #include "fs-util.h"
   5 #include "load-dropin.h"
   6 #include "load-fragment.h"
   7 #include "log.h"
   8 #include "stat-util.h"
   9 #include "string-util.h"
  10 #include "strv.h"
  11 #include "unit-name.h"
  12 #include "unit.h"
  13
  14 static int process_deps(Unit *u, UnitDependency dependency, const char *dir_suffix) {
  15         _cleanup_strv_free_ char **paths = NULL;
  16         char **p;
  17         int r;
  18
  19         r = unit_file_find_dropin_paths(NULL,
  20                                         u->manager->lookup_paths.search_path,
  21                                         u->manager->unit_path_cache,
  22                                         dir_suffix, NULL,
  23                                         u->id, u->aliases,
  24                                         &paths);
  25         if (r < 0)
  26                 return r;
  27
  28         STRV_FOREACH(p, paths) {
  29                 _cleanup_free_ char *target = NULL;
  30                 const char *entry;
  31
  32                 entry = basename(*p);
  33
  34                 if (null_or_empty_path(*p) > 0) {
  35                         /* an error usually means an invalid symlink, which is not a mask */
  36                         log_unit_debug(u, "%s dependency on %s is masked by %s, ignoring.",
  37                                        unit_dependency_to_string(dependency), entry, *p);
  38                         continue;
  39                 }
  40
  41                 r = is_symlink(*p);
  42                 if (r < 0) {
  43                         log_unit_warning_errno(u, r, "%s dropin %s unreadable, ignoring: %m",
  44                                                unit_dependency_to_string(dependency), *p);
  45                         continue;
  46                 }
  47                 if (r == 0) {
  48                         log_unit_warning(u, "%s dependency dropin %s is not a symlink, ignoring.",
  49                                          unit_dependency_to_string(dependency), *p);
  50                         continue;
  51                 }
  52
  53                 if (!unit_name_is_valid(entry, UNIT_NAME_ANY)) {
  54                         log_unit_warning(u, "%s dependency dropin %s is not a valid unit name, ignoring.",
  55                                          unit_dependency_to_string(dependency), *p);
  56                         continue;
  57                 }
  58
  59                 r = readlink_malloc(*p, &target);
  60                 if (r < 0) {
  61                         log_unit_warning_errno(u, r, "readlink(\"%s\") failed, ignoring: %m", *p);
  62                         continue;
  63                 }
  64
  65                 /* We don't treat this as an error, especially because we didn't check this for a
  66                  * long time. Nevertheless, we warn, because such mismatch can be mighty confusing. */
  67                 r = unit_symlink_name_compatible(entry, basename(target), u->instance);
  68                 if (r < 0) {
  69                         log_unit_warning_errno(u, r, "Can't check if names %s and %s are compatible, ignoring: %m",
  70                                                entry, basename(target));
  71                         continue;
  72                 }
  73                 if (r == 0)
  74                         log_unit_warning(u, "%s dependency dropin %s target %s has different name",
  75                                          unit_dependency_to_string(dependency), *p, target);
  76
  77                 r = unit_add_dependency_by_name(u, dependency, entry, true, UNIT_DEPENDENCY_FILE);
  78                 if (r < 0)
  79                         log_unit_warning_errno(u, r, "Cannot add %s dependency on %s, ignoring: %m",
  80                                                unit_dependency_to_string(dependency), entry);
  81         }
  82
  83         return 0;
  84 }
  85
  86 int unit_load_dropin(Unit *u) {
  87         _cleanup_strv_free_ char **l = NULL;
  88         char **f;
  89         int r;
  90
  91         assert(u);
  92
  93         /* Load dependencies from .wants and .requires directories */
  94         r = process_deps(u, UNIT_WANTS, ".wants");
  95         if (r < 0)
  96                 return r;
  97
  98         r = process_deps(u, UNIT_REQUIRES, ".requires");
  99         if (r < 0)
 100                 return r;
 101
 102         /* Load .conf dropins */
 103         r = unit_find_dropin_paths(u, &l);
 104         if (r <= 0)
 105                 return 0;
 106
 107         if (!u->dropin_paths)
 108                 u->dropin_paths = TAKE_PTR(l);
 109         else {
 110                 r = strv_extend_strv(&u->dropin_paths, l, true);
 111                 if (r < 0)
 112                         return log_oom();
 113         }
 114
 115         u->dropin_mtime = 0;
 116         STRV_FOREACH(f, u->dropin_paths) {
 117                 struct stat st;
 118
 119                 r = config_parse(u->id, *f, NULL,
 120                                  UNIT_VTABLE(u)->sections,
 121                                  config_item_perf_lookup, load_fragment_gperf_lookup,
 122                                  0, u, &st);
 123                 if (r > 0)
 124                         u->dropin_mtime = MAX(u->dropin_mtime, timespec_load(&st.st_mtim));
 125         }
 126
 127         return 0;
 128 }