src/shared/dropin.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <errno.h>
   4 #include <stdarg.h>
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7
   8 #include "alloc-util.h"
   9 #include "conf-files.h"
  10 #include "dirent-util.h"
  11 #include "dropin.h"
  12 #include "escape.h"
  13 #include "fd-util.h"
  14 #include "fileio-label.h"
  15 #include "fs-util.h"
  16 #include "hashmap.h"
  17 #include "log.h"
  18 #include "macro.h"
  19 #include "mkdir.h"
  20 #include "path-util.h"
  21 #include "set.h"
  22 #include "string-util.h"
  23 #include "strv.h"
  24 #include "unit-name.h"
  25
  26 int drop_in_file(const char *dir, const char *unit, unsigned level,
  27                  const char *name, char **ret_p, char **ret_q) {
  28
  29         char prefix[DECIMAL_STR_MAX(unsigned)];
  30         _cleanup_free_ char *b = NULL, *p = NULL, *q = NULL;
  31
  32         assert(unit);
  33         assert(name);
  34         assert(ret_p);
  35         assert(ret_q);
  36
  37         sprintf(prefix, "%u", level);
  38
  39         b = xescape(name, "/.");
  40         if (!b)
  41                 return -ENOMEM;
  42
  43         if (!filename_is_valid(b))
  44                 return -EINVAL;
  45
  46         p = strjoin(dir, "/", unit, ".d");
  47         q = strjoin(p, "/", prefix, "-", b, ".conf");
  48         if (!p || !q)
  49                 return -ENOMEM;
  50
  51         *ret_p = TAKE_PTR(p);
  52         *ret_q = TAKE_PTR(q);
  53         return 0;
  54 }
  55
  56 int write_drop_in(const char *dir, const char *unit, unsigned level,
  57                   const char *name, const char *data) {
  58
  59         _cleanup_free_ char *p = NULL, *q = NULL;
  60         int r;
  61
  62         assert(dir);
  63         assert(unit);
  64         assert(name);
  65         assert(data);
  66
  67         r = drop_in_file(dir, unit, level, name, &p, &q);
  68         if (r < 0)
  69                 return r;
  70
  71         (void) mkdir_p(p, 0755);
  72         return write_string_file_atomic_label(q, data);
  73 }
  74
  75 int write_drop_in_format(const char *dir, const char *unit, unsigned level,
  76                          const char *name, const char *format, ...) {
  77         _cleanup_free_ char *p = NULL;
  78         va_list ap;
  79         int r;
  80
  81         assert(dir);
  82         assert(unit);
  83         assert(name);
  84         assert(format);
  85
  86         va_start(ap, format);
  87         r = vasprintf(&p, format, ap);
  88         va_end(ap);
  89
  90         if (r < 0)
  91                 return -ENOMEM;
  92
  93         return write_drop_in(dir, unit, level, name, p);
  94 }
  95
  96 static int unit_file_add_dir(
  97                 const char *original_root,
  98                 const char *path,
  99                 char ***dirs) {
 100
 101         _cleanup_free_ char *chased = NULL;
 102         int r;
 103
 104         assert(path);
 105
 106         /* This adds [original_root]/path to dirs, if it exists. */
 107
 108         r = chase_symlinks(path, original_root, 0, &chased);
 109         if (r == -ENOENT) /* Ignore -ENOENT, after all most units won't have a drop-in dir. */
 110                 return 0;
 111         if (r == -ENAMETOOLONG) {
 112                 /* Also, ignore -ENAMETOOLONG but log about it. After all, users are not even able to create the
 113                  * drop-in dir in such case. This mostly happens for device units with an overly long /sys path. */
 114                 log_debug_errno(r, "Path '%s' too long, couldn't canonicalize, ignoring.", path);
 115                 return 0;
 116         }
 117         if (r < 0)
 118                 return log_warning_errno(r, "Failed to canonicalize path '%s': %m", path);
 119
 120         if (strv_consume(dirs, TAKE_PTR(chased)) < 0)
 121                 return log_oom();
 122
 123         return 0;
 124 }
 125
 126 static int unit_file_find_dirs(
 127                 const char *original_root,
 128                 Set *unit_path_cache,
 129                 const char *unit_path,
 130                 const char *name,
 131                 const char *suffix,
 132                 char ***dirs) {
 133
 134         _cleanup_free_ char *prefix = NULL, *instance = NULL, *built = NULL;
 135         bool is_instance, chopped;
 136         const char *dash;
 137         UnitType type;
 138         char *path;
 139         size_t n;
 140         int r;
 141
 142         assert(unit_path);
 143         assert(name);
 144         assert(suffix);
 145
 146         path = strjoina(unit_path, "/", name, suffix);
 147         if (!unit_path_cache || set_get(unit_path_cache, path)) {
 148                 r = unit_file_add_dir(original_root, path, dirs);
 149                 if (r < 0)
 150                         return r;
 151         }
 152
 153         is_instance = unit_name_is_valid(name, UNIT_NAME_INSTANCE);
 154         if (is_instance) { /* Also try the template dir */
 155                 _cleanup_free_ char *template = NULL;
 156
 157                 r = unit_name_template(name, &template);
 158                 if (r < 0)
 159                         return log_error_errno(r, "Failed to generate template from unit name: %m");
 160
 161                 r = unit_file_find_dirs(original_root, unit_path_cache, unit_path, template, suffix, dirs);
 162                 if (r < 0)
 163                         return r;
 164         }
 165
 166         /* Let's see if there's a "-" prefix for this unit name. If so, let's invoke ourselves for it. This will then
 167          * recursively do the same for all our prefixes. i.e. this means given "foo-bar-waldo.service" we'll also
 168          * search "foo-bar-.service" and "foo-.service".
 169          *
 170          * Note the order in which we do it: we traverse up adding drop-ins on each step. This means the more specific
 171          * drop-ins may override the more generic drop-ins, which is the intended behaviour. */
 172
 173         r = unit_name_to_prefix(name, &prefix);
 174         if (r < 0)
 175                 return log_error_errno(r, "Failed to derive unit name prefix from unit name: %m");
 176
 177         chopped = false;
 178         for (;;) {
 179                 dash = strrchr(prefix, '-');
 180                 if (!dash) /* No dash? if so we are done */
 181                         return 0;
 182
 183                 n = (size_t) (dash - prefix);
 184                 if (n == 0) /* Leading dash? If so, we are done */
 185                         return 0;
 186
 187                 if (prefix[n+1] != 0 || chopped) {
 188                         prefix[n+1] = 0;
 189                         break;
 190                 }
 191
 192                 /* Trailing dash? If so, chop it off and try again, but not more than once. */
 193                 prefix[n] = 0;
 194                 chopped = true;
 195         }
 196
 197         if (!unit_prefix_is_valid(prefix))
 198                 return 0;
 199
 200         type = unit_name_to_type(name);
 201         if (type < 0)
 202                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 203                                        "Failed to to derive unit type from unit name: %s",
 204                                        name);
 205
 206         if (is_instance) {
 207                 r = unit_name_to_instance(name, &instance);
 208                 if (r < 0)
 209                         return log_error_errno(r, "Failed to derive unit name instance from unit name: %m");
 210         }
 211
 212         r = unit_name_build_from_type(prefix, instance, type, &built);
 213         if (r < 0)
 214                 return log_error_errno(r, "Failed to build prefix unit name: %m");
 215
 216         return unit_file_find_dirs(original_root, unit_path_cache, unit_path, built, suffix, dirs);
 217 }
 218
 219 int unit_file_find_dropin_paths(
 220                 const char *original_root,
 221                 char **lookup_path,
 222                 Set *unit_path_cache,
 223                 const char *dir_suffix,
 224                 const char *file_suffix,
 225                 const Set *names,
 226                 char ***ret) {
 227
 228         _cleanup_strv_free_ char **dirs = NULL;
 229         char *name, **p;
 230         Iterator i;
 231         int r;
 232
 233         assert(ret);
 234
 235         SET_FOREACH(name, names, i)
 236                 STRV_FOREACH(p, lookup_path)
 237                         (void) unit_file_find_dirs(original_root, unit_path_cache, *p, name, dir_suffix, &dirs);
 238
 239         if (strv_isempty(dirs)) {
 240                 *ret = NULL;
 241                 return 0;
 242         }
 243
 244         r = conf_files_list_strv(ret, file_suffix, NULL, 0, (const char**) dirs);
 245         if (r < 0)
 246                 return log_warning_errno(r, "Failed to create the list of configuration files: %m");
 247
 248         return 1;
 249 }