udev/udev-rules.c

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