Line data Source code
1 : /* SPDX-License-Identifier: GPL-2.0+ */
2 :
3 : #include <ctype.h>
4 : #include <errno.h>
5 : #include <fcntl.h>
6 : #include <net/if.h>
7 : #include <stddef.h>
8 : #include <stdio.h>
9 : #include <stdlib.h>
10 : #include <sys/wait.h>
11 : #include <unistd.h>
12 :
13 : #include "sd-event.h"
14 :
15 : #include "alloc-util.h"
16 : #include "device-private.h"
17 : #include "device-util.h"
18 : #include "fd-util.h"
19 : #include "fs-util.h"
20 : #include "format-util.h"
21 : #include "libudev-util.h"
22 : #include "netlink-util.h"
23 : #include "parse-util.h"
24 : #include "path-util.h"
25 : #include "process-util.h"
26 : #include "rlimit-util.h"
27 : #include "signal-util.h"
28 : #include "stdio-util.h"
29 : #include "string-util.h"
30 : #include "strv.h"
31 : #include "strxcpyx.h"
32 : #include "udev-builtin.h"
33 : #include "udev-event.h"
34 : #include "udev-node.h"
35 : #include "udev-util.h"
36 : #include "udev-watch.h"
37 : #include "user-util.h"
38 :
39 : typedef struct Spawn {
40 : sd_device *device;
41 : const char *cmd;
42 : pid_t pid;
43 : usec_t timeout_warn_usec;
44 : usec_t timeout_usec;
45 : usec_t event_birth_usec;
46 : bool accept_failure;
47 : int fd_stdout;
48 : int fd_stderr;
49 : char *result;
50 : size_t result_size;
51 : size_t result_len;
52 : } Spawn;
53 :
54 0 : UdevEvent *udev_event_new(sd_device *dev, usec_t exec_delay_usec, sd_netlink *rtnl) {
55 : UdevEvent *event;
56 :
57 0 : assert(dev);
58 :
59 0 : event = new(UdevEvent, 1);
60 0 : if (!event)
61 0 : return NULL;
62 :
63 0 : *event = (UdevEvent) {
64 0 : .dev = sd_device_ref(dev),
65 0 : .birth_usec = now(CLOCK_MONOTONIC),
66 : .exec_delay_usec = exec_delay_usec,
67 0 : .rtnl = sd_netlink_ref(rtnl),
68 : .uid = UID_INVALID,
69 : .gid = GID_INVALID,
70 : .mode = MODE_INVALID,
71 : };
72 :
73 0 : return event;
74 : }
75 :
76 0 : UdevEvent *udev_event_free(UdevEvent *event) {
77 0 : if (!event)
78 0 : return NULL;
79 :
80 0 : sd_device_unref(event->dev);
81 0 : sd_device_unref(event->dev_db_clone);
82 0 : sd_netlink_unref(event->rtnl);
83 0 : ordered_hashmap_free_free_key(event->run_list);
84 0 : ordered_hashmap_free_free_free(event->seclabel_list);
85 0 : free(event->program_result);
86 0 : free(event->name);
87 :
88 0 : return mfree(event);
89 : }
90 :
91 : typedef enum {
92 : FORMAT_SUBST_DEVNODE,
93 : FORMAT_SUBST_ATTR,
94 : FORMAT_SUBST_ENV,
95 : FORMAT_SUBST_KERNEL,
96 : FORMAT_SUBST_KERNEL_NUMBER,
97 : FORMAT_SUBST_DRIVER,
98 : FORMAT_SUBST_DEVPATH,
99 : FORMAT_SUBST_ID,
100 : FORMAT_SUBST_MAJOR,
101 : FORMAT_SUBST_MINOR,
102 : FORMAT_SUBST_RESULT,
103 : FORMAT_SUBST_PARENT,
104 : FORMAT_SUBST_NAME,
105 : FORMAT_SUBST_LINKS,
106 : FORMAT_SUBST_ROOT,
107 : FORMAT_SUBST_SYS,
108 : _FORMAT_SUBST_TYPE_MAX,
109 : _FORMAT_SUBST_TYPE_INVALID = -1
110 : } FormatSubstitutionType;
111 :
112 : struct subst_map_entry {
113 : const char *name;
114 : const char fmt;
115 : FormatSubstitutionType type;
116 : };
117 :
118 : static const struct subst_map_entry map[] = {
119 : { .name = "devnode", .fmt = 'N', .type = FORMAT_SUBST_DEVNODE },
120 : { .name = "tempnode", .fmt = 'N', .type = FORMAT_SUBST_DEVNODE }, /* deprecated */
121 : { .name = "attr", .fmt = 's', .type = FORMAT_SUBST_ATTR },
122 : { .name = "sysfs", .fmt = 's', .type = FORMAT_SUBST_ATTR }, /* deprecated */
123 : { .name = "env", .fmt = 'E', .type = FORMAT_SUBST_ENV },
124 : { .name = "kernel", .fmt = 'k', .type = FORMAT_SUBST_KERNEL },
125 : { .name = "number", .fmt = 'n', .type = FORMAT_SUBST_KERNEL_NUMBER },
126 : { .name = "driver", .fmt = 'd', .type = FORMAT_SUBST_DRIVER },
127 : { .name = "devpath", .fmt = 'p', .type = FORMAT_SUBST_DEVPATH },
128 : { .name = "id", .fmt = 'b', .type = FORMAT_SUBST_ID },
129 : { .name = "major", .fmt = 'M', .type = FORMAT_SUBST_MAJOR },
130 : { .name = "minor", .fmt = 'm', .type = FORMAT_SUBST_MINOR },
131 : { .name = "result", .fmt = 'c', .type = FORMAT_SUBST_RESULT },
132 : { .name = "parent", .fmt = 'P', .type = FORMAT_SUBST_PARENT },
133 : { .name = "name", .fmt = 'D', .type = FORMAT_SUBST_NAME },
134 : { .name = "links", .fmt = 'L', .type = FORMAT_SUBST_LINKS },
135 : { .name = "root", .fmt = 'r', .type = FORMAT_SUBST_ROOT },
136 : { .name = "sys", .fmt = 'S', .type = FORMAT_SUBST_SYS },
137 : };
138 :
139 0 : static const char *format_type_to_string(FormatSubstitutionType t) {
140 0 : for (size_t i = 0; i < ELEMENTSOF(map); i++)
141 0 : if (map[i].type == t)
142 0 : return map[i].name;
143 0 : return NULL;
144 : }
145 :
146 0 : static char format_type_to_char(FormatSubstitutionType t) {
147 0 : for (size_t i = 0; i < ELEMENTSOF(map); i++)
148 0 : if (map[i].type == t)
149 0 : return map[i].fmt;
150 0 : return '\0';
151 : }
152 :
153 0 : static int get_subst_type(const char **str, bool strict, FormatSubstitutionType *ret_type, char ret_attr[static UTIL_PATH_SIZE]) {
154 0 : const char *p = *str, *q = NULL;
155 : size_t i;
156 :
157 0 : assert(str);
158 0 : assert(*str);
159 0 : assert(ret_type);
160 0 : assert(ret_attr);
161 :
162 0 : if (*p == '$') {
163 0 : p++;
164 0 : if (*p == '$') {
165 0 : *str = p;
166 0 : return 0;
167 : }
168 0 : for (i = 0; i < ELEMENTSOF(map); i++)
169 0 : if ((q = startswith(p, map[i].name)))
170 0 : break;
171 0 : } else if (*p == '%') {
172 0 : p++;
173 0 : if (*p == '%') {
174 0 : *str = p;
175 0 : return 0;
176 : }
177 :
178 0 : for (i = 0; i < ELEMENTSOF(map); i++)
179 0 : if (*p == map[i].fmt) {
180 0 : q = p + 1;
181 0 : break;
182 : }
183 : } else
184 0 : return 0;
185 0 : if (!q)
186 : /* When 'strict' flag is set, then '$' and '%' must be escaped. */
187 0 : return strict ? -EINVAL : 0;
188 :
189 0 : if (*q == '{') {
190 : const char *start, *end;
191 : size_t len;
192 :
193 0 : start = q + 1;
194 0 : end = strchr(start, '}');
195 0 : if (!end)
196 0 : return -EINVAL;
197 :
198 0 : len = end - start;
199 0 : if (len == 0 || len >= UTIL_PATH_SIZE)
200 0 : return -EINVAL;
201 :
202 0 : strnscpy(ret_attr, UTIL_PATH_SIZE, start, len);
203 0 : q = end + 1;
204 : } else
205 0 : *ret_attr = '\0';
206 :
207 0 : *str = q;
208 0 : *ret_type = map[i].type;
209 0 : return 1;
210 : }
211 :
212 0 : static int safe_atou_optional_plus(const char *s, unsigned *ret) {
213 : const char *p;
214 : int r;
215 :
216 0 : assert(s);
217 0 : assert(ret);
218 :
219 : /* Returns 1 if plus, 0 if no plus, negative on error */
220 :
221 0 : p = endswith(s, "+");
222 0 : if (p)
223 0 : s = strndupa(s, p - s);
224 :
225 0 : r = safe_atou(s, ret);
226 0 : if (r < 0)
227 0 : return r;
228 :
229 0 : return !!p;
230 : }
231 :
232 0 : static ssize_t udev_event_subst_format(
233 : UdevEvent *event,
234 : FormatSubstitutionType type,
235 : const char *attr,
236 : char *dest,
237 : size_t l) {
238 0 : sd_device *parent, *dev = event->dev;
239 0 : const char *val = NULL;
240 0 : char *s = dest;
241 : int r;
242 :
243 0 : switch (type) {
244 0 : case FORMAT_SUBST_DEVPATH:
245 0 : r = sd_device_get_devpath(dev, &val);
246 0 : if (r < 0)
247 0 : return r;
248 0 : l = strpcpy(&s, l, val);
249 0 : break;
250 0 : case FORMAT_SUBST_KERNEL:
251 0 : r = sd_device_get_sysname(dev, &val);
252 0 : if (r < 0)
253 0 : return r;
254 0 : l = strpcpy(&s, l, val);
255 0 : break;
256 0 : case FORMAT_SUBST_KERNEL_NUMBER:
257 0 : r = sd_device_get_sysnum(dev, &val);
258 0 : if (r == -ENOENT)
259 0 : goto null_terminate;
260 0 : if (r < 0)
261 0 : return r;
262 0 : l = strpcpy(&s, l, val);
263 0 : break;
264 0 : case FORMAT_SUBST_ID:
265 0 : if (!event->dev_parent)
266 0 : goto null_terminate;
267 0 : r = sd_device_get_sysname(event->dev_parent, &val);
268 0 : if (r < 0)
269 0 : return r;
270 0 : l = strpcpy(&s, l, val);
271 0 : break;
272 0 : case FORMAT_SUBST_DRIVER:
273 0 : if (!event->dev_parent)
274 0 : goto null_terminate;
275 0 : r = sd_device_get_driver(event->dev_parent, &val);
276 0 : if (r == -ENOENT)
277 0 : goto null_terminate;
278 0 : if (r < 0)
279 0 : return r;
280 0 : l = strpcpy(&s, l, val);
281 0 : break;
282 0 : case FORMAT_SUBST_MAJOR:
283 : case FORMAT_SUBST_MINOR: {
284 : dev_t devnum;
285 :
286 0 : r = sd_device_get_devnum(dev, &devnum);
287 0 : if (r < 0 && r != -ENOENT)
288 0 : return r;
289 0 : l = strpcpyf(&s, l, "%u", r < 0 ? 0 : type == FORMAT_SUBST_MAJOR ? major(devnum) : minor(devnum));
290 0 : break;
291 : }
292 0 : case FORMAT_SUBST_RESULT: {
293 0 : unsigned index = 0; /* 0 means whole string */
294 : bool has_plus;
295 :
296 0 : if (!event->program_result)
297 0 : goto null_terminate;
298 :
299 0 : if (!isempty(attr)) {
300 0 : r = safe_atou_optional_plus(attr, &index);
301 0 : if (r < 0)
302 0 : return r;
303 :
304 0 : has_plus = r;
305 : }
306 :
307 0 : if (index == 0)
308 0 : l = strpcpy(&s, l, event->program_result);
309 : else {
310 : const char *start, *p;
311 : unsigned i;
312 :
313 0 : p = skip_leading_chars(event->program_result, NULL);
314 :
315 0 : for (i = 1; i < index; i++) {
316 0 : while (*p && !strchr(WHITESPACE, *p))
317 0 : p++;
318 0 : p = skip_leading_chars(p, NULL);
319 0 : if (*p == '\0')
320 0 : break;
321 : }
322 0 : if (i != index) {
323 0 : log_device_debug(dev, "requested part of result string not found");
324 0 : goto null_terminate;
325 : }
326 :
327 0 : start = p;
328 : /* %c{2+} copies the whole string from the second part on */
329 0 : if (has_plus)
330 0 : l = strpcpy(&s, l, start);
331 : else {
332 0 : while (*p && !strchr(WHITESPACE, *p))
333 0 : p++;
334 0 : l = strnpcpy(&s, l, start, p - start);
335 : }
336 : }
337 0 : break;
338 : }
339 0 : case FORMAT_SUBST_ATTR: {
340 : char vbuf[UTIL_NAME_SIZE];
341 : int count;
342 :
343 0 : if (isempty(attr))
344 0 : return -EINVAL;
345 :
346 : /* try to read the value specified by "[dmi/id]product_name" */
347 0 : if (util_resolve_subsys_kernel(attr, vbuf, sizeof(vbuf), true) == 0)
348 0 : val = vbuf;
349 :
350 : /* try to read the attribute the device */
351 0 : if (!val)
352 0 : (void) sd_device_get_sysattr_value(dev, attr, &val);
353 :
354 : /* try to read the attribute of the parent device, other matches have selected */
355 0 : if (!val && event->dev_parent && event->dev_parent != dev)
356 0 : (void) sd_device_get_sysattr_value(event->dev_parent, attr, &val);
357 :
358 0 : if (!val)
359 0 : goto null_terminate;
360 :
361 : /* strip trailing whitespace, and replace unwanted characters */
362 0 : if (val != vbuf)
363 0 : strscpy(vbuf, sizeof(vbuf), val);
364 0 : delete_trailing_chars(vbuf, NULL);
365 0 : count = util_replace_chars(vbuf, UDEV_ALLOWED_CHARS_INPUT);
366 0 : if (count > 0)
367 0 : log_device_debug(dev, "%i character(s) replaced", count);
368 0 : l = strpcpy(&s, l, vbuf);
369 0 : break;
370 : }
371 0 : case FORMAT_SUBST_PARENT:
372 0 : r = sd_device_get_parent(dev, &parent);
373 0 : if (r == -ENODEV)
374 0 : goto null_terminate;
375 0 : if (r < 0)
376 0 : return r;
377 0 : r = sd_device_get_devname(parent, &val);
378 0 : if (r == -ENOENT)
379 0 : goto null_terminate;
380 0 : if (r < 0)
381 0 : return r;
382 0 : l = strpcpy(&s, l, val + STRLEN("/dev/"));
383 0 : break;
384 0 : case FORMAT_SUBST_DEVNODE:
385 0 : r = sd_device_get_devname(dev, &val);
386 0 : if (r == -ENOENT)
387 0 : goto null_terminate;
388 0 : if (r < 0)
389 0 : return r;
390 0 : l = strpcpy(&s, l, val);
391 0 : break;
392 0 : case FORMAT_SUBST_NAME:
393 0 : if (event->name)
394 0 : l = strpcpy(&s, l, event->name);
395 0 : else if (sd_device_get_devname(dev, &val) >= 0)
396 0 : l = strpcpy(&s, l, val + STRLEN("/dev/"));
397 : else {
398 0 : r = sd_device_get_sysname(dev, &val);
399 0 : if (r < 0)
400 0 : return r;
401 0 : l = strpcpy(&s, l, val);
402 : }
403 0 : break;
404 0 : case FORMAT_SUBST_LINKS:
405 0 : FOREACH_DEVICE_DEVLINK(dev, val)
406 0 : if (s == dest)
407 0 : l = strpcpy(&s, l, val + STRLEN("/dev/"));
408 : else
409 0 : l = strpcpyl(&s, l, " ", val + STRLEN("/dev/"), NULL);
410 0 : if (s == dest)
411 0 : goto null_terminate;
412 0 : break;
413 0 : case FORMAT_SUBST_ROOT:
414 0 : l = strpcpy(&s, l, "/dev");
415 0 : break;
416 0 : case FORMAT_SUBST_SYS:
417 0 : l = strpcpy(&s, l, "/sys");
418 0 : break;
419 0 : case FORMAT_SUBST_ENV:
420 0 : if (isempty(attr))
421 0 : return -EINVAL;
422 0 : r = sd_device_get_property_value(dev, attr, &val);
423 0 : if (r == -ENOENT)
424 0 : goto null_terminate;
425 0 : if (r < 0)
426 0 : return r;
427 0 : l = strpcpy(&s, l, val);
428 0 : break;
429 0 : default:
430 0 : assert_not_reached("Unknown format substitution type");
431 : }
432 :
433 0 : return s - dest;
434 :
435 0 : null_terminate:
436 0 : *s = '\0';
437 0 : return 0;
438 : }
439 :
440 0 : ssize_t udev_event_apply_format(UdevEvent *event,
441 : const char *src, char *dest, size_t size,
442 : bool replace_whitespace) {
443 0 : const char *s = src;
444 : int r;
445 :
446 0 : assert(event);
447 0 : assert(event->dev);
448 0 : assert(src);
449 0 : assert(dest);
450 0 : assert(size > 0);
451 :
452 0 : while (*s) {
453 : FormatSubstitutionType type;
454 : char attr[UTIL_PATH_SIZE];
455 : ssize_t subst_len;
456 :
457 0 : r = get_subst_type(&s, false, &type, attr);
458 0 : if (r < 0)
459 0 : return log_device_warning_errno(event->dev, r, "Invalid format string, ignoring: %s", src);
460 0 : if (r == 0) {
461 0 : if (size < 2) /* need space for this char and the terminating NUL */
462 0 : break;
463 0 : *dest++ = *s++;
464 0 : size--;
465 0 : continue;
466 : }
467 :
468 0 : subst_len = udev_event_subst_format(event, type, attr, dest, size);
469 0 : if (subst_len < 0)
470 0 : return log_device_warning_errno(event->dev, subst_len,
471 : "Failed to substitute variable '$%s' or apply format '%%%c', ignoring: %m",
472 : format_type_to_string(type), format_type_to_char(type));
473 :
474 : /* FORMAT_SUBST_RESULT handles spaces itself */
475 0 : if (replace_whitespace && type != FORMAT_SUBST_RESULT)
476 : /* util_replace_whitespace can replace in-place,
477 : * and does nothing if subst_len == 0 */
478 0 : subst_len = util_replace_whitespace(dest, dest, subst_len);
479 :
480 0 : dest += subst_len;
481 0 : size -= subst_len;
482 : }
483 :
484 0 : assert(size >= 1);
485 0 : *dest = '\0';
486 0 : return size;
487 : }
488 :
489 0 : int udev_check_format(const char *value, size_t *offset, const char **hint) {
490 : FormatSubstitutionType type;
491 0 : const char *s = value;
492 : char attr[UTIL_PATH_SIZE];
493 : int r;
494 :
495 0 : while (*s) {
496 0 : r = get_subst_type(&s, true, &type, attr);
497 0 : if (r < 0) {
498 0 : if (offset)
499 0 : *offset = s - value;
500 0 : if (hint)
501 0 : *hint = "invalid substitution type";
502 0 : return r;
503 0 : } else if (r == 0) {
504 0 : s++;
505 0 : continue;
506 : }
507 :
508 0 : if (IN_SET(type, FORMAT_SUBST_ATTR, FORMAT_SUBST_ENV) && isempty(attr)) {
509 0 : if (offset)
510 0 : *offset = s - value;
511 0 : if (hint)
512 0 : *hint = "attribute value missing";
513 0 : return -EINVAL;
514 : }
515 :
516 0 : if (type == FORMAT_SUBST_RESULT && !isempty(attr)) {
517 : unsigned i;
518 :
519 0 : r = safe_atou_optional_plus(attr, &i);
520 0 : if (r < 0) {
521 0 : if (offset)
522 0 : *offset = s - value;
523 0 : if (hint)
524 0 : *hint = "attribute value not a valid number";
525 0 : return r;
526 : }
527 : }
528 : }
529 :
530 0 : return 0;
531 : }
532 :
533 0 : static int on_spawn_io(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
534 0 : Spawn *spawn = userdata;
535 : char buf[4096], *p;
536 : size_t size;
537 : ssize_t l;
538 :
539 0 : assert(spawn);
540 0 : assert(fd == spawn->fd_stdout || fd == spawn->fd_stderr);
541 0 : assert(!spawn->result || spawn->result_len < spawn->result_size);
542 :
543 0 : if (fd == spawn->fd_stdout && spawn->result) {
544 0 : p = spawn->result + spawn->result_len;
545 0 : size = spawn->result_size - spawn->result_len;
546 : } else {
547 0 : p = buf;
548 0 : size = sizeof(buf);
549 : }
550 :
551 0 : l = read(fd, p, size - 1);
552 0 : if (l < 0) {
553 0 : if (errno != EAGAIN)
554 0 : log_device_error_errno(spawn->device, errno,
555 : "Failed to read stdout of '%s': %m", spawn->cmd);
556 :
557 0 : return 0;
558 : }
559 :
560 0 : p[l] = '\0';
561 0 : if (fd == spawn->fd_stdout && spawn->result)
562 0 : spawn->result_len += l;
563 :
564 : /* Log output only if we watch stderr. */
565 0 : if (l > 0 && spawn->fd_stderr >= 0) {
566 0 : _cleanup_strv_free_ char **v = NULL;
567 : char **q;
568 :
569 0 : v = strv_split_newlines(p);
570 0 : if (!v)
571 0 : return 0;
572 :
573 0 : STRV_FOREACH(q, v)
574 0 : log_device_debug(spawn->device, "'%s'(%s) '%s'", spawn->cmd,
575 : fd == spawn->fd_stdout ? "out" : "err", *q);
576 : }
577 :
578 0 : return 0;
579 : }
580 :
581 0 : static int on_spawn_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
582 0 : Spawn *spawn = userdata;
583 : char timeout[FORMAT_TIMESPAN_MAX];
584 :
585 0 : assert(spawn);
586 :
587 0 : kill_and_sigcont(spawn->pid, SIGKILL);
588 :
589 0 : log_device_error(spawn->device, "Spawned process '%s' ["PID_FMT"] timed out after %s, killing",
590 : spawn->cmd, spawn->pid,
591 : format_timespan(timeout, sizeof(timeout), spawn->timeout_usec, USEC_PER_SEC));
592 :
593 0 : return 1;
594 : }
595 :
596 0 : static int on_spawn_timeout_warning(sd_event_source *s, uint64_t usec, void *userdata) {
597 0 : Spawn *spawn = userdata;
598 : char timeout[FORMAT_TIMESPAN_MAX];
599 :
600 0 : assert(spawn);
601 :
602 0 : log_device_warning(spawn->device, "Spawned process '%s' ["PID_FMT"] is taking longer than %s to complete",
603 : spawn->cmd, spawn->pid,
604 : format_timespan(timeout, sizeof(timeout), spawn->timeout_warn_usec, USEC_PER_SEC));
605 :
606 0 : return 1;
607 : }
608 :
609 0 : static int on_spawn_sigchld(sd_event_source *s, const siginfo_t *si, void *userdata) {
610 0 : Spawn *spawn = userdata;
611 0 : int ret = -EIO;
612 :
613 0 : assert(spawn);
614 :
615 0 : switch (si->si_code) {
616 0 : case CLD_EXITED:
617 0 : if (si->si_status == 0)
618 0 : log_device_debug(spawn->device, "Process '%s' succeeded.", spawn->cmd);
619 : else
620 0 : log_device_full(spawn->device, spawn->accept_failure ? LOG_DEBUG : LOG_WARNING, 0,
621 : "Process '%s' failed with exit code %i.", spawn->cmd, si->si_status);
622 0 : ret = si->si_status;
623 0 : break;
624 0 : case CLD_KILLED:
625 : case CLD_DUMPED:
626 0 : log_device_error(spawn->device, "Process '%s' terminated by signal %s.", spawn->cmd, signal_to_string(si->si_status));
627 0 : break;
628 0 : default:
629 0 : log_device_error(spawn->device, "Process '%s' failed due to unknown reason.", spawn->cmd);
630 : }
631 :
632 0 : sd_event_exit(sd_event_source_get_event(s), ret);
633 0 : return 1;
634 : }
635 :
636 0 : static int spawn_wait(Spawn *spawn) {
637 0 : _cleanup_(sd_event_unrefp) sd_event *e = NULL;
638 : int r;
639 :
640 0 : assert(spawn);
641 :
642 0 : r = sd_event_new(&e);
643 0 : if (r < 0)
644 0 : return r;
645 :
646 0 : if (spawn->timeout_usec > 0) {
647 : usec_t usec, age_usec;
648 :
649 0 : usec = now(CLOCK_MONOTONIC);
650 0 : age_usec = usec - spawn->event_birth_usec;
651 0 : if (age_usec < spawn->timeout_usec) {
652 0 : if (spawn->timeout_warn_usec > 0 &&
653 0 : spawn->timeout_warn_usec < spawn->timeout_usec &&
654 0 : spawn->timeout_warn_usec > age_usec) {
655 0 : spawn->timeout_warn_usec -= age_usec;
656 :
657 0 : r = sd_event_add_time(e, NULL, CLOCK_MONOTONIC,
658 0 : usec + spawn->timeout_warn_usec, USEC_PER_SEC,
659 : on_spawn_timeout_warning, spawn);
660 0 : if (r < 0)
661 0 : return r;
662 : }
663 :
664 0 : spawn->timeout_usec -= age_usec;
665 :
666 0 : r = sd_event_add_time(e, NULL, CLOCK_MONOTONIC,
667 0 : usec + spawn->timeout_usec, USEC_PER_SEC, on_spawn_timeout, spawn);
668 0 : if (r < 0)
669 0 : return r;
670 : }
671 : }
672 :
673 0 : if (spawn->fd_stdout >= 0) {
674 0 : r = sd_event_add_io(e, NULL, spawn->fd_stdout, EPOLLIN, on_spawn_io, spawn);
675 0 : if (r < 0)
676 0 : return r;
677 : }
678 :
679 0 : if (spawn->fd_stderr >= 0) {
680 0 : r = sd_event_add_io(e, NULL, spawn->fd_stderr, EPOLLIN, on_spawn_io, spawn);
681 0 : if (r < 0)
682 0 : return r;
683 : }
684 :
685 0 : r = sd_event_add_child(e, NULL, spawn->pid, WEXITED, on_spawn_sigchld, spawn);
686 0 : if (r < 0)
687 0 : return r;
688 :
689 0 : return sd_event_loop(e);
690 : }
691 :
692 0 : int udev_event_spawn(UdevEvent *event,
693 : usec_t timeout_usec,
694 : bool accept_failure,
695 : const char *cmd,
696 : char *result, size_t ressize) {
697 0 : _cleanup_close_pair_ int outpipe[2] = {-1, -1}, errpipe[2] = {-1, -1};
698 0 : _cleanup_strv_free_ char **argv = NULL;
699 0 : char **envp = NULL;
700 : Spawn spawn;
701 : pid_t pid;
702 : int r;
703 :
704 0 : assert(event);
705 0 : assert(event->dev);
706 0 : assert(result || ressize == 0);
707 :
708 : /* pipes from child to parent */
709 0 : if (result || log_get_max_level() >= LOG_INFO)
710 0 : if (pipe2(outpipe, O_NONBLOCK|O_CLOEXEC) != 0)
711 0 : return log_device_error_errno(event->dev, errno,
712 : "Failed to create pipe for command '%s': %m", cmd);
713 :
714 0 : if (log_get_max_level() >= LOG_INFO)
715 0 : if (pipe2(errpipe, O_NONBLOCK|O_CLOEXEC) != 0)
716 0 : return log_device_error_errno(event->dev, errno,
717 : "Failed to create pipe for command '%s': %m", cmd);
718 :
719 0 : argv = strv_split_full(cmd, NULL, SPLIT_QUOTES|SPLIT_RELAX);
720 0 : if (!argv)
721 0 : return log_oom();
722 :
723 0 : if (isempty(argv[0]))
724 0 : return log_device_error_errno(event->dev, SYNTHETIC_ERRNO(EINVAL),
725 : "Invalid command '%s'", cmd);
726 :
727 : /* allow programs in /usr/lib/udev/ to be called without the path */
728 0 : if (!path_is_absolute(argv[0])) {
729 : char *program;
730 :
731 0 : program = path_join(UDEVLIBEXECDIR, argv[0]);
732 0 : if (!program)
733 0 : return log_oom();
734 :
735 0 : free_and_replace(argv[0], program);
736 : }
737 :
738 0 : r = device_get_properties_strv(event->dev, &envp);
739 0 : if (r < 0)
740 0 : return log_device_error_errno(event->dev, r, "Failed to get device properties");
741 :
742 0 : log_device_debug(event->dev, "Starting '%s'", cmd);
743 :
744 0 : r = safe_fork("(spawn)", FORK_RESET_SIGNALS|FORK_DEATHSIG|FORK_LOG, &pid);
745 0 : if (r < 0)
746 0 : return log_device_error_errno(event->dev, r,
747 : "Failed to fork() to execute command '%s': %m", cmd);
748 0 : if (r == 0) {
749 0 : if (rearrange_stdio(-1, outpipe[WRITE_END], errpipe[WRITE_END]) < 0)
750 0 : _exit(EXIT_FAILURE);
751 :
752 0 : (void) close_all_fds(NULL, 0);
753 0 : (void) rlimit_nofile_safe();
754 :
755 0 : execve(argv[0], argv, envp);
756 0 : _exit(EXIT_FAILURE);
757 : }
758 :
759 : /* parent closed child's ends of pipes */
760 0 : outpipe[WRITE_END] = safe_close(outpipe[WRITE_END]);
761 0 : errpipe[WRITE_END] = safe_close(errpipe[WRITE_END]);
762 :
763 0 : spawn = (Spawn) {
764 0 : .device = event->dev,
765 : .cmd = cmd,
766 : .pid = pid,
767 : .accept_failure = accept_failure,
768 0 : .timeout_warn_usec = udev_warn_timeout(timeout_usec),
769 : .timeout_usec = timeout_usec,
770 0 : .event_birth_usec = event->birth_usec,
771 0 : .fd_stdout = outpipe[READ_END],
772 0 : .fd_stderr = errpipe[READ_END],
773 : .result = result,
774 : .result_size = ressize,
775 : };
776 0 : r = spawn_wait(&spawn);
777 0 : if (r < 0)
778 0 : return log_device_error_errno(event->dev, r,
779 : "Failed to wait for spawned command '%s': %m", cmd);
780 :
781 0 : if (result)
782 0 : result[spawn.result_len] = '\0';
783 :
784 0 : return r; /* 0 for success, and positive if the program failed */
785 : }
786 :
787 0 : static int rename_netif(UdevEvent *event) {
788 0 : sd_device *dev = event->dev;
789 : const char *oldname;
790 : int ifindex, r;
791 :
792 0 : if (!event->name)
793 0 : return 0; /* No new name is requested. */
794 :
795 0 : r = sd_device_get_sysname(dev, &oldname);
796 0 : if (r < 0)
797 0 : return log_device_error_errno(dev, r, "Failed to get sysname: %m");
798 :
799 0 : if (streq(event->name, oldname))
800 0 : return 0; /* The interface name is already requested name. */
801 :
802 0 : if (!device_for_action(dev, DEVICE_ACTION_ADD))
803 0 : return 0; /* Rename the interface only when it is added. */
804 :
805 0 : r = sd_device_get_ifindex(dev, &ifindex);
806 0 : if (r == -ENOENT)
807 0 : return 0; /* Device is not a network interface. */
808 0 : if (r < 0)
809 0 : return log_device_error_errno(dev, r, "Failed to get ifindex: %m");
810 :
811 0 : r = rtnl_set_link_name(&event->rtnl, ifindex, event->name);
812 0 : if (r < 0)
813 0 : return log_device_error_errno(dev, r, "Failed to rename network interface %i from '%s' to '%s': %m",
814 : ifindex, oldname, event->name);
815 :
816 : /* Set ID_RENAMING boolean property here, and drop it in the corresponding move uevent later. */
817 0 : r = device_add_property(dev, "ID_RENAMING", "1");
818 0 : if (r < 0)
819 0 : return log_device_warning_errno(dev, r, "Failed to add 'ID_RENAMING' property: %m");
820 :
821 0 : r = device_rename(dev, event->name);
822 0 : if (r < 0)
823 0 : return log_device_warning_errno(dev, r, "Failed to update properties with new name '%s': %m", event->name);
824 :
825 0 : log_device_debug(dev, "Network interface %i is renamed from '%s' to '%s'", ifindex, oldname, event->name);
826 :
827 0 : return 1;
828 : }
829 :
830 0 : static int update_devnode(UdevEvent *event) {
831 0 : sd_device *dev = event->dev;
832 : int r;
833 :
834 0 : r = sd_device_get_devnum(dev, NULL);
835 0 : if (r == -ENOENT)
836 0 : return 0;
837 0 : if (r < 0)
838 0 : return log_device_error_errno(dev, r, "Failed to get devnum: %m");
839 :
840 : /* remove/update possible left-over symlinks from old database entry */
841 0 : if (event->dev_db_clone)
842 0 : (void) udev_node_update_old_links(dev, event->dev_db_clone);
843 :
844 0 : if (!uid_is_valid(event->uid)) {
845 0 : r = device_get_devnode_uid(dev, &event->uid);
846 0 : if (r < 0 && r != -ENOENT)
847 0 : return log_device_error_errno(dev, r, "Failed to get devnode UID: %m");
848 : }
849 :
850 0 : if (!gid_is_valid(event->gid)) {
851 0 : r = device_get_devnode_gid(dev, &event->gid);
852 0 : if (r < 0 && r != -ENOENT)
853 0 : return log_device_error_errno(dev, r, "Failed to get devnode GID: %m");
854 : }
855 :
856 0 : if (event->mode == MODE_INVALID) {
857 0 : r = device_get_devnode_mode(dev, &event->mode);
858 0 : if (r < 0 && r != -ENOENT)
859 0 : return log_device_error_errno(dev, r, "Failed to get devnode mode: %m");
860 : }
861 0 : if (event->mode == MODE_INVALID && gid_is_valid(event->gid) && event->gid > 0)
862 : /* If group is set, but mode is not set, "upgrade" mode for the group. */
863 0 : event->mode = 0660;
864 :
865 0 : bool apply_mac = device_for_action(dev, DEVICE_ACTION_ADD);
866 :
867 0 : return udev_node_add(dev, apply_mac, event->mode, event->uid, event->gid, event->seclabel_list);
868 : }
869 :
870 0 : static void event_execute_rules_on_remove(
871 : UdevEvent *event,
872 : usec_t timeout_usec,
873 : Hashmap *properties_list,
874 : UdevRules *rules) {
875 :
876 0 : sd_device *dev = event->dev;
877 : int r;
878 :
879 0 : r = device_read_db_internal(dev, true);
880 0 : if (r < 0)
881 0 : log_device_debug_errno(dev, r, "Failed to read database under /run/udev/data/: %m");
882 :
883 0 : r = device_tag_index(dev, NULL, false);
884 0 : if (r < 0)
885 0 : log_device_debug_errno(dev, r, "Failed to remove corresponding tag files under /run/udev/tag/, ignoring: %m");
886 :
887 0 : r = device_delete_db(dev);
888 0 : if (r < 0)
889 0 : log_device_debug_errno(dev, r, "Failed to delete database under /run/udev/data/, ignoring: %m");
890 :
891 0 : if (sd_device_get_devnum(dev, NULL) >= 0)
892 0 : (void) udev_watch_end(dev);
893 :
894 0 : (void) udev_rules_apply_to_event(rules, event, timeout_usec, properties_list);
895 :
896 0 : if (sd_device_get_devnum(dev, NULL) >= 0)
897 0 : (void) udev_node_remove(dev);
898 0 : }
899 :
900 0 : static int udev_event_on_move(UdevEvent *event) {
901 0 : sd_device *dev = event->dev;
902 : int r;
903 :
904 0 : if (event->dev_db_clone &&
905 0 : sd_device_get_devnum(dev, NULL) < 0) {
906 0 : r = device_copy_properties(dev, event->dev_db_clone);
907 0 : if (r < 0)
908 0 : log_device_debug_errno(dev, r, "Failed to copy properties from cloned sd_device object, ignoring: %m");
909 : }
910 :
911 : /* Drop previously added property */
912 0 : r = device_add_property(dev, "ID_RENAMING", NULL);
913 0 : if (r < 0)
914 0 : return log_device_debug_errno(dev, r, "Failed to remove 'ID_RENAMING' property: %m");
915 :
916 0 : return 0;
917 : }
918 :
919 0 : int udev_event_execute_rules(UdevEvent *event,
920 : usec_t timeout_usec,
921 : Hashmap *properties_list,
922 : UdevRules *rules) {
923 : const char *subsystem;
924 : DeviceAction action;
925 : sd_device *dev;
926 : int r;
927 :
928 0 : assert(event);
929 0 : assert(rules);
930 :
931 0 : dev = event->dev;
932 :
933 0 : r = sd_device_get_subsystem(dev, &subsystem);
934 0 : if (r < 0)
935 0 : return log_device_error_errno(dev, r, "Failed to get subsystem: %m");
936 :
937 0 : r = device_get_action(dev, &action);
938 0 : if (r < 0)
939 0 : return log_device_error_errno(dev, r, "Failed to get ACTION: %m");
940 :
941 0 : if (action == DEVICE_ACTION_REMOVE) {
942 0 : event_execute_rules_on_remove(event, timeout_usec, properties_list, rules);
943 0 : return 0;
944 : }
945 :
946 0 : r = device_clone_with_db(dev, &event->dev_db_clone);
947 0 : if (r < 0)
948 0 : return log_device_debug_errno(dev, r, "Failed to clone sd_device object: %m");
949 :
950 0 : if (event->dev_db_clone && sd_device_get_devnum(dev, NULL) >= 0)
951 : /* Disable watch during event processing. */
952 0 : (void) udev_watch_end(event->dev_db_clone);
953 :
954 0 : if (action == DEVICE_ACTION_MOVE) {
955 0 : r = udev_event_on_move(event);
956 0 : if (r < 0)
957 0 : return r;
958 : }
959 :
960 0 : r = udev_rules_apply_to_event(rules, event, timeout_usec, properties_list);
961 0 : if (r < 0)
962 0 : return log_device_debug_errno(dev, r, "Failed to apply udev rules: %m");
963 :
964 0 : r = rename_netif(event);
965 0 : if (r < 0)
966 0 : return r;
967 :
968 0 : r = update_devnode(event);
969 0 : if (r < 0)
970 0 : return r;
971 :
972 : /* preserve old, or get new initialization timestamp */
973 0 : r = device_ensure_usec_initialized(dev, event->dev_db_clone);
974 0 : if (r < 0)
975 0 : return log_device_debug_errno(dev, r, "Failed to set initialization timestamp: %m");
976 :
977 : /* (re)write database file */
978 0 : r = device_tag_index(dev, event->dev_db_clone, true);
979 0 : if (r < 0)
980 0 : return log_device_debug_errno(dev, r, "Failed to update tags under /run/udev/tag/: %m");
981 :
982 0 : r = device_update_db(dev);
983 0 : if (r < 0)
984 0 : return log_device_debug_errno(dev, r, "Failed to update database under /run/udev/data/: %m");
985 :
986 0 : device_set_is_initialized(dev);
987 :
988 0 : event->dev_db_clone = sd_device_unref(event->dev_db_clone);
989 :
990 0 : return 0;
991 : }
992 :
993 0 : void udev_event_execute_run(UdevEvent *event, usec_t timeout_usec) {
994 : const char *command;
995 : void *val;
996 : Iterator i;
997 : int r;
998 :
999 0 : ORDERED_HASHMAP_FOREACH_KEY(val, command, event->run_list, i) {
1000 0 : UdevBuiltinCommand builtin_cmd = PTR_TO_UDEV_BUILTIN_CMD(val);
1001 :
1002 0 : if (builtin_cmd != _UDEV_BUILTIN_INVALID) {
1003 0 : log_device_debug(event->dev, "Running built-in command \"%s\"", command);
1004 0 : r = udev_builtin_run(event->dev, builtin_cmd, command, false);
1005 0 : if (r < 0)
1006 0 : log_device_debug_errno(event->dev, r, "Failed to run built-in command \"%s\", ignoring: %m", command);
1007 : } else {
1008 0 : if (event->exec_delay_usec > 0) {
1009 : char buf[FORMAT_TIMESPAN_MAX];
1010 :
1011 0 : log_device_debug(event->dev, "Delaying execution of \"%s\" for %s.",
1012 : command, format_timespan(buf, sizeof(buf), event->exec_delay_usec, USEC_PER_SEC));
1013 0 : (void) usleep(event->exec_delay_usec);
1014 : }
1015 :
1016 0 : log_device_debug(event->dev, "Running command \"%s\"", command);
1017 0 : r = udev_event_spawn(event, timeout_usec, false, command, NULL, 0);
1018 0 : if (r > 0) /* returned value is positive when program fails */
1019 0 : log_device_debug(event->dev, "Command \"%s\" returned %d (error), ignoring.", command, r);
1020 : }
1021 : }
1022 0 : }
|
