src/shared/dropin.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2014 Zbigniew Jędrzejewski-Szmek
   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 "dropin.h"
  23 #include "util.h"
  24 #include "strv.h"
  25 #include "mkdir.h"
  26 #include "fileio-label.h"
  27 #include "conf-files.h"
  28
  29 int drop_in_file(const char *dir, const char *unit, unsigned level,
  30                  const char *name, char **_p, char **_q) {
  31
  32         _cleanup_free_ char *b = NULL;
  33         char *p, *q;
  34
  35         char prefix[DECIMAL_STR_MAX(unsigned)];
  36
  37         assert(unit);
  38         assert(name);
  39         assert(_p);
  40         assert(_q);
  41
  42         sprintf(prefix, "%u", level);
  43
  44         b = xescape(name, "/.");
  45         if (!b)
  46                 return -ENOMEM;
  47
  48         if (!filename_is_valid(b))
  49                 return -EINVAL;
  50
  51         p = strjoin(dir, "/", unit, ".d", NULL);
  52         if (!p)
  53                 return -ENOMEM;
  54
  55         q = strjoin(p, "/", prefix, "-", b, ".conf", NULL);
  56         if (!q) {
  57                 free(p);
  58                 return -ENOMEM;
  59         }
  60
  61         *_p = p;
  62         *_q = q;
  63         return 0;
  64 }
  65
  66 int write_drop_in(const char *dir, const char *unit, unsigned level,
  67                   const char *name, const char *data) {
  68
  69         _cleanup_free_ char *p = NULL, *q = NULL;
  70         int r;
  71
  72         assert(dir);
  73         assert(unit);
  74         assert(name);
  75         assert(data);
  76
  77         r = drop_in_file(dir, unit, level, name, &p, &q);
  78         if (r < 0)
  79                 return r;
  80
  81         (void) mkdir_p(p, 0755);
  82         return write_string_file_atomic_label(q, data);
  83 }
  84
  85 int write_drop_in_format(const char *dir, const char *unit, unsigned level,
  86                          const char *name, const char *format, ...) {
  87         _cleanup_free_ char *p = NULL;
  88         va_list ap;
  89         int r;
  90
  91         assert(dir);
  92         assert(unit);
  93         assert(name);
  94         assert(format);
  95
  96         va_start(ap, format);
  97         r = vasprintf(&p, format, ap);
  98         va_end(ap);
  99
 100         if (r < 0)
 101                 return -ENOMEM;
 102
 103         return write_drop_in(dir, unit, level, name, p);
 104 }
 105
 106 static int iterate_dir(
 107                 const char *path,
 108                 UnitDependency dependency,
 109                 dependency_consumer_t consumer,
 110                 void *arg,
 111                 char ***strv) {
 112
 113         _cleanup_closedir_ DIR *d = NULL;
 114         int r;
 115
 116         assert(path);
 117
 118         /* The config directories are special, since the order of the
 119          * drop-ins matters */
 120         if (dependency < 0)  {
 121                 r = strv_extend(strv, path);
 122                 if (r < 0)
 123                         return log_oom();
 124
 125                 return 0;
 126         }
 127
 128         assert(consumer);
 129
 130         d = opendir(path);
 131         if (!d) {
 132                 if (errno == ENOENT)
 133                         return 0;
 134
 135                 return log_error_errno(errno, "Failed to open directory %s: %m", path);
 136         }
 137
 138         for (;;) {
 139                 struct dirent *de;
 140                 _cleanup_free_ char *f = NULL;
 141
 142                 errno = 0;
 143                 de = readdir(d);
 144                 if (!de && errno != 0)
 145                         return log_error_errno(errno, "Failed to read directory %s: %m", path);
 146
 147                 if (!de)
 148                         break;
 149
 150                 if (hidden_file(de->d_name))
 151                         continue;
 152
 153                 f = strjoin(path, "/", de->d_name, NULL);
 154                 if (!f)
 155                         return log_oom();
 156
 157                 r = consumer(dependency, de->d_name, f, arg);
 158                 if (r < 0)
 159                         return r;
 160         }
 161
 162         return 0;
 163 }
 164
 165 int unit_file_process_dir(
 166                 Set *unit_path_cache,
 167                 const char *unit_path,
 168                 const char *name,
 169                 const char *suffix,
 170                 UnitDependency dependency,
 171                 dependency_consumer_t consumer,
 172                 void *arg,
 173                 char ***strv) {
 174
 175         _cleanup_free_ char *path = NULL;
 176         int r;
 177
 178         assert(unit_path);
 179         assert(name);
 180         assert(suffix);
 181
 182         path = strjoin(unit_path, "/", name, suffix, NULL);
 183         if (!path)
 184                 return log_oom();
 185
 186         if (!unit_path_cache || set_get(unit_path_cache, path))
 187                 (void) iterate_dir(path, dependency, consumer, arg, strv);
 188
 189         if (unit_name_is_valid(name, UNIT_NAME_INSTANCE)) {
 190                 _cleanup_free_ char *template = NULL, *p = NULL;
 191                 /* Also try the template dir */
 192
 193                 r = unit_name_template(name, &template);
 194                 if (r < 0)
 195                         return log_error_errno(r, "Failed to generate template from unit name: %m");
 196
 197                 p = strjoin(unit_path, "/", template, suffix, NULL);
 198                 if (!p)
 199                         return log_oom();
 200
 201                 if (!unit_path_cache || set_get(unit_path_cache, p))
 202                         (void) iterate_dir(p, dependency, consumer, arg, strv);
 203         }
 204
 205         return 0;
 206 }
 207
 208 int unit_file_find_dropin_paths(
 209                 char **lookup_path,
 210                 Set *unit_path_cache,
 211                 Set *names,
 212                 char ***paths) {
 213
 214         _cleanup_strv_free_ char **strv = NULL, **ans = NULL;
 215         Iterator i;
 216         char *t;
 217         int r;
 218
 219         assert(paths);
 220
 221         SET_FOREACH(t, names, i) {
 222                 char **p;
 223
 224                 STRV_FOREACH(p, lookup_path)
 225                         unit_file_process_dir(unit_path_cache, *p, t, ".d", _UNIT_DEPENDENCY_INVALID, NULL, NULL, &strv);
 226         }
 227
 228         if (strv_isempty(strv))
 229                 return 0;
 230
 231         r = conf_files_list_strv(&ans, ".conf", NULL, (const char**) strv);
 232         if (r < 0)
 233                 return log_warning_errno(r, "Failed to get list of configuration files: %m");
 234
 235         *paths = ans;
 236         ans = NULL;
 237         return 1;
 238 }