src/shared/dropin.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   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 "chase.h"
  10 #include "conf-files.h"
  11 #include "dirent-util.h"
  12 #include "dropin.h"
  13 #include "escape.h"
  14 #include "fd-util.h"
  15 #include "fileio-label.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(path, original_root, 0, &chased, NULL);
 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         /* Return early for top level drop-ins. */
 167         if (unit_type_from_string(name) >= 0)
 168                 return 0;
 169
 170         /* Let's see if there's a "-" prefix for this unit name. If so, let's invoke ourselves for it. This will then
 171          * recursively do the same for all our prefixes. i.e. this means given "foo-bar-waldo.service" we'll also
 172          * search "foo-bar-.service" and "foo-.service".
 173          *
 174          * Note the order in which we do it: we traverse up adding drop-ins on each step. This means the more specific
 175          * drop-ins may override the more generic drop-ins, which is the intended behaviour. */
 176
 177         r = unit_name_to_prefix(name, &prefix);
 178         if (r < 0)
 179                 return log_error_errno(r, "Failed to derive unit name prefix from unit name: %m");
 180
 181         chopped = false;
 182         for (;;) {
 183                 dash = strrchr(prefix, '-');
 184                 if (!dash) /* No dash? if so we are done */
 185                         return 0;
 186
 187                 n = (size_t) (dash - prefix);
 188                 if (n == 0) /* Leading dash? If so, we are done */
 189                         return 0;
 190
 191                 if (prefix[n+1] != 0 || chopped) {
 192                         prefix[n+1] = 0;
 193                         break;
 194                 }
 195
 196                 /* Trailing dash? If so, chop it off and try again, but not more than once. */
 197                 prefix[n] = 0;
 198                 chopped = true;
 199         }
 200
 201         if (!unit_prefix_is_valid(prefix))
 202                 return 0;
 203
 204         type = unit_name_to_type(name);
 205         if (type < 0)
 206                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 207                                        "Failed to derive unit type from unit name: %s",
 208                                        name);
 209
 210         if (is_instance) {
 211                 r = unit_name_to_instance(name, &instance);
 212                 if (r < 0)
 213                         return log_error_errno(r, "Failed to derive unit name instance from unit name: %m");
 214         }
 215
 216         r = unit_name_build_from_type(prefix, instance, type, &built);
 217         if (r < 0)
 218                 return log_error_errno(r, "Failed to build prefix unit name: %m");
 219
 220         return unit_file_find_dirs(original_root, unit_path_cache, unit_path, built, suffix, dirs);
 221 }
 222
 223 int unit_file_find_dropin_paths(
 224                 const char *original_root,
 225                 char **lookup_path,
 226                 Set *unit_path_cache,
 227                 const char *dir_suffix,
 228                 const char *file_suffix,
 229                 const char *name,
 230                 const Set *aliases,
 231                 char ***ret) {
 232
 233         _cleanup_strv_free_ char **dirs = NULL;
 234         const char *n;
 235         int r;
 236
 237         assert(ret);
 238
 239         if (name)
 240                 STRV_FOREACH(p, lookup_path)
 241                         (void) unit_file_find_dirs(original_root, unit_path_cache, *p, name, dir_suffix, &dirs);
 242
 243         SET_FOREACH(n, aliases)
 244                 STRV_FOREACH(p, lookup_path)
 245                         (void) unit_file_find_dirs(original_root, unit_path_cache, *p, n, dir_suffix, &dirs);
 246
 247         /* All the names in the unit are of the same type so just grab one. */
 248         n = name ?: (const char*) set_first(aliases);
 249         if (n) {
 250                 UnitType type = _UNIT_TYPE_INVALID;
 251
 252                 type = unit_name_to_type(n);
 253                 if (type < 0)
 254                         return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 255                                                "Failed to derive unit type from unit name: %s", n);
 256
 257                 /* Special top level drop in for "<unit type>.<suffix>". Add this last as it's the most generic
 258                  * and should be able to be overridden by more specific drop-ins. */
 259                 STRV_FOREACH(p, lookup_path)
 260                         (void) unit_file_find_dirs(original_root,
 261                                                    unit_path_cache,
 262                                                    *p,
 263                                                    unit_type_to_string(type),
 264                                                    dir_suffix,
 265                                                    &dirs);
 266         }
 267
 268         if (strv_isempty(dirs)) {
 269                 *ret = NULL;
 270                 return 0;
 271         }
 272
 273         r = conf_files_list_strv(ret, file_suffix, NULL, 0, (const char**) dirs);
 274         if (r < 0)
 275                 return log_warning_errno(r, "Failed to create the list of configuration files: %m");
 276
 277         return 1;
 278 }