udev/udev-rules.c

   1 /*
   2  * Copyright (C) 2003 Greg Kroah-Hartman <greg@kroah.com>
   3  * Copyright (C) 2003-2008 Kay Sievers <kay.sievers@vrfy.org>
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <stddef.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <stdio.h>
  23 #include <fcntl.h>
  24 #include <ctype.h>
  25 #include <unistd.h>
  26 #include <errno.h>
  27 #include <dirent.h>
  28 #include <fnmatch.h>
  29
  30 #include "udev.h"
  31
  32 struct udev_rules {
  33         struct udev *udev;
  34         char *buf;
  35         size_t bufsize;
  36         int resolve_names;
  37 };
  38
  39 struct udev_rules_iter {
  40         struct udev_rules *rules;
  41         size_t current;
  42 };
  43
  44 enum key_operation {
  45         KEY_OP_UNSET,
  46         KEY_OP_MATCH,
  47         KEY_OP_NOMATCH,
  48         KEY_OP_ADD,
  49         KEY_OP_ASSIGN,
  50         KEY_OP_ASSIGN_FINAL,
  51 };
  52
  53 struct key {
  54         enum key_operation operation;
  55         size_t val_off;
  56 };
  57
  58 struct key_pair {
  59         struct key key;
  60         size_t key_name_off;
  61 };
  62
  63 #define PAIRS_MAX               5
  64 struct key_pairs {
  65         int count;
  66         struct key_pair keys[PAIRS_MAX];
  67 };
  68
  69 enum import_type {
  70         IMPORT_UNSET,
  71         IMPORT_PROGRAM,
  72         IMPORT_FILE,
  73         IMPORT_PARENT,
  74 };
  75
  76 enum escape_type {
  77         ESCAPE_UNSET,
  78         ESCAPE_NONE,
  79         ESCAPE_REPLACE,
  80 };
  81
  82 struct udev_rule {
  83         struct key action;
  84         struct key devpath;
  85         struct key kernel;
  86         struct key subsystem;
  87         struct key driver;
  88         struct key_pairs attr;
  89
  90         struct key kernels;
  91         struct key subsystems;
  92         struct key drivers;
  93         struct key_pairs attrs;
  94
  95         struct key_pairs env;
  96         struct key program;
  97         struct key result;
  98         struct key import;
  99         enum import_type import_type;
 100         struct key test;
 101         mode_t test_mode_mask;
 102         struct key run;
 103         struct key wait_for;
 104         struct key label;
 105         struct key goto_label;
 106         size_t goto_rule_off;
 107
 108         struct key name;
 109         struct key symlink;
 110         struct key symlink_match;
 111         struct key owner;
 112         struct key group;
 113         struct key mode;
 114         enum escape_type string_escape;
 115
 116         unsigned int link_priority;
 117         int event_timeout;
 118         unsigned int partitions;
 119         unsigned int last_rule:1,
 120                      run_ignore_error:1,
 121                      ignore_device:1,
 122                      ignore_remove:1;
 123
 124         size_t bufsize;
 125         char buf[];
 126 };
 127
 128 static void udev_rules_iter_init(struct udev_rules_iter *iter, struct udev_rules *rules)
 129 {
 130         dbg(rules->udev, "bufsize=%zi\n", rules->bufsize);
 131         iter->rules = rules;
 132         iter->current = 0;
 133 }
 134
 135 static struct udev_rule *udev_rules_iter_next(struct udev_rules_iter *iter)
 136 {
 137         struct udev_rules *rules;
 138         struct udev_rule *rule;
 139
 140         rules = iter->rules;
 141         if (!rules)
 142                 return NULL;
 143
 144         dbg(rules->udev, "current=%zi\n", iter->current);
 145         if (iter->current >= rules->bufsize) {
 146                 dbg(rules->udev, "no more rules\n");
 147                 return NULL;
 148         }
 149
 150         /* get next rule */
 151         rule = (struct udev_rule *) (rules->buf + iter->current);
 152         iter->current += sizeof(struct udev_rule) + rule->bufsize;
 153
 154         return rule;
 155 }
 156
 157 static struct udev_rule *udev_rules_iter_goto(struct udev_rules_iter *iter, size_t rule_off)
 158 {
 159         struct udev_rules *rules = iter->rules;
 160         struct udev_rule *rule;
 161
 162         dbg(rules->udev, "current=%zi\n", iter->current);
 163         iter->current = rule_off;
 164         rule = (struct udev_rule *) (rules->buf + iter->current);
 165
 166         return rule;
 167 }
 168
 169 static size_t find_label(const struct udev_rules_iter *iter, const char *label)
 170 {
 171         struct udev_rule *rule;
 172         struct udev_rules *rules = iter->rules;
 173         size_t current = iter->current;
 174
 175 next:
 176         dbg(rules->udev, "current=%zi\n", current);
 177         if (current >= rules->bufsize) {
 178                 dbg(rules->udev, "LABEL='%s' not found\n", label);
 179                 return 0;
 180         }
 181         rule = (struct udev_rule *) (rules->buf + current);
 182
 183         if (strcmp(&rule->buf[rule->label.val_off], label) != 0) {
 184                 dbg(rules->udev, "moving forward, looking for label '%s'\n", label);
 185                 current += sizeof(struct udev_rule) + rule->bufsize;
 186                 goto next;
 187         }
 188
 189         dbg(rules->udev, "found label '%s'\n", label);
 190         return current;
 191 }
 192
 193 /* extract possible {attr} and move str behind it */
 194 static char *get_format_attribute(struct udev *udev, char **str)
 195 {
 196         char *pos;
 197         char *attr = NULL;
 198
 199         if (*str[0] == '{') {
 200                 pos = strchr(*str, '}');
 201                 if (pos == NULL) {
 202                         err(udev, "missing closing brace for format\n");
 203                         return NULL;
 204                 }
 205                 pos[0] = '\0';
 206                 attr = *str+1;
 207                 *str = pos+1;
 208                 dbg(udev, "attribute='%s', str='%s'\n", attr, *str);
 209         }
 210         return attr;
 211 }
 212
 213 /* extract possible format length and move str behind it*/
 214 static int get_format_len(struct udev *udev, char **str)
 215 {
 216         int num;
 217         char *tail;
 218
 219         if (isdigit(*str[0])) {
 220                 num = (int) strtoul(*str, &tail, 10);
 221                 if (num > 0) {
 222                         *str = tail;
 223                         dbg(udev, "format length=%i\n", num);
 224                         return num;
 225                 } else {
 226                         err(udev, "format parsing error '%s'\n", *str);
 227                 }
 228         }
 229         return -1;
 230 }
 231
 232 static int import_property_from_string(struct udev_device *dev, char *line)
 233 {
 234         struct udev *udev = udev_device_get_udev(dev);
 235         char *key;
 236         char *val;
 237         size_t len;
 238
 239         /* find key */
 240         key = line;
 241         while (isspace(key[0]))
 242                 key++;
 243
 244         /* comment or empty line */
 245         if (key[0] == '#' || key[0] == '\0')
 246                 return -1;
 247
 248         /* split key/value */
 249         val = strchr(key, '=');
 250         if (val == NULL)
 251                 return -1;
 252         val[0] = '\0';
 253         val++;
 254
 255         /* find value */
 256         while (isspace(val[0]))
 257                 val++;
 258
 259         /* terminate key */
 260         len = strlen(key);
 261         if (len == 0)
 262                 return -1;
 263         while (isspace(key[len-1]))
 264                 len--;
 265         key[len] = '\0';
 266
 267         /* terminate value */
 268         len = strlen(val);
 269         if (len == 0)
 270                 return -1;
 271         while (isspace(val[len-1]))
 272                 len--;
 273         val[len] = '\0';
 274
 275         if (len == 0)
 276                 return -1;
 277
 278         /* unquote */
 279         if (val[0] == '"' || val[0] == '\'') {
 280                 if (val[len-1] != val[0]) {
 281                         info(udev, "inconsistent quoting: '%s', skip\n", line);
 282                         return -1;
 283                 }
 284                 val[len-1] = '\0';
 285                 val++;
 286         }
 287
 288         info(udev, "adding '%s'='%s'\n", key, val);
 289
 290         /* handle device, renamed by external tool, returning new path */
 291         if (strcmp(key, "DEVPATH") == 0) {
 292                 char syspath[UTIL_PATH_SIZE];
 293
 294                 info(udev, "updating devpath from '%s' to '%s'\n",
 295                      udev_device_get_devpath(dev), val);
 296                 util_strlcpy(syspath, udev_get_sys_path(udev), sizeof(syspath));
 297                 util_strlcat(syspath, val, sizeof(syspath));
 298                 udev_device_set_syspath(dev, syspath);
 299         } else {
 300                 struct udev_list_entry *entry;
 301
 302                 entry = udev_device_add_property(dev, key, val);
 303                 /* store in db */
 304                 udev_list_entry_set_flag(entry, 1);
 305         }
 306         return 0;
 307 }
 308
 309 static int import_file_into_env(struct udev_device *dev, const char *filename)
 310 {
 311         FILE *f;
 312         char line[UTIL_LINE_SIZE];
 313
 314         f = fopen(filename, "r");
 315         if (f == NULL)
 316                 return -1;
 317         while (fgets(line, sizeof(line), f) != NULL)
 318                 import_property_from_string(dev, line);
 319         fclose(f);
 320         return 0;
 321 }
 322
 323 static int import_program_into_env(struct udev_device *dev, const char *program)
 324 {
 325         struct udev *udev = udev_device_get_udev(dev);
 326         char **envp;
 327         char result[2048];
 328         size_t reslen;
 329         char *line;
 330
 331         envp = udev_device_get_properties_envp(dev);
 332         if (run_program(udev, program, envp, result, sizeof(result), &reslen) != 0)
 333                 return -1;
 334
 335         line = result;
 336         while (line != NULL) {
 337                 char *pos;
 338
 339                 pos = strchr(line, '\n');
 340                 if (pos != NULL) {
 341                         pos[0] = '\0';
 342                         pos = &pos[1];
 343                 }
 344                 import_property_from_string(dev, line);
 345                 line = pos;
 346         }
 347         return 0;
 348 }
 349
 350 static int import_parent_into_env(struct udev_device *dev, const char *filter)
 351 {
 352         struct udev *udev = udev_device_get_udev(dev);
 353         struct udev_device *dev_parent;
 354         struct udev_list_entry *list_entry;
 355
 356         dev_parent = udev_device_get_parent(dev);
 357         if (dev_parent == NULL)
 358                 return -1;
 359
 360         dbg(udev, "found parent '%s', get the node name\n", udev_device_get_syspath(dev_parent));
 361         udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(dev_parent)) {
 362                 const char *key = udev_list_entry_get_name(list_entry);
 363                 const char *val = udev_list_entry_get_value(list_entry);
 364
 365                 if (fnmatch(filter, key, 0) == 0) {
 366                         struct udev_list_entry *entry;
 367
 368                         dbg(udev, "import key '%s=%s'\n", key, val);
 369                         entry = udev_device_add_property(dev, key, val);
 370                         /* store in db */
 371                         udev_list_entry_set_flag(entry, 1);
 372                 }
 373         }
 374         return 0;
 375 }
 376
 377 int udev_rules_run(struct udev_event *event)
 378 {
 379         struct udev_list_entry *list_entry;
 380         int err = 0;
 381
 382         dbg(event->udev, "executing run list\n");
 383         udev_list_entry_foreach(list_entry, udev_list_get_entry(&event->run_list)) {
 384                 const char *cmd = udev_list_entry_get_name(list_entry);
 385
 386                 if (strncmp(cmd, "socket:", strlen("socket:")) == 0) {
 387                         struct udev_monitor *monitor;
 388
 389                         monitor = udev_monitor_new_from_socket(event->udev, &cmd[strlen("socket:")]);
 390                         if (monitor == NULL)
 391                                 continue;
 392                         udev_monitor_send_device(monitor, event->dev);
 393                         udev_monitor_unref(monitor);
 394                 } else {
 395                         char program[UTIL_PATH_SIZE];
 396                         char **envp;
 397
 398                         util_strlcpy(program, cmd, sizeof(program));
 399                         udev_rules_apply_format(event, program, sizeof(program));
 400                         envp = udev_device_get_properties_envp(event->dev);
 401                         if (run_program(event->udev, program, envp, NULL, 0, NULL) != 0) {
 402                                 if (!udev_list_entry_get_flag(list_entry))
 403                                         err = -1;
 404                         }
 405                 }
 406         }
 407         return err;
 408 }
 409
 410 #define WAIT_LOOP_PER_SECOND            50
 411 static int wait_for_file(struct udev_event *event, const char *file, int timeout)
 412 {
 413         char filepath[UTIL_PATH_SIZE];
 414         char devicepath[UTIL_PATH_SIZE] = "";
 415         struct stat stats;
 416         int loop = timeout * WAIT_LOOP_PER_SECOND;
 417
 418         /* a relative path is a device attribute */
 419         if (file[0] != '/') {
 420                 util_strlcpy(devicepath, udev_get_sys_path(event->udev), sizeof(devicepath));
 421                 util_strlcat(devicepath, udev_device_get_devpath(event->dev), sizeof(devicepath));
 422
 423                 util_strlcpy(filepath, devicepath, sizeof(filepath));
 424                 util_strlcat(filepath, "/", sizeof(filepath));
 425                 util_strlcat(filepath, file, sizeof(filepath));
 426                 file = filepath;
 427         }
 428
 429         dbg(event->udev, "will wait %i sec for '%s'\n", timeout, file);
 430         while (--loop) {
 431                 /* lookup file */
 432                 if (stat(file, &stats) == 0) {
 433                         info(event->udev, "file '%s' appeared after %i loops\n", file, (timeout * WAIT_LOOP_PER_SECOND) - loop-1);
 434                         return 0;
 435                 }
 436                 /* make sure, the device did not disappear in the meantime */
 437                 if (devicepath[0] != '\0' && stat(devicepath, &stats) != 0) {
 438                         info(event->udev, "device disappeared while waiting for '%s'\n", file);
 439                         return -2;
 440                 }
 441                 info(event->udev, "wait for '%s' for %i mseconds\n", file, 1000 / WAIT_LOOP_PER_SECOND);
 442                 usleep(1000 * 1000 / WAIT_LOOP_PER_SECOND);
 443         }
 444         info(event->udev, "waiting for '%s' failed\n", file);
 445         return -1;
 446 }
 447
 448 /* handle "[$SUBSYSTEM/$KERNEL]<attribute>" lookup */
 449 static int split_subsys_sysname(struct udev *udev, char *attrstr, char **subsys, char **sysname, char **attr)
 450 {
 451         char *pos;
 452
 453         if (attrstr[0] != '[')
 454                 return -1;
 455
 456         *subsys = &attrstr[1];
 457         pos = strchr(*subsys, ']');
 458         if (pos == NULL)
 459                 return -1;
 460         pos[0] = '\0';
 461         pos = &pos[1];
 462
 463         if (pos[0] == '/')
 464                 pos = &pos[1];
 465         if (pos[0] != '\0')
 466                 *attr = pos;
 467         else
 468                 *attr = NULL;
 469
 470         pos = strchr(*subsys, '/');
 471         if (pos == NULL)
 472                 return -1;
 473         pos[0] = '\0';
 474         *sysname = &pos[1];
 475         return 0;
 476 }
 477
 478 static int attr_subst_subdir(char *attr, size_t len)
 479 {
 480         char *pos;
 481         int found = 0;
 482
 483         pos = strstr(attr, "/*/");
 484         if (pos != NULL) {
 485                 char str[UTIL_PATH_SIZE];
 486                 DIR *dir;
 487
 488                 pos[1] = '\0';
 489                 util_strlcpy(str, &pos[2], sizeof(str));
 490                 dir = opendir(attr);
 491                 if (dir != NULL) {
 492                         struct dirent *dent;
 493
 494                         for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
 495                                 struct stat stats;
 496
 497                                 if (dent->d_name[0] == '.')
 498                                         continue;
 499                                 util_strlcat(attr, dent->d_name, len);
 500                                 util_strlcat(attr, str, len);
 501                                 if (stat(attr, &stats) == 0) {
 502                                         found = 1;
 503                                         break;
 504                                 }
 505                                 pos[1] = '\0';
 506                         }
 507                         closedir(dir);
 508                 }
 509                 if (!found)
 510                         util_strlcat(attr, str, len);
 511         }
 512
 513         return found;
 514 }
 515
 516 void udev_rules_apply_format(struct udev_event *event, char *string, size_t maxsize)
 517 {
 518         struct udev_device *dev = event->dev;
 519         char temp[UTIL_PATH_SIZE];
 520         char temp2[UTIL_PATH_SIZE];
 521         char *head, *tail, *cpos, *attr, *rest;
 522         int len;
 523         int i;
 524         int count;
 525         enum subst_type {
 526                 SUBST_UNKNOWN,
 527                 SUBST_DEVPATH,
 528                 SUBST_KERNEL,
 529                 SUBST_KERNEL_NUMBER,
 530                 SUBST_ID,
 531                 SUBST_DRIVER,
 532                 SUBST_MAJOR,
 533                 SUBST_MINOR,
 534                 SUBST_RESULT,
 535                 SUBST_ATTR,
 536                 SUBST_PARENT,
 537                 SUBST_TEMP_NODE,
 538                 SUBST_NAME,
 539                 SUBST_LINKS,
 540                 SUBST_ROOT,
 541                 SUBST_SYS,
 542                 SUBST_ENV,
 543         };
 544         static const struct subst_map {
 545                 char *name;
 546                 char fmt;
 547                 enum subst_type type;
 548         } map[] = {
 549                 { .name = "devpath",    .fmt = 'p',     .type = SUBST_DEVPATH },
 550                 { .name = "number",     .fmt = 'n',     .type = SUBST_KERNEL_NUMBER },
 551                 { .name = "kernel",     .fmt = 'k',     .type = SUBST_KERNEL },
 552                 { .name = "id",         .fmt = 'b',     .type = SUBST_ID },
 553                 { .name = "driver",     .fmt = 'd',     .type = SUBST_DRIVER },
 554                 { .name = "major",      .fmt = 'M',     .type = SUBST_MAJOR },
 555                 { .name = "minor",      .fmt = 'm',     .type = SUBST_MINOR },
 556                 { .name = "result",     .fmt = 'c',     .type = SUBST_RESULT },
 557                 { .name = "attr",       .fmt = 's',     .type = SUBST_ATTR },
 558                 { .name = "sysfs",      .fmt = 's',     .type = SUBST_ATTR },
 559                 { .name = "parent",     .fmt = 'P',     .type = SUBST_PARENT },
 560                 { .name = "tempnode",   .fmt = 'N',     .type = SUBST_TEMP_NODE },
 561                 { .name = "name",       .fmt = 'D',     .type = SUBST_NAME },
 562                 { .name = "links",      .fmt = 'L',     .type = SUBST_LINKS },
 563                 { .name = "root",       .fmt = 'r',     .type = SUBST_ROOT },
 564                 { .name = "sys",        .fmt = 'S',     .type = SUBST_SYS },
 565                 { .name = "env",        .fmt = 'E',     .type = SUBST_ENV },
 566                 { NULL, '\0', 0 }
 567         };
 568         enum subst_type type;
 569         const struct subst_map *subst;
 570
 571         head = string;
 572         while (1) {
 573                 len = -1;
 574                 while (head[0] != '\0') {
 575                         if (head[0] == '$') {
 576                                 /* substitute named variable */
 577                                 if (head[1] == '\0')
 578                                         break;
 579                                 if (head[1] == '$') {
 580                                         util_strlcpy(temp, head+2, sizeof(temp));
 581                                         util_strlcpy(head+1, temp, maxsize);
 582                                         head++;
 583                                         continue;
 584                                 }
 585                                 head[0] = '\0';
 586                                 for (subst = map; subst->name; subst++) {
 587                                         if (strncasecmp(&head[1], subst->name, strlen(subst->name)) == 0) {
 588                                                 type = subst->type;
 589                                                 tail = head + strlen(subst->name)+1;
 590                                                 dbg(event->udev, "will substitute format name '%s'\n", subst->name);
 591                                                 goto found;
 592                                         }
 593                                 }
 594                                 head[0] = '$';
 595                                 err(event->udev, "unknown format variable '%s'\n", head);
 596                         } else if (head[0] == '%') {
 597                                 /* substitute format char */
 598                                 if (head[1] == '\0')
 599                                         break;
 600                                 if (head[1] == '%') {
 601                                         util_strlcpy(temp, head+2, sizeof(temp));
 602                                         util_strlcpy(head+1, temp, maxsize);
 603                                         head++;
 604                                         continue;
 605                                 }
 606                                 head[0] = '\0';
 607                                 tail = head+1;
 608                                 len = get_format_len(event->udev, &tail);
 609                                 for (subst = map; subst->name; subst++) {
 610                                         if (tail[0] == subst->fmt) {
 611                                                 type = subst->type;
 612                                                 tail++;
 613                                                 dbg(event->udev, "will substitute format char '%c'\n", subst->fmt);
 614                                                 goto found;
 615                                         }
 616                                 }
 617                                 head[0] = '%';
 618                                 err(event->udev, "unknown format char '%c'\n", tail[0]);
 619                         }
 620                         head++;
 621                 }
 622                 break;
 623 found:
 624                 attr = get_format_attribute(event->udev, &tail);
 625                 util_strlcpy(temp, tail, sizeof(temp));
 626                 dbg(event->udev, "format=%i, string='%s', tail='%s'\n", type ,string, tail);
 627
 628                 switch (type) {
 629                 case SUBST_DEVPATH:
 630                         util_strlcat(string, udev_device_get_devpath(dev), maxsize);
 631                         dbg(event->udev, "substitute devpath '%s'\n", udev_device_get_devpath(dev));
 632                         break;
 633                 case SUBST_KERNEL:
 634                         util_strlcat(string, udev_device_get_sysname(dev), maxsize);
 635                         dbg(event->udev, "substitute kernel name '%s'\n", udev_device_get_sysname(dev));
 636                         break;
 637                 case SUBST_KERNEL_NUMBER:
 638                         if (udev_device_get_sysnum(dev) == NULL)
 639                                 break;
 640                         util_strlcat(string, udev_device_get_sysnum(dev), maxsize);
 641                         dbg(event->udev, "substitute kernel number '%s'\n", udev_device_get_sysnum(dev));
 642                         break;
 643                 case SUBST_ID:
 644                         if (event->dev_parent != NULL) {
 645                                 util_strlcat(string, udev_device_get_sysname(event->dev_parent), maxsize);
 646                                 dbg(event->udev, "substitute id '%s'\n", udev_device_get_sysname(event->dev_parent));
 647                         }
 648                         break;
 649                 case SUBST_DRIVER:
 650                         if (event->dev_parent != NULL) {
 651                                 const char *driver = udev_device_get_driver(event->dev_parent);
 652
 653                                 if (driver == NULL)
 654                                         break;
 655                                 util_strlcat(string, driver, maxsize);
 656                                 dbg(event->udev, "substitute driver '%s'\n", driver);
 657                         }
 658                         break;
 659                 case SUBST_MAJOR:
 660                         sprintf(temp2, "%d", major(udev_device_get_devnum(dev)));
 661                         util_strlcat(string, temp2, maxsize);
 662                         dbg(event->udev, "substitute major number '%s'\n", temp2);
 663                         break;
 664                 case SUBST_MINOR:
 665                         sprintf(temp2, "%d", minor(udev_device_get_devnum(dev)));
 666                         util_strlcat(string, temp2, maxsize);
 667                         dbg(event->udev, "substitute minor number '%s'\n", temp2);
 668                         break;
 669                 case SUBST_RESULT:
 670                         if (event->program_result[0] == '\0')
 671                                 break;
 672                         /* get part part of the result string */
 673                         i = 0;
 674                         if (attr != NULL)
 675                                 i = strtoul(attr, &rest, 10);
 676                         if (i > 0) {
 677                                 dbg(event->udev, "request part #%d of result string\n", i);
 678                                 cpos = event->program_result;
 679                                 while (--i) {
 680                                         while (cpos[0] != '\0' && !isspace(cpos[0]))
 681                                                 cpos++;
 682                                         while (isspace(cpos[0]))
 683                                                 cpos++;
 684                                 }
 685                                 if (i > 0) {
 686                                         err(event->udev, "requested part of result string not found\n");
 687                                         break;
 688                                 }
 689                                 util_strlcpy(temp2, cpos, sizeof(temp2));
 690                                 /* %{2+}c copies the whole string from the second part on */
 691                                 if (rest[0] != '+') {
 692                                         cpos = strchr(temp2, ' ');
 693                                         if (cpos)
 694                                                 cpos[0] = '\0';
 695                                 }
 696                                 util_strlcat(string, temp2, maxsize);
 697                                 dbg(event->udev, "substitute part of result string '%s'\n", temp2);
 698                         } else {
 699                                 util_strlcat(string, event->program_result, maxsize);
 700                                 dbg(event->udev, "substitute result string '%s'\n", event->program_result);
 701                         }
 702                         break;
 703                 case SUBST_ATTR:
 704                         if (attr == NULL)
 705                                 err(event->udev, "missing file parameter for attr\n");
 706                         else {
 707                                 char *subsys;
 708                                 char *sysname;
 709                                 char *attrib;
 710                                 char value[UTIL_NAME_SIZE] = "";
 711                                 size_t size;
 712
 713                                 if (split_subsys_sysname(event->udev, attr, &subsys, &sysname, &attrib) == 0) {
 714                                         struct udev_device *d;
 715                                         const char *val;
 716
 717                                         if (attrib == NULL)
 718                                                 break;
 719                                         d = udev_device_new_from_subsystem_sysname(event->udev, subsys, sysname);
 720                                         if (d == NULL)
 721                                                 break;
 722                                         val = udev_device_get_attr_value(d, attrib);
 723                                         if (val != NULL)
 724                                                 util_strlcpy(value, val, sizeof(value));
 725                                         udev_device_unref(d);
 726                                 }
 727
 728                                 /* try the current device, other matches may have selected */
 729                                 if (value[0]=='\0' && event->dev_parent != NULL && event->dev_parent != event->dev) {
 730                                         const char *val;
 731
 732                                         val = udev_device_get_attr_value(event->dev_parent, attr);
 733                                         if (val != NULL)
 734                                                 util_strlcpy(value, val, sizeof(value));
 735                                 }
 736
 737                                 /* look at all devices along the chain of parents */
 738                                 if (value[0]=='\0') {
 739                                         struct udev_device *dev_parent = dev;
 740                                         const char *val;
 741
 742                                         do {
 743                                                 dbg(event->udev, "looking at '%s'\n", udev_device_get_syspath(dev_parent));
 744                                                 val = udev_device_get_attr_value(dev_parent, attr);
 745                                                 if (val != NULL) {
 746                                                         util_strlcpy(value, val, sizeof(value));
 747                                                         break;
 748                                                 }
 749                                                 dev_parent = udev_device_get_parent(dev_parent);
 750                                         } while (dev_parent != NULL);
 751                                 }
 752
 753                                 if (value[0]=='\0')
 754                                         break;
 755
 756                                 /* strip trailing whitespace, and replace unwanted characters */
 757                                 size = strlen(value);
 758                                 while (size > 0 && isspace(value[--size]))
 759                                         value[size] = '\0';
 760                                 count = util_replace_chars(value, ALLOWED_CHARS_INPUT);
 761                                 if (count > 0)
 762                                         info(event->udev, "%i character(s) replaced\n" , count);
 763                                 util_strlcat(string, value, maxsize);
 764                                 dbg(event->udev, "substitute sysfs value '%s'\n", value);
 765                         }
 766                         break;
 767                 case SUBST_PARENT:
 768                         {
 769                                 struct udev_device *dev_parent;
 770                                 const char *devnode;
 771
 772                                 dev_parent = udev_device_get_parent(event->dev);
 773                                 if (dev_parent == NULL)
 774                                         break;
 775                                 devnode = udev_device_get_devnode(dev_parent);
 776                                 if (devnode != NULL) {
 777                                         size_t devlen = strlen(udev_get_dev_path(event->udev))+1;
 778
 779                                         util_strlcat(string, &devnode[devlen], maxsize);
 780                                         dbg(event->udev, "found parent '%s', got node name '%s'\n",
 781                                             udev_device_get_syspath(dev_parent), &devnode[devlen]);
 782                                 }
 783                         }
 784                         break;
 785                 case SUBST_TEMP_NODE:
 786                         if (event->tmp_node[0] == '\0' && major(udev_device_get_devnum(dev)) > 0) {
 787                                 dbg(event->udev, "create temporary device node for callout\n");
 788                                 snprintf(event->tmp_node, sizeof(event->tmp_node), "%s/.tmp-%u-%u",
 789                                          udev_get_dev_path(event->udev),
 790                                          major(udev_device_get_devnum(dev)), minor(udev_device_get_devnum(dev)));
 791                                 udev_node_mknod(dev, event->tmp_node, makedev(0,0), 0600, 0, 0);
 792                         }
 793                         util_strlcat(string, event->tmp_node, maxsize);
 794                         dbg(event->udev, "substitute temporary device node name '%s'\n", event->tmp_node);
 795                         break;
 796                 case SUBST_NAME:
 797                         if (event->name != NULL) {
 798                                 util_strlcat(string, event->name, maxsize);
 799                                 dbg(event->udev, "substitute name '%s'\n", event->name);
 800                         } else {
 801                                 util_strlcat(string, udev_device_get_sysname(dev), maxsize);
 802                                 dbg(event->udev, "substitute sysname '%s'\n", udev_device_get_sysname(dev));
 803                         }
 804                         break;
 805                 case SUBST_LINKS:
 806                         {
 807                                 struct udev_list_entry *list_entry;
 808
 809                                 list_entry = udev_device_get_properties_list_entry(dev);
 810                                 util_strlcpy(string, udev_list_entry_get_name(list_entry), maxsize);
 811                                 udev_list_entry_foreach(list_entry, udev_list_entry_get_next(list_entry)) {
 812                                         util_strlcat(string, " ", maxsize);
 813                                         util_strlcat(string, udev_list_entry_get_name(list_entry), maxsize);
 814                                 }
 815                         }
 816                         break;
 817                 case SUBST_ROOT:
 818                         util_strlcat(string, udev_get_dev_path(event->udev), maxsize);
 819                         dbg(event->udev, "substitute udev_root '%s'\n", udev_get_dev_path(event->udev));
 820                         break;
 821                 case SUBST_SYS:
 822                         util_strlcat(string, udev_get_sys_path(event->udev), maxsize);
 823                         dbg(event->udev, "substitute sys_path '%s'\n", udev_get_sys_path(event->udev));
 824                         break;
 825                 case SUBST_ENV:
 826                         if (attr == NULL) {
 827                                 dbg(event->udev, "missing attribute\n");
 828                                 break;
 829                         } else {
 830                                 struct udev_list_entry *list_entry;
 831                                 const char *value;
 832
 833                                 list_entry = udev_device_get_properties_list_entry(event->dev);
 834                                 list_entry = udev_list_entry_get_by_name(list_entry, attr);
 835                                 if (list_entry == NULL)
 836                                         break;
 837                                 value = udev_list_entry_get_value(list_entry);
 838                                 dbg(event->udev, "substitute env '%s=%s'\n", attr, value);
 839                                 util_strlcat(string, value, maxsize);
 840                                 break;
 841                         }
 842                 default:
 843                         err(event->udev, "unknown substitution type=%i\n", type);
 844                         break;
 845                 }
 846                 /* possibly truncate to format-char specified length */
 847                 if (len >= 0 && len < (int)strlen(head)) {
 848                         head[len] = '\0';
 849                         dbg(event->udev, "truncate to %i chars, subtitution string becomes '%s'\n", len, head);
 850                 }
 851                 util_strlcat(string, temp, maxsize);
 852         }
 853 }
 854
 855 static char *key_val(struct udev_rule *rule, struct key *key)
 856 {
 857         return rule->buf + key->val_off;
 858 }
 859
 860 static char *key_pair_name(struct udev_rule *rule, struct key_pair *pair)
 861 {
 862         return rule->buf + pair->key_name_off;
 863 }
 864
 865 static int match_key(struct udev *udev, const char *key_name, struct udev_rule *rule, struct key *key, const char *val)
 866 {
 867         char value[UTIL_PATH_SIZE];
 868         char *key_value;
 869         char *pos;
 870         int match = 0;
 871
 872         if (key->operation != KEY_OP_MATCH &&
 873             key->operation != KEY_OP_NOMATCH)
 874                 return 0;
 875
 876         if (val == NULL)
 877                 val = "";
 878
 879         /* look for a matching string, parts are separated by '|' */
 880         util_strlcpy(value, rule->buf + key->val_off, sizeof(value));
 881         key_value = value;
 882         dbg(udev, "key %s value='%s'\n", key_name, key_value);
 883         while (key_value != NULL) {
 884                 pos = strchr(key_value, '|');
 885                 if (pos != NULL) {
 886                         pos[0] = '\0';
 887                         pos = &pos[1];
 888                 }
 889
 890                 dbg(udev, "match %s '%s' <-> '%s'\n", key_name, key_value, val);
 891                 match = (fnmatch(key_value, val, 0) == 0);
 892                 if (match)
 893                         break;
 894
 895                 key_value = pos;
 896         }
 897
 898         if (match && (key->operation == KEY_OP_MATCH)) {
 899                 dbg(udev, "%s is true (matching value)\n", key_name);
 900                 return 0;
 901         }
 902         if (!match && (key->operation == KEY_OP_NOMATCH)) {
 903                 dbg(udev, "%s is true (non-matching value)\n", key_name);
 904                 return 0;
 905         }
 906         return -1;
 907 }
 908
 909 /* match a single rule against a given device and possibly its parent devices */
 910 static int match_rule(struct udev_event *event, struct udev_rule *rule)
 911 {
 912         struct udev_device *dev = event->dev;
 913         int i;
 914
 915         if (match_key(event->udev, "ACTION", rule, &rule->action, udev_device_get_action(dev)))
 916                 goto nomatch;
 917
 918         if (match_key(event->udev, "KERNEL", rule, &rule->kernel, udev_device_get_sysname(dev)))
 919                 goto nomatch;
 920
 921         if (match_key(event->udev, "SUBSYSTEM", rule, &rule->subsystem, udev_device_get_subsystem(dev)))
 922                 goto nomatch;
 923
 924         if (match_key(event->udev, "DEVPATH", rule, &rule->devpath, udev_device_get_devpath(dev)))
 925                 goto nomatch;
 926
 927         if (match_key(event->udev, "DRIVER", rule, &rule->driver, udev_device_get_driver(dev)))
 928                 goto nomatch;
 929
 930         /* match NAME against a value assigned by an earlier rule */
 931         if (match_key(event->udev, "NAME", rule, &rule->name, event->name))
 932                 goto nomatch;
 933
 934         /* match against current list of symlinks */
 935         if (rule->symlink_match.operation == KEY_OP_MATCH ||
 936             rule->symlink_match.operation == KEY_OP_NOMATCH) {
 937                 size_t devlen = strlen(udev_get_dev_path(event->udev))+1;
 938                 struct udev_list_entry *list_entry;
 939                 int match = 0;
 940
 941                 udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(dev)) {
 942                         const char *devlink;
 943
 944                         devlink =  &udev_list_entry_get_name(list_entry)[devlen];
 945                         if (match_key(event->udev, "SYMLINK", rule, &rule->symlink_match, devlink) == 0) {
 946                                 match = 1;
 947                                 break;
 948                         }
 949                 }
 950                 if (!match)
 951                         goto nomatch;
 952         }
 953
 954         for (i = 0; i < rule->env.count; i++) {
 955                 struct key_pair *pair = &rule->env.keys[i];
 956
 957                 /* we only check for matches, assignments will be handled later */
 958                 if (pair->key.operation == KEY_OP_MATCH ||
 959                     pair->key.operation == KEY_OP_NOMATCH) {
 960                         struct udev_list_entry *list_entry;
 961                         const char *key_name = key_pair_name(rule, pair);
 962                         const char *value;
 963
 964                         list_entry = udev_device_get_properties_list_entry(event->dev);
 965                         list_entry = udev_list_entry_get_by_name(list_entry, key_name);
 966                         value = udev_list_entry_get_value(list_entry);
 967                         if (value == NULL) {
 968                                 dbg(event->udev, "ENV{%s} is not set, treat as empty\n", key_name);
 969                                 value = "";
 970                         }
 971                         if (match_key(event->udev, "ENV", rule, &pair->key, value))
 972                                 goto nomatch;
 973                 }
 974         }
 975
 976         if (rule->test.operation == KEY_OP_MATCH ||
 977             rule->test.operation == KEY_OP_NOMATCH) {
 978                 char filename[UTIL_PATH_SIZE];
 979                 char *subsys;
 980                 char *sysname;
 981                 char *attrib;
 982                 struct stat statbuf;
 983                 int match;
 984
 985                 util_strlcpy(filename, key_val(rule, &rule->test), sizeof(filename));
 986                 udev_rules_apply_format(event, filename, sizeof(filename));
 987
 988                 if (split_subsys_sysname(event->udev, filename, &subsys, &sysname, &attrib) == 0) {
 989                         struct udev_device *d;
 990                         d = udev_device_new_from_subsystem_sysname(event->udev, subsys, sysname);
 991                         if (d != NULL) {
 992                                 util_strlcpy(filename, udev_device_get_syspath(d), sizeof(filename));
 993                                 if (attrib != NULL) {
 994                                         util_strlcat(filename, "/", sizeof(filename));
 995                                         util_strlcat(filename, attrib, sizeof(filename));
 996                                 }
 997                                 udev_device_unref(d);
 998                         }
 999                 } else if (filename[0] != '/') {
1000                         char tmp[UTIL_PATH_SIZE];
1001
1002                         util_strlcpy(tmp, udev_device_get_syspath(dev), sizeof(tmp));
1003                         util_strlcat(tmp, "/", sizeof(tmp));
1004                         util_strlcat(tmp, filename, sizeof(tmp));
1005                         util_strlcpy(filename, tmp, sizeof(filename));
1006                 }
1007
1008                 attr_subst_subdir(filename, sizeof(filename));
1009
1010                 match = (stat(filename, &statbuf) == 0);
1011                 info(event->udev, "'%s' %s", filename, match ? "exists\n" : "does not exist\n");
1012                 if (match && rule->test_mode_mask > 0) {
1013                         match = ((statbuf.st_mode & rule->test_mode_mask) > 0);
1014                         info(event->udev, "'%s' has mode=%#o and %s %#o\n", filename, statbuf.st_mode,
1015                              match ? "matches" : "does not match",
1016                              rule->test_mode_mask);
1017                 }
1018                 if (match && rule->test.operation == KEY_OP_NOMATCH)
1019                         goto nomatch;
1020                 if (!match && rule->test.operation == KEY_OP_MATCH)
1021                         goto nomatch;
1022                 dbg(event->udev, "TEST key is true\n");
1023         }
1024
1025         if (rule->wait_for.operation != KEY_OP_UNSET) {
1026                 char filename[UTIL_PATH_SIZE];
1027                 int found;
1028
1029                 util_strlcpy(filename, key_val(rule, &rule->wait_for), sizeof(filename));
1030                 udev_rules_apply_format(event, filename, sizeof(filename));
1031                 found = (wait_for_file(event, filename, 10) == 0);
1032                 if (!found && (rule->wait_for.operation != KEY_OP_NOMATCH))
1033                         goto nomatch;
1034         }
1035
1036         /* check for matching sysfs attribute pairs */
1037         for (i = 0; i < rule->attr.count; i++) {
1038                 struct key_pair *pair = &rule->attr.keys[i];
1039
1040                 if (pair->key.operation == KEY_OP_MATCH ||
1041                     pair->key.operation == KEY_OP_NOMATCH) {
1042                         char attr[UTIL_PATH_SIZE];
1043                         const char *key_name = key_pair_name(rule, pair);
1044                         const char *key_value = key_val(rule, &pair->key);
1045                         char *subsys;
1046                         char *sysname;
1047                         char *attrib;
1048                         char value[UTIL_NAME_SIZE] = "";
1049                         size_t len;
1050
1051                         util_strlcpy(attr, key_name, sizeof(attr));
1052                         if (split_subsys_sysname(event->udev, attr, &subsys, &sysname, &attrib) == 0) {
1053                                 struct udev_device *d;
1054                                 const char *val;
1055
1056                                 if (attrib == NULL)
1057                                         goto nomatch;
1058                                 d = udev_device_new_from_subsystem_sysname(event->udev, subsys, sysname);
1059                                 if (d == NULL)
1060                                         goto nomatch;
1061                                 val = udev_device_get_attr_value(d, attrib);
1062                                 if (val != NULL)
1063                                         util_strlcpy(value, val, sizeof(value));
1064                                 udev_device_unref(d);
1065                         }
1066
1067                         if (value[0]=='\0') {
1068                                 const char *val;
1069
1070                                 val = udev_device_get_attr_value(dev, key_name);
1071                                 if (val != NULL)
1072                                         util_strlcpy(value, val, sizeof(value));
1073                         }
1074
1075                         if (value[0]=='\0')
1076                                 goto nomatch;
1077
1078                         /* strip trailing whitespace of value, if not asked to match for it */
1079                         len = strlen(key_value);
1080                         if (len > 0 && !isspace(key_value[len-1])) {
1081                                 len = strlen(value);
1082                                 while (len > 0 && isspace(value[--len]))
1083                                         value[len] = '\0';
1084                                 dbg(event->udev, "removed trailing whitespace from '%s'\n", value);
1085                         }
1086
1087                         if (match_key(event->udev, "ATTR", rule, &pair->key, value))
1088                                 goto nomatch;
1089                 }
1090         }
1091
1092         /* walk up the chain of parent devices and find a match */
1093         event->dev_parent = dev;
1094         while (1) {
1095                 /* check for matching kernel device name */
1096                 if (match_key(event->udev, "KERNELS", rule,
1097                               &rule->kernels, udev_device_get_sysname(event->dev_parent)))
1098                         goto try_parent;
1099
1100                 /* check for matching subsystem value */
1101                 if (match_key(event->udev, "SUBSYSTEMS", rule,
1102                               &rule->subsystems, udev_device_get_subsystem(event->dev_parent)))
1103                         goto try_parent;
1104
1105                 /* check for matching driver */
1106                 if (match_key(event->udev, "DRIVERS", rule,
1107                               &rule->drivers, udev_device_get_driver(event->dev_parent)))
1108                         goto try_parent;
1109
1110                 /* check for matching sysfs attribute pairs */
1111                 for (i = 0; i < rule->attrs.count; i++) {
1112                         struct key_pair *pair = &rule->attrs.keys[i];
1113
1114                         if (pair->key.operation == KEY_OP_MATCH ||
1115                             pair->key.operation == KEY_OP_NOMATCH) {
1116                                 const char *key_name = key_pair_name(rule, pair);
1117                                 const char *key_value = key_val(rule, &pair->key);
1118                                 const char *val;
1119                                 char value[UTIL_NAME_SIZE];
1120                                 size_t len;
1121
1122                                 val = udev_device_get_attr_value(event->dev_parent, key_name);
1123                                 if (val == NULL)
1124                                         val = udev_device_get_attr_value(dev, key_name);
1125                                 if (val == NULL)
1126                                         goto try_parent;
1127                                 util_strlcpy(value, val, sizeof(value));
1128
1129                                 /* strip trailing whitespace of value, if not asked to match for it */
1130                                 len = strlen(key_value);
1131                                 if (len > 0 && !isspace(key_value[len-1])) {
1132                                         len = strlen(value);
1133                                         while (len > 0 && isspace(value[--len]))
1134                                                 value[len] = '\0';
1135                                         dbg(event->udev, "removed trailing whitespace from '%s'\n", value);
1136                                 }
1137
1138                                 if (match_key(event->udev, "ATTRS", rule, &pair->key, value))
1139                                         goto try_parent;
1140                         }
1141                 }
1142
1143                 /* found matching device  */
1144                 break;
1145 try_parent:
1146                 /* move to parent device */
1147                 dbg(event->udev, "try parent sysfs device\n");
1148                 event->dev_parent = udev_device_get_parent(event->dev_parent);
1149                 if (event->dev_parent == NULL)
1150                         goto nomatch;
1151                 dbg(event->udev, "looking at dev_parent->devpath='%s'\n",
1152                     udev_device_get_syspath(event->dev_parent));
1153         }
1154
1155         /* execute external program */
1156         if (rule->program.operation != KEY_OP_UNSET) {
1157                 char program[UTIL_PATH_SIZE];
1158                 char **envp;
1159                 char result[UTIL_PATH_SIZE];
1160
1161                 util_strlcpy(program, key_val(rule, &rule->program), sizeof(program));
1162                 udev_rules_apply_format(event, program, sizeof(program));
1163                 envp = udev_device_get_properties_envp(dev);
1164                 if (run_program(event->udev, program, envp, result, sizeof(result), NULL) != 0) {
1165                         dbg(event->udev, "PROGRAM is false\n");
1166                         event->program_result[0] = '\0';
1167                         if (rule->program.operation != KEY_OP_NOMATCH)
1168                                 goto nomatch;
1169                 } else {
1170                         int count;
1171
1172                         dbg(event->udev, "PROGRAM matches\n");
1173                         util_remove_trailing_chars(result, '\n');
1174                         if (rule->string_escape == ESCAPE_UNSET ||
1175                             rule->string_escape == ESCAPE_REPLACE) {
1176                                 count = util_replace_chars(result, ALLOWED_CHARS_INPUT);
1177                                 if (count > 0)
1178                                         info(event->udev, "%i character(s) replaced\n" , count);
1179                         }
1180                         dbg(event->udev, "result is '%s'\n", result);
1181                         util_strlcpy(event->program_result, result, sizeof(event->program_result));
1182                         dbg(event->udev, "PROGRAM returned successful\n");
1183                         if (rule->program.operation == KEY_OP_NOMATCH)
1184                                 goto nomatch;
1185                 }
1186                 dbg(event->udev, "PROGRAM key is true\n");
1187         }
1188
1189         /* check for matching result of external program */
1190         if (match_key(event->udev, "RESULT", rule, &rule->result, event->program_result))
1191                 goto nomatch;
1192
1193         /* import variables returned from program or or file into properties */
1194         if (rule->import.operation != KEY_OP_UNSET) {
1195                 char import[UTIL_PATH_SIZE];
1196                 int rc = -1;
1197
1198                 util_strlcpy(import, key_val(rule, &rule->import), sizeof(import));
1199                 udev_rules_apply_format(event, import, sizeof(import));
1200                 dbg(event->udev, "check for IMPORT import='%s'\n", import);
1201                 if (rule->import_type == IMPORT_PROGRAM) {
1202                         rc = import_program_into_env(event->dev, import);
1203                 } else if (rule->import_type == IMPORT_FILE) {
1204                         dbg(event->udev, "import file import='%s'\n", import);
1205                         rc = import_file_into_env(event->dev, import);
1206                 } else if (rule->import_type == IMPORT_PARENT) {
1207                         dbg(event->udev, "import parent import='%s'\n", import);
1208                         rc = import_parent_into_env(event->dev, import);
1209                 }
1210                 if (rc != 0) {
1211                         dbg(event->udev, "IMPORT failed\n");
1212                         if (rule->import.operation != KEY_OP_NOMATCH)
1213                                 goto nomatch;
1214                 } else
1215                         dbg(event->udev, "IMPORT '%s' imported\n", key_val(rule, &rule->import));
1216                 dbg(event->udev, "IMPORT key is true\n");
1217         }
1218
1219         /* rule matches, if we have ENV assignments export it */
1220         for (i = 0; i < rule->env.count; i++) {
1221                 struct key_pair *pair = &rule->env.keys[i];
1222
1223                 if (pair->key.operation == KEY_OP_ASSIGN) {
1224                         char temp_value[UTIL_NAME_SIZE];
1225                         const char *key_name = key_pair_name(rule, pair);
1226                         const char *value = key_val(rule, &pair->key);
1227
1228                         /* make sure we don't write to the same string we possibly read from */
1229                         util_strlcpy(temp_value, value, sizeof(temp_value));
1230                         udev_rules_apply_format(event, temp_value, sizeof(temp_value));
1231
1232                         if (temp_value[0] != '\0') {
1233                                 struct udev_list_entry *entry;
1234
1235                                 info(event->udev, "set ENV '%s=%s'\n", key_name, temp_value);
1236                                 entry = udev_device_add_property(dev, key_name, temp_value);
1237                                 /* store in db */
1238                                 udev_list_entry_set_flag(entry, 1);
1239                         }
1240                 }
1241         }
1242
1243         /* if we have ATTR assignments, write value to sysfs file */
1244         for (i = 0; i < rule->attr.count; i++) {
1245                 struct key_pair *pair = &rule->attr.keys[i];
1246
1247                 if (pair->key.operation == KEY_OP_ASSIGN) {
1248                         const char *key_name = key_pair_name(rule, pair);
1249                         char *subsys;
1250                         char *sysname;
1251                         char *attrib;
1252                         char attr[UTIL_PATH_SIZE];
1253                         char value[UTIL_NAME_SIZE];
1254                         FILE *f;
1255
1256                         util_strlcpy(attr, key_name, sizeof(attr));
1257                         if (split_subsys_sysname(event->udev, attr, &subsys, &sysname, &attrib) == 0) {
1258                                 struct udev_device *d;
1259
1260                                 d = udev_device_new_from_subsystem_sysname(event->udev, subsys, sysname);
1261                                 if (d != NULL) {
1262                                         util_strlcpy(attr, udev_device_get_syspath(d), sizeof(attr));
1263                                         if (attrib != NULL) {
1264                                                 util_strlcat(attr, "/", sizeof(attr));
1265                                                 util_strlcat(attr, attrib, sizeof(attr));
1266                                         }
1267                                         udev_device_unref(d);
1268                                 }
1269                         } else {
1270                                 util_strlcpy(attr, udev_device_get_syspath(dev), sizeof(attr));
1271                                 util_strlcat(attr, "/", sizeof(attr));
1272                                 util_strlcat(attr, key_name, sizeof(attr));
1273                         }
1274
1275                         attr_subst_subdir(attr, sizeof(attr));
1276
1277                         util_strlcpy(value, key_val(rule, &pair->key), sizeof(value));
1278                         udev_rules_apply_format(event, value, sizeof(value));
1279                         info(event->udev, "writing '%s' to sysfs file '%s'\n", value, attr);
1280                         f = fopen(attr, "w");
1281                         if (f != NULL) {
1282                                 if (!event->test)
1283                                         if (fprintf(f, "%s", value) <= 0)
1284                                                 err(event->udev, "error writing ATTR{%s}: %m\n", attr);
1285                                 fclose(f);
1286                         } else
1287                                 err(event->udev, "error opening ATTR{%s} for writing: %m\n", attr);
1288                 }
1289         }
1290         return 0;
1291
1292 nomatch:
1293         return -1;
1294 }
1295
1296 int udev_rules_get_name(struct udev_rules *rules, struct udev_event *event)
1297 {
1298         struct udev_device *dev = event->dev;
1299         struct udev_rules_iter iter;
1300         struct udev_rule *rule;
1301         int name_set = 0;
1302
1303         dbg(event->udev, "device: '%s'\n", udev_device_get_syspath(dev));
1304
1305         /* look for a matching rule to apply */
1306         udev_rules_iter_init(&iter, rules);
1307         while (1) {
1308                 rule = udev_rules_iter_next(&iter);
1309                 if (rule == NULL)
1310                         break;
1311
1312                 if (name_set &&
1313                     (rule->name.operation == KEY_OP_ASSIGN ||
1314                      rule->name.operation == KEY_OP_ASSIGN_FINAL ||
1315                      rule->name.operation == KEY_OP_ADD)) {
1316                         dbg(event->udev, "node name already set, rule ignored\n");
1317                         continue;
1318                 }
1319
1320                 dbg(event->udev, "process rule\n");
1321                 if (match_rule(event, rule) == 0) {
1322                         /* apply options */
1323                         if (rule->ignore_device) {
1324                                 info(event->udev, "rule applied, '%s' is ignored\n", udev_device_get_sysname(dev));
1325                                 event->ignore_device = 1;
1326                                 return 0;
1327                         }
1328                         if (rule->ignore_remove) {
1329                                 udev_device_set_ignore_remove(dev, 1);
1330                                 dbg(event->udev, "remove event should be ignored\n");
1331                         }
1332                         if (rule->link_priority != 0) {
1333                                 udev_device_set_devlink_priority(dev, rule->link_priority);
1334                                 info(event->udev, "devlink_priority=%i\n", rule->link_priority);
1335                         }
1336                         if (rule->event_timeout >= 0) {
1337                                 udev_device_set_event_timeout(dev, rule->event_timeout);
1338                                 info(event->udev, "event_timeout=%i\n", rule->event_timeout);
1339                         }
1340                         /* apply all_partitions option only at a disk device */
1341                         if (rule->partitions > 0 &&
1342                             strcmp(udev_device_get_subsystem(dev), "block") == 0 &&
1343                             udev_device_get_sysnum(dev) == NULL) {
1344                                 udev_device_set_num_fake_partitions(dev, rule->partitions);
1345                                 dbg(event->udev, "creation of partition nodes requested\n");
1346                         }
1347
1348                         /* apply permissions */
1349                         if (!event->mode_final && rule->mode.operation != KEY_OP_UNSET) {
1350                                 if (rule->mode.operation == KEY_OP_ASSIGN_FINAL)
1351                                         event->mode_final = 1;
1352                                 char buf[20];
1353                                 util_strlcpy(buf, key_val(rule, &rule->mode), sizeof(buf));
1354                                 udev_rules_apply_format(event, buf, sizeof(buf));
1355                                 event->mode = strtol(buf, NULL, 8);
1356                                 dbg(event->udev, "applied mode=%#o to '%s'\n",
1357                                     event->mode, udev_device_get_sysname(dev));
1358                         }
1359                         if (!event->owner_final && rule->owner.operation != KEY_OP_UNSET) {
1360                                 if (rule->owner.operation == KEY_OP_ASSIGN_FINAL)
1361                                         event->owner_final = 1;
1362                                 util_strlcpy(event->owner, key_val(rule, &rule->owner), sizeof(event->owner));
1363                                 udev_rules_apply_format(event, event->owner, sizeof(event->owner));
1364                                 dbg(event->udev, "applied owner='%s' to '%s'\n",
1365                                     event->owner, udev_device_get_sysname(dev));
1366                         }
1367                         if (!event->group_final && rule->group.operation != KEY_OP_UNSET) {
1368                                 if (rule->group.operation == KEY_OP_ASSIGN_FINAL)
1369                                         event->group_final = 1;
1370                                 util_strlcpy(event->group, key_val(rule, &rule->group), sizeof(event->group));
1371                                 udev_rules_apply_format(event, event->group, sizeof(event->group));
1372                                 dbg(event->udev, "applied group='%s' to '%s'\n",
1373                                     event->group, udev_device_get_sysname(dev));
1374                         }
1375
1376                         /* collect symlinks */
1377                         if (!event->devlink_final &&
1378                             (rule->symlink.operation == KEY_OP_ASSIGN ||
1379                              rule->symlink.operation == KEY_OP_ASSIGN_FINAL ||
1380                              rule->symlink.operation == KEY_OP_ADD)) {
1381                                 char temp[UTIL_PATH_SIZE];
1382                                 char filename[UTIL_PATH_SIZE];
1383                                 char *pos, *next;
1384                                 int count = 0;
1385
1386                                 if (rule->symlink.operation == KEY_OP_ASSIGN_FINAL)
1387                                         event->devlink_final = 1;
1388                                 if (rule->symlink.operation == KEY_OP_ASSIGN ||
1389                                     rule->symlink.operation == KEY_OP_ASSIGN_FINAL) {
1390                                         info(event->udev, "reset symlink list\n");
1391                                         udev_device_cleanup_devlinks_list(dev);
1392                                 }
1393                                 /* allow  multiple symlinks separated by spaces */
1394                                 util_strlcpy(temp, key_val(rule, &rule->symlink), sizeof(temp));
1395                                 udev_rules_apply_format(event, temp, sizeof(temp));
1396                                 if (rule->string_escape == ESCAPE_UNSET)
1397                                         count = util_replace_chars(temp, ALLOWED_CHARS_FILE " ");
1398                                 else if (rule->string_escape == ESCAPE_REPLACE)
1399                                         count = util_replace_chars(temp, ALLOWED_CHARS_FILE);
1400                                 if (count > 0)
1401                                         info(event->udev, "%i character(s) replaced\n" , count);
1402                                 dbg(event->udev, "rule applied, added symlink(s) '%s'\n", temp);
1403                                 pos = temp;
1404                                 while (isspace(pos[0]))
1405                                         pos++;
1406                                 next = strchr(pos, ' ');
1407                                 while (next) {
1408                                         next[0] = '\0';
1409                                         info(event->udev, "add symlink '%s'\n", pos);
1410                                         util_strlcpy(filename, udev_get_dev_path(event->udev), sizeof(filename));
1411                                         util_strlcat(filename, "/", sizeof(filename));
1412                                         util_strlcat(filename, pos, sizeof(filename));
1413                                         udev_device_add_devlink(dev, filename);
1414                                         while (isspace(next[1]))
1415                                                 next++;
1416                                         pos = &next[1];
1417                                         next = strchr(pos, ' ');
1418                                 }
1419                                 if (pos[0] != '\0') {
1420                                         info(event->udev, "add symlink '%s'\n", pos);
1421                                         util_strlcpy(filename, udev_get_dev_path(event->udev), sizeof(filename));
1422                                         util_strlcat(filename, "/", sizeof(filename));
1423                                         util_strlcat(filename, pos, sizeof(filename));
1424                                         udev_device_add_devlink(dev, filename);
1425                                 }
1426                         }
1427
1428                         /* set name, later rules with name set will be ignored */
1429                         if (rule->name.operation == KEY_OP_ASSIGN ||
1430                             rule->name.operation == KEY_OP_ASSIGN_FINAL ||
1431                             rule->name.operation == KEY_OP_ADD) {
1432                                 int count;
1433
1434                                 name_set = 1;
1435                                 util_strlcpy(event->name, key_val(rule, &rule->name), sizeof(event->name));
1436                                 udev_rules_apply_format(event, event->name, sizeof(event->name));
1437                                 if (rule->string_escape == ESCAPE_UNSET ||
1438                                     rule->string_escape == ESCAPE_REPLACE) {
1439                                         count = util_replace_chars(event->name, ALLOWED_CHARS_FILE);
1440                                         if (count > 0)
1441                                                 info(event->udev, "%i character(s) replaced\n", count);
1442                                 }
1443
1444                                 info(event->udev, "rule applied, '%s' becomes '%s'\n",
1445                                      udev_device_get_sysname(dev), event->name);
1446                                 if (strcmp(udev_device_get_subsystem(dev), "net") != 0)
1447                                         dbg(event->udev, "'%s' owner='%s', group='%s', mode=%#o partitions=%i\n",
1448                                             event->name, event->owner, event->group, event->mode,
1449                                             udev_device_get_num_fake_partitions(dev));
1450                         }
1451
1452                         if (!event->run_final && rule->run.operation != KEY_OP_UNSET) {
1453                                 struct udev_list_entry *list_entry;
1454
1455                                 if (rule->run.operation == KEY_OP_ASSIGN_FINAL)
1456                                         event->run_final = 1;
1457                                 if (rule->run.operation == KEY_OP_ASSIGN || rule->run.operation == KEY_OP_ASSIGN_FINAL) {
1458                                         info(event->udev, "reset run list\n");
1459                                         udev_list_cleanup(event->udev, &event->run_list);
1460                                 }
1461                                 dbg(event->udev, "add run '%s'\n", key_val(rule, &rule->run));
1462                                 list_entry = udev_list_entry_add(event->udev, &event->run_list,
1463                                                                  key_val(rule, &rule->run), NULL, 1, 0);
1464                                 if (rule->run_ignore_error && list_entry != NULL)
1465                                         udev_list_entry_set_flag(list_entry, 1);
1466                         }
1467
1468                         if (rule->last_rule) {
1469                                 dbg(event->udev, "last rule to be applied\n");
1470                                 break;
1471                         }
1472
1473                         if (rule->goto_label.operation != KEY_OP_UNSET) {
1474                                 dbg(event->udev, "moving forward to label '%s'\n", key_val(rule, &rule->goto_label));
1475                                 udev_rules_iter_goto(&iter, rule->goto_rule_off);
1476                         }
1477                 }
1478         }
1479
1480         if (!name_set) {
1481                 info(event->udev, "no node name set, will use kernel name '%s'\n",
1482                      udev_device_get_sysname(dev));
1483                 util_strlcpy(event->name, udev_device_get_sysname(dev), sizeof(event->name));
1484         }
1485
1486         if (event->tmp_node[0] != '\0') {
1487                 dbg(event->udev, "removing temporary device node\n");
1488                 unlink_secure(event->udev, event->tmp_node);
1489                 event->tmp_node[0] = '\0';
1490         }
1491         return 0;
1492 }
1493
1494 int udev_rules_get_run(struct udev_rules *rules, struct udev_event *event)
1495 {
1496         struct udev_device *dev = event->dev;
1497         struct udev_rules_iter iter;
1498         struct udev_rule *rule;
1499
1500         dbg(event->udev, "sysname: '%s'\n", udev_device_get_sysname(dev));
1501
1502         /* look for a matching rule to apply */
1503         udev_rules_iter_init(&iter, rules);
1504         while (1) {
1505                 rule = udev_rules_iter_next(&iter);
1506                 if (rule == NULL)
1507                         break;
1508
1509                 dbg(event->udev, "process rule\n");
1510                 if (rule->name.operation == KEY_OP_ASSIGN ||
1511                     rule->name.operation == KEY_OP_ASSIGN_FINAL ||
1512                     rule->name.operation == KEY_OP_ADD ||
1513                     rule->symlink.operation == KEY_OP_ASSIGN ||
1514                     rule->symlink.operation == KEY_OP_ASSIGN_FINAL ||
1515                     rule->symlink.operation == KEY_OP_ADD ||
1516                     rule->mode.operation != KEY_OP_UNSET ||
1517                     rule->owner.operation != KEY_OP_UNSET || rule->group.operation != KEY_OP_UNSET) {
1518                         dbg(event->udev, "skip rule that names a device\n");
1519                         continue;
1520                 }
1521
1522                 if (match_rule(event, rule) == 0) {
1523                         if (rule->ignore_device) {
1524                                 info(event->udev, "rule applied, '%s' is ignored\n", udev_device_get_sysname(dev));
1525                                 event->ignore_device = 1;
1526                                 return 0;
1527                         }
1528                         if (rule->ignore_remove) {
1529                                 udev_device_set_ignore_remove(dev, 1);
1530                                 dbg(event->udev, "remove event should be ignored\n");
1531                         }
1532
1533                         if (!event->run_final && rule->run.operation != KEY_OP_UNSET) {
1534                                 struct udev_list_entry *list_entry;
1535
1536                                 if (rule->run.operation == KEY_OP_ASSIGN ||
1537                                     rule->run.operation == KEY_OP_ASSIGN_FINAL) {
1538                                         info(event->udev, "reset run list\n");
1539                                         udev_list_cleanup(event->udev, &event->run_list);
1540                                 }
1541                                 dbg(event->udev, "add run '%s'\n", key_val(rule, &rule->run));
1542                                 list_entry = udev_list_entry_add(event->udev, &event->run_list,
1543                                                                  key_val(rule, &rule->run), NULL, 1, 0);
1544                                 if (rule->run_ignore_error && list_entry != NULL)
1545                                         udev_list_entry_set_flag(list_entry, 1);
1546                                 if (rule->run.operation == KEY_OP_ASSIGN_FINAL)
1547                                         break;
1548                         }
1549
1550                         if (rule->last_rule) {
1551                                 dbg(event->udev, "last rule to be applied\n");
1552                                 break;
1553                         }
1554
1555                         if (rule->goto_label.operation != KEY_OP_UNSET) {
1556                                 dbg(event->udev, "moving forward to label '%s'\n", key_val(rule, &rule->goto_label));
1557                                 udev_rules_iter_goto(&iter, rule->goto_rule_off);
1558                         }
1559                 }
1560         }
1561
1562         return 0;
1563 }
1564
1565 static int get_key(struct udev_rules *rules, char **line, char **key, enum key_operation *operation, char **value)
1566 {
1567         char *linepos;
1568         char *temp;
1569
1570         linepos = *line;
1571         if (linepos == NULL && linepos[0] == '\0')
1572                 return -1;
1573
1574         /* skip whitespace */
1575         while (isspace(linepos[0]) || linepos[0] == ',')
1576                 linepos++;
1577
1578         /* get the key */
1579         if (linepos[0] == '\0')
1580                 return -1;
1581         *key = linepos;
1582
1583         while (1) {
1584                 linepos++;
1585                 if (linepos[0] == '\0')
1586                         return -1;
1587                 if (isspace(linepos[0]))
1588                         break;
1589                 if (linepos[0] == '=')
1590                         break;
1591                 if ((linepos[0] == '+') || (linepos[0] == '!') || (linepos[0] == ':'))
1592                         if (linepos[1] == '=')
1593                                 break;
1594         }
1595
1596         /* remember end of key */
1597         temp = linepos;
1598
1599         /* skip whitespace after key */
1600         while (isspace(linepos[0]))
1601                 linepos++;
1602         if (linepos[0] == '\0')
1603                 return -1;
1604
1605         /* get operation type */
1606         if (linepos[0] == '=' && linepos[1] == '=') {
1607                 *operation = KEY_OP_MATCH;
1608                 linepos += 2;
1609                 dbg(rules->udev, "match:\n");
1610         } else if (linepos[0] == '!' && linepos[1] == '=') {
1611                 *operation = KEY_OP_NOMATCH;
1612                 linepos += 2;
1613                 dbg(rules->udev, "nomatch:\n");
1614         } else if (linepos[0] == '+' && linepos[1] == '=') {
1615                 *operation = KEY_OP_ADD;
1616                 linepos += 2;
1617                 dbg(rules->udev, "add:\n");
1618         } else if (linepos[0] == '=') {
1619                 *operation = KEY_OP_ASSIGN;
1620                 linepos++;
1621                 dbg(rules->udev, "assign:\n");
1622         } else if (linepos[0] == ':' && linepos[1] == '=') {
1623                 *operation = KEY_OP_ASSIGN_FINAL;
1624                 linepos += 2;
1625                 dbg(rules->udev, "assign_final:\n");
1626         } else
1627                 return -1;
1628
1629         /* terminate key */
1630         temp[0] = '\0';
1631
1632         /* skip whitespace after operator */
1633         while (isspace(linepos[0]))
1634                 linepos++;
1635         if (linepos[0] == '\0')
1636                 return -1;
1637
1638         /* get the value*/
1639         if (linepos[0] == '"')
1640                 linepos++;
1641         else
1642                 return -1;
1643         *value = linepos;
1644
1645         temp = strchr(linepos, '"');
1646         if (!temp)
1647                 return -1;
1648         temp[0] = '\0';
1649         temp++;
1650         dbg(rules->udev, "'%s'-'%s'\n", *key, *value);
1651
1652         /* move line to next key */
1653         *line = temp;
1654         return 0;
1655 }
1656
1657 /* extract possible KEY{attr} */
1658 static char *get_key_attribute(struct udev_rules *rules, char *str)
1659 {
1660         char *pos;
1661         char *attr;
1662
1663         attr = strchr(str, '{');
1664         if (attr != NULL) {
1665                 attr++;
1666                 pos = strchr(attr, '}');
1667                 if (pos == NULL) {
1668                         err(rules->udev, "missing closing brace for format\n");
1669                         return NULL;
1670                 }
1671                 pos[0] = '\0';
1672                 dbg(rules->udev, "attribute='%s'\n", attr);
1673                 return attr;
1674         }
1675
1676         return NULL;
1677 }
1678
1679 static int add_rule_key(struct udev_rule *rule, struct key *key,
1680                         enum key_operation operation, const char *value)
1681 {
1682         size_t val_len = strnlen(value, UTIL_PATH_SIZE);
1683
1684         key->operation = operation;
1685
1686         key->val_off = rule->bufsize;
1687         util_strlcpy(rule->buf + rule->bufsize, value, val_len+1);
1688         rule->bufsize += val_len+1;
1689
1690         return 0;
1691 }
1692
1693 static int add_rule_key_pair(struct udev_rules *rules, struct udev_rule *rule, struct key_pairs *pairs,
1694                              enum key_operation operation, const char *key, const char *value)
1695 {
1696         size_t key_len = strnlen(key, UTIL_PATH_SIZE);
1697
1698         if (pairs->count >= PAIRS_MAX) {
1699                 err(rules->udev, "skip, too many keys of the same type in a single rule\n");
1700                 return -1;
1701         }
1702
1703         add_rule_key(rule, &pairs->keys[pairs->count].key, operation, value);
1704
1705         /* add the key-name of the pair */
1706         pairs->keys[pairs->count].key_name_off = rule->bufsize;
1707         util_strlcpy(rule->buf + rule->bufsize, key, key_len+1);
1708         rule->bufsize += key_len+1;
1709
1710         pairs->count++;
1711
1712         return 0;
1713 }
1714
1715 static int add_to_rules(struct udev_rules *rules, char *line, const char *filename, unsigned int lineno)
1716 {
1717         char buf[sizeof(struct udev_rule) + UTIL_LINE_SIZE];
1718         struct udev_rule *rule;
1719         size_t rule_size;
1720         int valid;
1721         char *linepos;
1722         char *attr;
1723         size_t padding;
1724         int physdev = 0;
1725
1726         memset(buf, 0x00, sizeof(buf));
1727         rule = (struct udev_rule *) buf;
1728         rule->event_timeout = -1;
1729         linepos = line;
1730         valid = 0;
1731
1732         /* get all the keys */
1733         while (1) {
1734                 char *key;
1735                 char *value;
1736                 enum key_operation operation = KEY_OP_UNSET;
1737
1738                 if (get_key(rules, &linepos, &key, &operation, &value) != 0)
1739                         break;
1740
1741                 if (strcasecmp(key, "ACTION") == 0) {
1742                         if (operation != KEY_OP_MATCH &&
1743                             operation != KEY_OP_NOMATCH) {
1744                                 err(rules->udev, "invalid ACTION operation\n");
1745                                 goto invalid;
1746                         }
1747                         add_rule_key(rule, &rule->action, operation, value);
1748                         valid = 1;
1749                         continue;
1750                 }
1751
1752                 if (strcasecmp(key, "DEVPATH") == 0) {
1753                         if (operation != KEY_OP_MATCH &&
1754                             operation != KEY_OP_NOMATCH) {
1755                                 err(rules->udev, "invalid DEVPATH operation\n");
1756                                 goto invalid;
1757                         }
1758                         add_rule_key(rule, &rule->devpath, operation, value);
1759                         valid = 1;
1760                         continue;
1761                 }
1762
1763                 if (strcasecmp(key, "KERNEL") == 0) {
1764                         if (operation != KEY_OP_MATCH &&
1765                             operation != KEY_OP_NOMATCH) {
1766                                 err(rules->udev, "invalid KERNEL operation\n");
1767                                 goto invalid;
1768                         }
1769                         add_rule_key(rule, &rule->kernel, operation, value);
1770                         valid = 1;
1771                         continue;
1772                 }
1773
1774                 if (strcasecmp(key, "SUBSYSTEM") == 0) {
1775                         if (operation != KEY_OP_MATCH &&
1776                             operation != KEY_OP_NOMATCH) {
1777                                 err(rules->udev, "invalid SUBSYSTEM operation\n");
1778                                 goto invalid;
1779                         }
1780                         /* bus, class, subsystem events should all be the same */
1781                         if (strcmp(value, "subsystem") == 0 ||
1782                             strcmp(value, "bus") == 0 ||
1783                             strcmp(value, "class") == 0) {
1784                                 if (strcmp(value, "bus") == 0 || strcmp(value, "class") == 0)
1785                                         err(rules->udev, "'%s' must be specified as 'subsystem' \n"
1786                                             "please fix it in %s:%u", value, filename, lineno);
1787                                 add_rule_key(rule, &rule->subsystem, operation, "subsystem|class|bus");
1788                         } else
1789                                 add_rule_key(rule, &rule->subsystem, operation, value);
1790                         valid = 1;
1791                         continue;
1792                 }
1793
1794                 if (strcasecmp(key, "DRIVER") == 0) {
1795                         if (operation != KEY_OP_MATCH &&
1796                             operation != KEY_OP_NOMATCH) {
1797                                 err(rules->udev, "invalid DRIVER operation\n");
1798                                 goto invalid;
1799                         }
1800                         add_rule_key(rule, &rule->driver, operation, value);
1801                         valid = 1;
1802                         continue;
1803                 }
1804
1805                 if (strncasecmp(key, "ATTR{", sizeof("ATTR{")-1) == 0) {
1806                         attr = get_key_attribute(rules, key + sizeof("ATTR")-1);
1807                         if (attr == NULL) {
1808                                 err(rules->udev, "error parsing ATTR attribute\n");
1809                                 goto invalid;
1810                         }
1811                         if (add_rule_key_pair(rules, rule, &rule->attr, operation, attr, value) != 0)
1812                                 goto invalid;
1813                         valid = 1;
1814                         continue;
1815                 }
1816
1817                 if (strcasecmp(key, "KERNELS") == 0 ||
1818                     strcasecmp(key, "ID") == 0) {
1819                         if (operation != KEY_OP_MATCH &&
1820                             operation != KEY_OP_NOMATCH) {
1821                                 err(rules->udev, "invalid KERNELS operation\n");
1822                                 goto invalid;
1823                         }
1824                         add_rule_key(rule, &rule->kernels, operation, value);
1825                         valid = 1;
1826                         continue;
1827                 }
1828
1829                 if (strcasecmp(key, "SUBSYSTEMS") == 0 ||
1830                     strcasecmp(key, "BUS") == 0) {
1831                         if (operation != KEY_OP_MATCH &&
1832                             operation != KEY_OP_NOMATCH) {
1833                                 err(rules->udev, "invalid SUBSYSTEMS operation\n");
1834                                 goto invalid;
1835                         }
1836                         add_rule_key(rule, &rule->subsystems, operation, value);
1837                         valid = 1;
1838                         continue;
1839                 }
1840
1841                 if (strcasecmp(key, "DRIVERS") == 0) {
1842                         if (operation != KEY_OP_MATCH &&
1843                             operation != KEY_OP_NOMATCH) {
1844                                 err(rules->udev, "invalid DRIVERS operation\n");
1845                                 goto invalid;
1846                         }
1847                         add_rule_key(rule, &rule->drivers, operation, value);
1848                         valid = 1;
1849                         continue;
1850                 }
1851
1852                 if (strncasecmp(key, "ATTRS{", sizeof("ATTRS{")-1) == 0 ||
1853                     strncasecmp(key, "SYSFS{", sizeof("SYSFS{")-1) == 0) {
1854                         if (operation != KEY_OP_MATCH &&
1855                             operation != KEY_OP_NOMATCH) {
1856                                 err(rules->udev, "invalid ATTRS operation\n");
1857                                 goto invalid;
1858                         }
1859                         attr = get_key_attribute(rules, key + sizeof("ATTRS")-1);
1860                         if (attr == NULL) {
1861                                 err(rules->udev, "error parsing ATTRS attribute\n");
1862                                 goto invalid;
1863                         }
1864                         if (strncmp(attr, "device/", 7) == 0)
1865                                 err(rules->udev, "the 'device' link may not be available in a future kernel, "
1866                                     "please fix it in %s:%u", filename, lineno);
1867                         else if (strstr(attr, "../") != NULL)
1868                                 err(rules->udev, "do not reference parent sysfs directories directly, "
1869                                     "it may break with a future kernel, please fix it in %s:%u", filename, lineno);
1870                         if (add_rule_key_pair(rules, rule, &rule->attrs, operation, attr, value) != 0)
1871                                 goto invalid;
1872                         valid = 1;
1873                         continue;
1874                 }
1875
1876                 if (strncasecmp(key, "ENV{", sizeof("ENV{")-1) == 0) {
1877                         attr = get_key_attribute(rules, key + sizeof("ENV")-1);
1878                         if (attr == NULL) {
1879                                 err(rules->udev, "error parsing ENV attribute\n");
1880                                 goto invalid;
1881                         }
1882                         if (strncmp(attr, "PHYSDEV", 7) == 0)
1883                                 physdev = 1;
1884                         if (add_rule_key_pair(rules, rule, &rule->env, operation, attr, value) != 0)
1885                                 goto invalid;
1886                         valid = 1;
1887                         continue;
1888                 }
1889
1890                 if (strcasecmp(key, "PROGRAM") == 0) {
1891                         add_rule_key(rule, &rule->program, operation, value);
1892                         valid = 1;
1893                         continue;
1894                 }
1895
1896                 if (strcasecmp(key, "RESULT") == 0) {
1897                         if (operation != KEY_OP_MATCH &&
1898                             operation != KEY_OP_NOMATCH) {
1899                                 err(rules->udev, "invalid RESULT operation\n");
1900                                 goto invalid;
1901                         }
1902                         add_rule_key(rule, &rule->result, operation, value);
1903                         valid = 1;
1904                         continue;
1905                 }
1906
1907                 if (strncasecmp(key, "IMPORT", sizeof("IMPORT")-1) == 0) {
1908                         attr = get_key_attribute(rules, key + sizeof("IMPORT")-1);
1909                         if (attr != NULL && strstr(attr, "program")) {
1910                                 dbg(rules->udev, "IMPORT will be executed\n");
1911                                 rule->import_type  = IMPORT_PROGRAM;
1912                         } else if (attr != NULL && strstr(attr, "file")) {
1913                                 dbg(rules->udev, "IMPORT will be included as file\n");
1914                                 rule->import_type  = IMPORT_FILE;
1915                         } else if (attr != NULL && strstr(attr, "parent")) {
1916                                 dbg(rules->udev, "IMPORT will include the parent values\n");
1917                                 rule->import_type = IMPORT_PARENT;
1918                         } else {
1919                                 /* figure it out if it is executable */
1920                                 char file[UTIL_PATH_SIZE];
1921                                 char *pos;
1922                                 struct stat statbuf;
1923
1924                                 util_strlcpy(file, value, sizeof(file));
1925                                 pos = strchr(file, ' ');
1926                                 if (pos)
1927                                         pos[0] = '\0';
1928
1929                                 /* allow programs in /lib/udev called without the path */
1930                                 if (strchr(file, '/') == NULL) {
1931                                         util_strlcpy(file, UDEV_PREFIX "/lib/udev/", sizeof(file));
1932                                         util_strlcat(file, value, sizeof(file));
1933                                         pos = strchr(file, ' ');
1934                                         if (pos)
1935                                                 pos[0] = '\0';
1936                                 }
1937
1938                                 dbg(rules->udev, "IMPORT auto mode for '%s'\n", file);
1939                                 if (!lstat(file, &statbuf) && (statbuf.st_mode & S_IXUSR)) {
1940                                         dbg(rules->udev, "IMPORT is executable, will be executed (autotype)\n");
1941                                         rule->import_type  = IMPORT_PROGRAM;
1942                                 } else {
1943                                         dbg(rules->udev, "IMPORT is not executable, will be included as file (autotype)\n");
1944                                         rule->import_type  = IMPORT_FILE;
1945                                 }
1946                         }
1947                         add_rule_key(rule, &rule->import, operation, value);
1948                         valid = 1;
1949                         continue;
1950                 }
1951
1952                 if (strncasecmp(key, "TEST", sizeof("TEST")-1) == 0) {
1953                         if (operation != KEY_OP_MATCH &&
1954                             operation != KEY_OP_NOMATCH) {
1955                                 err(rules->udev, "invalid TEST operation\n");
1956                                 goto invalid;
1957                         }
1958                         attr = get_key_attribute(rules, key + sizeof("TEST")-1);
1959                         if (attr != NULL)
1960                                 rule->test_mode_mask = strtol(attr, NULL, 8);
1961                         add_rule_key(rule, &rule->test, operation, value);
1962                         valid = 1;
1963                         continue;
1964                 }
1965
1966                 if (strncasecmp(key, "RUN", sizeof("RUN")-1) == 0) {
1967                         attr = get_key_attribute(rules, key + sizeof("RUN")-1);
1968                         if (attr != NULL) {
1969                                 if (strstr(attr, "ignore_error"))
1970                                         rule->run_ignore_error = 1;
1971                         }
1972                         add_rule_key(rule, &rule->run, operation, value);
1973                         valid = 1;
1974                         continue;
1975                 }
1976
1977                 if (strcasecmp(key, "WAIT_FOR") == 0 || strcasecmp(key, "WAIT_FOR_SYSFS") == 0) {
1978                         add_rule_key(rule, &rule->wait_for, operation, value);
1979                         valid = 1;
1980                         continue;
1981                 }
1982
1983                 if (strcasecmp(key, "LABEL") == 0) {
1984                         add_rule_key(rule, &rule->label, operation, value);
1985                         valid = 1;
1986                         continue;
1987                 }
1988
1989                 if (strcasecmp(key, "GOTO") == 0) {
1990                         add_rule_key(rule, &rule->goto_label, operation, value);
1991                         valid = 1;
1992                         continue;
1993                 }
1994
1995                 if (strncasecmp(key, "NAME", sizeof("NAME")-1) == 0) {
1996                         attr = get_key_attribute(rules, key + sizeof("NAME")-1);
1997                         if (attr != NULL) {
1998                                 if (strstr(attr, "all_partitions") != NULL) {
1999                                         dbg(rules->udev, "creation of partition nodes requested\n");
2000                                         rule->partitions = DEFAULT_FAKE_PARTITIONS_COUNT;
2001                                 }
2002                                 if (strstr(attr, "ignore_remove") != NULL) {
2003                                         dbg(rules->udev, "remove event should be ignored\n");
2004                                         rule->ignore_remove = 1;
2005                                 }
2006                         }
2007                         if (value[0] == '\0')
2008                                 dbg(rules->udev, "name empty, node creation supressed\n");
2009                         add_rule_key(rule, &rule->name, operation, value);
2010                         continue;
2011                 }
2012
2013                 if (strcasecmp(key, "SYMLINK") == 0) {
2014                         if (operation == KEY_OP_MATCH ||
2015                             operation == KEY_OP_NOMATCH)
2016                                 add_rule_key(rule, &rule->symlink_match, operation, value);
2017                         else
2018                                 add_rule_key(rule, &rule->symlink, operation, value);
2019                         valid = 1;
2020                         continue;
2021                 }
2022
2023                 if (strcasecmp(key, "OWNER") == 0) {
2024                         valid = 1;
2025                         if (rules->resolve_names && (!strchr(value, '$') && !strchr(value, '%'))) {
2026                                 char *endptr;
2027                                 strtoul(value, &endptr, 10);
2028                                 if (endptr[0] != '\0') {
2029                                         char owner[32];
2030                                         uid_t uid = lookup_user(rules->udev, value);
2031                                         dbg(rules->udev, "replacing username='%s' by id=%i\n", value, uid);
2032                                         sprintf(owner, "%u", (unsigned int) uid);
2033                                         add_rule_key(rule, &rule->owner, operation, owner);
2034                                         continue;
2035                                 }
2036                         }
2037
2038                         add_rule_key(rule, &rule->owner, operation, value);
2039                         continue;
2040                 }
2041
2042                 if (strcasecmp(key, "GROUP") == 0) {
2043                         valid = 1;
2044                         if (rules->resolve_names && (!strchr(value, '$') && !strchr(value, '%'))) {
2045                                 char *endptr;
2046                                 strtoul(value, &endptr, 10);
2047                                 if (endptr[0] != '\0') {
2048                                         char group[32];
2049                                         gid_t gid = lookup_group(rules->udev, value);
2050                                         dbg(rules->udev, "replacing groupname='%s' by id=%i\n", value, gid);
2051                                         sprintf(group, "%u", (unsigned int) gid);
2052                                         add_rule_key(rule, &rule->group, operation, group);
2053                                         continue;
2054                                 }
2055                         }
2056
2057                         add_rule_key(rule, &rule->group, operation, value);
2058                         continue;
2059                 }
2060
2061                 if (strcasecmp(key, "MODE") == 0) {
2062                         add_rule_key(rule, &rule->mode, operation, value);
2063                         valid = 1;
2064                         continue;
2065                 }
2066
2067                 if (strcasecmp(key, "OPTIONS") == 0) {
2068                         const char *pos;
2069
2070                         if (strstr(value, "last_rule") != NULL) {
2071                                 dbg(rules->udev, "last rule to be applied\n");
2072                                 rule->last_rule = 1;
2073                         }
2074                         if (strstr(value, "ignore_device") != NULL) {
2075                                 dbg(rules->udev, "device should be ignored\n");
2076                                 rule->ignore_device = 1;
2077                         }
2078                         if (strstr(value, "ignore_remove") != NULL) {
2079                                 dbg(rules->udev, "remove event should be ignored\n");
2080                                 rule->ignore_remove = 1;
2081                         }
2082                         pos = strstr(value, "link_priority=");
2083                         if (pos != NULL) {
2084                                 rule->link_priority = atoi(&pos[strlen("link_priority=")]);
2085                                 dbg(rules->udev, "link priority=%i\n", rule->link_priority);
2086                         }
2087                         pos = strstr(value, "event_timeout=");
2088                         if (pos != NULL) {
2089                                 rule->event_timeout = atoi(&pos[strlen("event_timeout=")]);
2090                                 dbg(rules->udev, "event timout=%i\n", rule->event_timeout);
2091                         }
2092                         pos = strstr(value, "string_escape=");
2093                         if (pos != NULL) {
2094                                 pos = &pos[strlen("string_escape=")];
2095                                 if (strncmp(pos, "none", strlen("none")) == 0)
2096                                         rule->string_escape = ESCAPE_NONE;
2097                                 else if (strncmp(pos, "replace", strlen("replace")) == 0)
2098                                         rule->string_escape = ESCAPE_REPLACE;
2099                         }
2100                         if (strstr(value, "all_partitions") != NULL) {
2101                                 dbg(rules->udev, "creation of partition nodes requested\n");
2102                                 rule->partitions = DEFAULT_FAKE_PARTITIONS_COUNT;
2103                         }
2104                         valid = 1;
2105                         continue;
2106                 }
2107
2108                 err(rules->udev, "unknown key '%s' in %s:%u\n", key, filename, lineno);
2109         }
2110
2111         if (physdev && rule->wait_for.operation == KEY_OP_UNSET)
2112                 err(rules->udev, "PHYSDEV* values are deprecated and will be removed from a future kernel, \n"
2113                     "please fix it in %s:%u", filename, lineno);
2114
2115         /* skip line if not any valid key was found */
2116         if (!valid)
2117                 goto invalid;
2118
2119         /* grow buffer and add rule */
2120         rule_size = sizeof(struct udev_rule) + rule->bufsize;
2121         padding = (sizeof(size_t) - rule_size % sizeof(size_t)) % sizeof(size_t);
2122         dbg(rules->udev, "add %zi padding bytes\n", padding);
2123         rule_size += padding;
2124         rule->bufsize += padding;
2125
2126         rules->buf = realloc(rules->buf, rules->bufsize + rule_size);
2127         if (!rules->buf) {
2128                 err(rules->udev, "realloc failed\n");
2129                 goto exit;
2130         }
2131         dbg(rules->udev, "adding rule to offset %zi\n", rules->bufsize);
2132         memcpy(rules->buf + rules->bufsize, rule, rule_size);
2133         rules->bufsize += rule_size;
2134 exit:
2135         return 0;
2136
2137 invalid:
2138         err(rules->udev, "invalid rule '%s:%u'\n", filename, lineno);
2139         return -1;
2140 }
2141
2142 static int parse_file(struct udev_rules *rules, const char *filename)
2143 {
2144         FILE *f;
2145         char line[UTIL_LINE_SIZE];
2146         size_t start;
2147         struct udev_rule *rule;
2148         struct udev_rules_iter iter;
2149
2150         start = rules->bufsize;
2151         info(rules->udev, "reading '%s' as rules file\n", filename);
2152
2153         f = fopen(filename, "r");
2154         if (f == NULL)
2155                 return -1;
2156
2157         while(fgets(line, sizeof(line), f) != NULL) {
2158                 int line_nr = 0;
2159                 char *key;
2160                 size_t len;
2161
2162                 /* skip whitespace */
2163                 line_nr++;
2164                 key = line;
2165                 while (isspace(key[0]))
2166                         key++;
2167
2168                 /* comment */
2169                 if (key[0] == '#')
2170                         continue;
2171
2172                 len = strlen(line);
2173                 if (len < 3)
2174                         continue;
2175
2176                 /* continue reading if backslash+newline is found */
2177                 while (line[len-2] == '\\') {
2178                         if (fgets(&line[len-2], (sizeof(line)-len)+2, f) == NULL)
2179                                 break;
2180                         line_nr++;
2181                         len = strlen(line);
2182                 }
2183
2184                 if (len+1 >= sizeof(line)) {
2185                         err(rules->udev, "line too long '%s':%u, ignored\n", filename, line_nr);
2186                         continue;
2187                 }
2188                 add_to_rules(rules, key, filename, line_nr);
2189         }
2190         fclose(f);
2191
2192         /* compute all goto targets within this file */
2193         udev_rules_iter_init(&iter, rules);
2194         udev_rules_iter_goto(&iter, start);
2195         while((rule = udev_rules_iter_next(&iter))) {
2196                 if (rule->goto_label.operation != KEY_OP_UNSET) {
2197                         char *goto_label = &rule->buf[rule->goto_label.val_off];
2198
2199                         dbg(rules->udev, "resolving goto label '%s'\n", goto_label);
2200                         rule->goto_rule_off = find_label(&iter, goto_label);
2201                         if (rule->goto_rule_off == 0) {
2202                                 err(rules->udev, "ignore goto to nonexistent label '%s' in '%s'\n",
2203                                     goto_label, filename);
2204                                 rule->goto_rule_off = iter.current;
2205                         }
2206                 }
2207         }
2208         return 0;
2209 }
2210
2211 static int add_matching_files(struct udev *udev, struct udev_list_node *file_list, const char *dirname, const char *suffix)
2212 {
2213         struct dirent *ent;
2214         DIR *dir;
2215         char filename[UTIL_PATH_SIZE];
2216
2217         dbg(udev, "open directory '%s'\n", dirname);
2218         dir = opendir(dirname);
2219         if (dir == NULL) {
2220                 err(udev, "unable to open '%s': %m\n", dirname);
2221                 return -1;
2222         }
2223
2224         while (1) {
2225                 ent = readdir(dir);
2226                 if (ent == NULL || ent->d_name[0] == '\0')
2227                         break;
2228
2229                 if ((ent->d_name[0] == '.') || (ent->d_name[0] == '#'))
2230                         continue;
2231
2232                 /* look for file matching with specified suffix */
2233                 if (suffix != NULL) {
2234                         const char *ext;
2235
2236                         ext = strrchr(ent->d_name, '.');
2237                         if (ext == NULL)
2238                                 continue;
2239                         if (strcmp(ext, suffix) != 0)
2240                                 continue;
2241                 }
2242                 dbg(udev, "put file '%s/%s' into list\n", dirname, ent->d_name);
2243
2244                 snprintf(filename, sizeof(filename), "%s/%s", dirname, ent->d_name);
2245                 filename[sizeof(filename)-1] = '\0';
2246                 udev_list_entry_add(udev, file_list, filename, NULL, 1, 1);
2247         }
2248
2249         closedir(dir);
2250         return 0;
2251 }
2252
2253 struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names)
2254 {
2255         struct udev_rules *rules;
2256         struct stat statbuf;
2257         char filename[PATH_MAX];
2258         struct udev_list_node file_list;
2259         struct udev_list_entry *file_loop, *file_tmp;
2260
2261         rules = malloc(sizeof(struct udev_rules));
2262         if (rules == NULL)
2263                 return rules;
2264         memset(rules, 0x00, sizeof(struct udev_rules));
2265         rules->udev = udev;
2266         rules->resolve_names = resolve_names;
2267         udev_list_init(&file_list);
2268
2269         if (udev_get_rules_path(udev) != NULL) {
2270                 /* custom rules location for testing */
2271                 add_matching_files(udev, &file_list, udev_get_rules_path(udev), ".rules");
2272         } else {
2273                 struct udev_list_node sort_list;
2274                 struct udev_list_entry *sort_loop, *sort_tmp;
2275
2276                 /* read user/custom rules */
2277                 add_matching_files(udev, &file_list, SYSCONFDIR "/udev/rules.d", ".rules");
2278
2279                 /* read dynamic/temporary rules */
2280                 util_strlcpy(filename, udev_get_dev_path(udev), sizeof(filename));
2281                 util_strlcat(filename, "/.udev/rules.d", sizeof(filename));
2282                 if (stat(filename, &statbuf) != 0) {
2283                         create_path(udev, filename);
2284                         udev_selinux_setfscreatecon(udev, filename, S_IFDIR|0755);
2285                         mkdir(filename, 0755);
2286                         udev_selinux_resetfscreatecon(udev);
2287                 }
2288                 udev_list_init(&sort_list);
2289                 add_matching_files(udev, &sort_list, filename, ".rules");
2290
2291                 /* read default rules */
2292                 add_matching_files(udev, &sort_list, UDEV_PREFIX "/lib/udev/rules.d", ".rules");
2293
2294                 /* sort all rules files by basename into list of files */
2295                 udev_list_entry_foreach_safe(sort_loop, sort_tmp, udev_list_get_entry(&sort_list)) {
2296                         const char *sort_name = udev_list_entry_get_name(sort_loop);
2297                         const char *sort_base = strrchr(sort_name, '/');
2298
2299                         if (sort_base == NULL)
2300                                 continue;
2301
2302                         udev_list_entry_foreach_safe(file_loop, file_tmp, udev_list_get_entry(&file_list)) {
2303                                 const char *file_name = udev_list_entry_get_name(file_loop);
2304                                 const char *file_base = strrchr(file_name, '/');
2305
2306                                 if (file_base == NULL)
2307                                         continue;
2308                                 if (strcmp(file_base, sort_base) == 0) {
2309                                         info(udev, "rule file basename '%s' already added, ignoring '%s'\n",
2310                                              file_name, sort_name);
2311                                         udev_list_entry_remove(sort_loop);
2312                                         sort_loop = NULL;
2313                                         break;
2314                                 }
2315                                 if (strcmp(file_base, sort_base) > 0)
2316                                         break;
2317                         }
2318                         if (sort_loop != NULL)
2319                                 udev_list_entry_move_before(sort_loop, file_loop);
2320                 }
2321         }
2322
2323         /* parse list of files */
2324         udev_list_entry_foreach_safe(file_loop, file_tmp, udev_list_get_entry(&file_list)) {
2325                 const char *file_name = udev_list_entry_get_name(file_loop);
2326
2327                 if (stat(file_name, &statbuf) == 0 && statbuf.st_size > 0)
2328                         parse_file(rules, file_name);
2329                 else
2330                         info(udev, "can not read '%s'\n", file_name);
2331                 udev_list_entry_remove(file_loop);
2332         }
2333         return rules;
2334 }
2335
2336 void udev_rules_unref(struct udev_rules *rules)
2337 {
2338         if (rules == NULL)
2339                 return;
2340         if (rules->buf) {
2341                 free(rules->buf);
2342                 rules->buf = NULL;
2343         }
2344         free(rules);
2345 }