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-symlinks.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
drop_in_file(const char * dir,const char * unit,unsigned level,const char * name,char ** ret_p,char ** ret_q)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
write_drop_in(const char * dir,const char * unit,unsigned level,const char * name,const char * data)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
write_drop_in_format(const char * dir,const char * unit,unsigned level,const char * name,const char * format,...)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
unit_file_add_dir(const char * original_root,const char * path,char *** dirs)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, 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
unit_file_find_dirs(const char * original_root,Set * unit_path_cache,const char * unit_path,const char * name,const char * suffix,char *** dirs)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
unit_file_find_dropin_paths(const char * original_root,char ** lookup_path,Set * unit_path_cache,const char * dir_suffix,const char * file_suffix,const char * name,const Set * aliases,char *** ret)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 }
279