src/udev/udev-event.c

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