chiark / gitweb /
rules: support substitutions in TAG=
[elogind.git] / udev / udev-rules.c
index e6452a6fa4e0c4d49f8d62f22368cf1839b09481..48395e788738ee2028b0c17c09dda302d11a211c 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2008 Kay Sievers <kay.sievers@vrfy.org>
+ * Copyright (C) 2003-2010 Kay Sievers <kay.sievers@vrfy.org>
  * Copyright (C) 2008 Alan Jenkins <alan-jenkins@tuffmail.co.uk>
  *
  * This program is free software: you can redistribute it and/or modify
@@ -19,6 +19,7 @@
 #include <stddef.h>
 #include <limits.h>
 #include <stdlib.h>
+#include <stdbool.h>
 #include <string.h>
 #include <stdio.h>
 #include <fcntl.h>
@@ -27,6 +28,7 @@
 #include <errno.h>
 #include <dirent.h>
 #include <fnmatch.h>
+#include <time.h>
 
 #include "udev.h"
 
@@ -105,6 +107,13 @@ enum string_glob_type {
        GL_SOMETHING,                   /* commonly used "?*" */
 };
 
+enum string_subst_type {
+       SB_UNSET,
+       SB_NONE,
+       SB_FORMAT,
+       SB_SUBSYS,
+};
+
 /* tokens of a rule are sorted/handled in this order */
 enum token_type {
        TK_UNSET,
@@ -116,6 +125,7 @@ enum token_type {
        TK_M_DEVLINK,                   /* val */
        TK_M_NAME,                      /* val */
        TK_M_ENV,                       /* val, attr */
+       TK_M_TAG,                       /* val */
        TK_M_SUBSYSTEM,                 /* val */
        TK_M_DRIVER,                    /* val */
        TK_M_WAITFOR,                   /* val */
@@ -126,21 +136,24 @@ enum token_type {
        TK_M_SUBSYSTEMS,                /* val */
        TK_M_DRIVERS,                   /* val */
        TK_M_ATTRS,                     /* val, attr */
+       TK_M_TAGS,                      /* val */
        TK_M_PARENTS_MAX,
 
        TK_M_TEST,                      /* val, mode_t */
+       TK_M_EVENT_TIMEOUT,             /* int */
        TK_M_PROGRAM,                   /* val */
        TK_M_IMPORT_FILE,               /* val */
        TK_M_IMPORT_PROG,               /* val */
+       TK_M_IMPORT_DB,                 /* val */
+       TK_M_IMPORT_CMDLINE,            /* val */
        TK_M_IMPORT_PARENT,             /* val */
        TK_M_RESULT,                    /* val */
        TK_M_MAX,
 
-       TK_A_IGNORE_DEVICE,
        TK_A_STRING_ESCAPE_NONE,
        TK_A_STRING_ESCAPE_REPLACE,
+       TK_A_DB_PERSIST,
        TK_A_INOTIFY_WATCH,             /* int */
-       TK_A_NUM_FAKE_PART,             /* int */
        TK_A_DEVLINK_PRIO,              /* int */
        TK_A_OWNER,                     /* val */
        TK_A_GROUP,                     /* val */
@@ -148,15 +161,14 @@ enum token_type {
        TK_A_OWNER_ID,                  /* uid_t */
        TK_A_GROUP_ID,                  /* gid_t */
        TK_A_MODE_ID,                   /* mode_t */
+       TK_A_STATIC_NODE,               /* val */
        TK_A_ENV,                       /* val, attr */
+       TK_A_TAG,                       /* val */
        TK_A_NAME,                      /* val */
        TK_A_DEVLINK,                   /* val */
-       TK_A_EVENT_TIMEOUT,             /* int */
-       TK_A_IGNORE_REMOVE,
        TK_A_ATTR,                      /* val, attr */
        TK_A_RUN,                       /* val, bool */
        TK_A_GOTO,                      /* size_t */
-       TK_A_LAST_RULE,
 
        TK_END,
 };
@@ -164,29 +176,32 @@ enum token_type {
 /* we try to pack stuff in a way that we take only 12 bytes per token */
 struct token {
        union {
-               unsigned char type;             /* same as in rule and key */
+               unsigned char type;             /* same in rule and key */
                struct {
-                       unsigned char type;
-                       unsigned char flags;
+                       enum token_type type:8;
+                       bool can_set_name:1;
+                       bool has_static_node:1;
+                       unsigned int unused:6;
                        unsigned short token_count;
                        unsigned int label_off;
                        unsigned short filename_off;
                        unsigned short filename_line;
                } rule;
                struct {
-                       unsigned char type;
-                       unsigned char flags;
-                       unsigned char op;
-                       unsigned char glob;
+                       enum token_type type:8;
+                       enum operation_type op:8;
+                       enum string_glob_type glob:8;
+                       enum string_subst_type subst:4;
+                       enum string_subst_type attrsubst:4;
                        unsigned int value_off;
                        union {
                                unsigned int attr_off;
-                               int ignore_error;
+                               int devlink_unique;
+                               int fail_on_error;
                                unsigned int rule_goto;
                                mode_t  mode;
                                uid_t uid;
                                gid_t gid;
-                               int num_fake_part;
                                int devlink_prio;
                                int event_timeout;
                                int watch;
@@ -203,7 +218,7 @@ struct rule_tmp {
        unsigned int token_cur;
 };
 
-#ifdef DEBUG
+#ifdef ENABLE_DEBUG
 static const char *operation_str(enum operation_type type)
 {
        static const char *operation_strs[] = {
@@ -246,6 +261,7 @@ static const char *token_str(enum token_type type)
                [TK_M_DEVLINK] =                "M DEVLINK",
                [TK_M_NAME] =                   "M NAME",
                [TK_M_ENV] =                    "M ENV",
+               [TK_M_TAG] =                    "M TAG",
                [TK_M_SUBSYSTEM] =              "M SUBSYSTEM",
                [TK_M_DRIVER] =                 "M DRIVER",
                [TK_M_WAITFOR] =                "M WAITFOR",
@@ -256,37 +272,39 @@ static const char *token_str(enum token_type type)
                [TK_M_SUBSYSTEMS] =             "M SUBSYSTEMS",
                [TK_M_DRIVERS] =                "M DRIVERS",
                [TK_M_ATTRS] =                  "M ATTRS",
+               [TK_M_TAGS] =                   "M TAGS",
                [TK_M_PARENTS_MAX] =            "M PARENTS_MAX",
 
                [TK_M_TEST] =                   "M TEST",
+               [TK_M_EVENT_TIMEOUT] =          "M EVENT_TIMEOUT",
                [TK_M_PROGRAM] =                "M PROGRAM",
                [TK_M_IMPORT_FILE] =            "M IMPORT_FILE",
                [TK_M_IMPORT_PROG] =            "M IMPORT_PROG",
-               [TK_M_IMPORT_PARENT] =          "M MPORT_PARENT",
+               [TK_M_IMPORT_DB] =              "M IMPORT_DB",
+               [TK_M_IMPORT_CMDLINE] =         "M IMPORT_CMDLINE",
+               [TK_M_IMPORT_PARENT] =          "M IMPORT_PARENT",
                [TK_M_RESULT] =                 "M RESULT",
                [TK_M_MAX] =                    "M MAX",
 
-               [TK_A_IGNORE_DEVICE] =          "A IGNORE_DEVICE",
                [TK_A_STRING_ESCAPE_NONE] =     "A STRING_ESCAPE_NONE",
                [TK_A_STRING_ESCAPE_REPLACE] =  "A STRING_ESCAPE_REPLACE",
+               [TK_A_DB_PERSIST] =             "A DB_PERSIST",
                [TK_A_INOTIFY_WATCH] =          "A INOTIFY_WATCH",
-               [TK_A_NUM_FAKE_PART] =          "A NUM_FAKE_PART",
                [TK_A_DEVLINK_PRIO] =           "A DEVLINK_PRIO",
                [TK_A_OWNER] =                  "A OWNER",
                [TK_A_GROUP] =                  "A GROUP",
                [TK_A_MODE] =                   "A MODE",
                [TK_A_OWNER_ID] =               "A OWNER_ID",
                [TK_A_GROUP_ID] =               "A GROUP_ID",
+               [TK_A_STATIC_NODE] =            "A STATIC_NODE",
                [TK_A_MODE_ID] =                "A MODE_ID",
                [TK_A_ENV] =                    "A ENV",
+               [TK_A_TAG] =                    "A ENV",
                [TK_A_NAME] =                   "A NAME",
                [TK_A_DEVLINK] =                "A DEVLINK",
-               [TK_A_EVENT_TIMEOUT] =          "A EVENT_TIMEOUT",
-               [TK_A_IGNORE_REMOVE] =          "A IGNORE_REMOVE",
                [TK_A_ATTR] =                   "A ATTR",
                [TK_A_RUN] =                    "A RUN",
                [TK_A_GOTO] =                   "A GOTO",
-               [TK_A_LAST_RULE] =              "A LAST_RULE",
 
                [TK_END] =                      "END",
        };
@@ -309,11 +327,10 @@ static void dump_token(struct udev_rules *rules, struct token *token)
                        const char *tk_ptr = (char *)token;
                        unsigned int idx = (tk_ptr - tks_ptr) / sizeof(struct token);
 
-                       dbg(rules->udev, "* RULE %s:%u, token: %u, count: %u, label: '%s', flags: 0x%02x\n",
+                       dbg(rules->udev, "* RULE %s:%u, token: %u, count: %u, label: '%s'\n",
                            &rules->buf[token->rule.filename_off], token->rule.filename_line,
                            idx, token->rule.token_count,
-                           &rules->buf[token->rule.label_off],
-                           token->rule.flags);
+                           &rules->buf[token->rule.label_off]);
                        break;
                }
        case TK_M_ACTION:
@@ -327,9 +344,12 @@ static void dump_token(struct udev_rules *rules, struct token *token)
        case TK_M_KERNELS:
        case TK_M_SUBSYSTEMS:
        case TK_M_DRIVERS:
+       case TK_M_TAGS:
        case TK_M_PROGRAM:
        case TK_M_IMPORT_FILE:
        case TK_M_IMPORT_PROG:
+       case TK_M_IMPORT_DB:
+       case TK_M_IMPORT_CMDLINE:
        case TK_M_IMPORT_PARENT:
        case TK_M_RESULT:
        case TK_A_NAME:
@@ -349,11 +369,13 @@ static void dump_token(struct udev_rules *rules, struct token *token)
                dbg(rules->udev, "%s %s '%s' '%s'(%s)\n",
                    token_str(type), operation_str(op), attr, value, string_glob_str(glob));
                break;
-       case TK_A_IGNORE_DEVICE:
+       case TK_M_TAG:
+       case TK_A_TAG:
+               dbg(rules->udev, "%s %s '%s'\n", token_str(type), operation_str(op), value);
+               break;
        case TK_A_STRING_ESCAPE_NONE:
        case TK_A_STRING_ESCAPE_REPLACE:
-       case TK_A_LAST_RULE:
-       case TK_A_IGNORE_REMOVE:
+       case TK_A_DB_PERSIST:
                dbg(rules->udev, "%s\n", token_str(type));
                break;
        case TK_M_TEST:
@@ -363,11 +385,8 @@ static void dump_token(struct udev_rules *rules, struct token *token)
        case TK_A_INOTIFY_WATCH:
                dbg(rules->udev, "%s %u\n", token_str(type), token->key.watch);
                break;
-       case TK_A_NUM_FAKE_PART:
-               dbg(rules->udev, "%s %u\n", token_str(type), token->key.num_fake_part);
-               break;
        case TK_A_DEVLINK_PRIO:
-               dbg(rules->udev, "%s %s %u\n", token_str(type), operation_str(op), token->key.devlink_prio);
+               dbg(rules->udev, "%s %u\n", token_str(type), token->key.devlink_prio);
                break;
        case TK_A_OWNER_ID:
                dbg(rules->udev, "%s %s %u\n", token_str(type), operation_str(op), token->key.uid);
@@ -378,8 +397,11 @@ static void dump_token(struct udev_rules *rules, struct token *token)
        case TK_A_MODE_ID:
                dbg(rules->udev, "%s %s %#o\n", token_str(type), operation_str(op), token->key.mode);
                break;
-       case TK_A_EVENT_TIMEOUT:
-               dbg(rules->udev, "%s %s %u\n", token_str(type), operation_str(op), token->key.event_timeout);
+       case TK_A_STATIC_NODE:
+               dbg(rules->udev, "%s '%s'\n", token_str(type), value);
+               break;
+       case TK_M_EVENT_TIMEOUT:
+               dbg(rules->udev, "%s %u\n", token_str(type), token->key.event_timeout);
                break;
        case TK_A_GOTO:
                dbg(rules->udev, "%s '%s' %u\n", token_str(type), value, token->key.rule_goto);
@@ -413,7 +435,7 @@ static inline const char *operation_str(enum operation_type type) { return NULL;
 static inline const char *token_str(enum token_type type) { return NULL; }
 static inline void dump_token(struct udev_rules *rules, struct token *token) {}
 static inline void dump_rules(struct udev_rules *rules) {}
-#endif /* DEBUG */
+#endif /* ENABLE_DEBUG */
 
 static int add_new_string(struct udev_rules *rules, const char *str, size_t bytes)
 {
@@ -710,8 +732,9 @@ static int import_property_from_string(struct udev_device *dev, char *line)
                struct udev_list_entry *entry;
 
                entry = udev_device_add_property(dev, key, val);
-               /* store in db */
-               udev_list_entry_set_flag(entry, 1);
+               /* store in db, skip private keys */
+               if (key[0] != '.')
+                       udev_list_entry_set_num(entry, true);
        }
        return 0;
 }
@@ -730,17 +753,18 @@ static int import_file_into_properties(struct udev_device *dev, const char *file
        return 0;
 }
 
-static int import_program_into_properties(struct udev_device *dev, const char *program)
+static int import_program_into_properties(struct udev_event *event, const char *program, const sigset_t *sigmask)
 {
-       struct udev *udev = udev_device_get_udev(dev);
+       struct udev_device *dev = event->dev;
        char **envp;
-       char result[4096];
-       size_t reslen;
+       char result[UTIL_LINE_SIZE];
        char *line;
+       int err;
 
        envp = udev_device_get_properties_envp(dev);
-       if (util_run_program(udev, program, envp, result, sizeof(result), &reslen) != 0)
-               return -1;
+       err = udev_event_spawn(event, program, envp, sigmask, result, sizeof(result));
+       if (err < 0)
+               return err;
 
        line = result;
        while (line != NULL) {
@@ -777,8 +801,9 @@ static int import_parent_into_properties(struct udev_device *dev, const char *fi
 
                        dbg(udev, "import key '%s=%s'\n", key, val);
                        entry = udev_device_add_property(dev, key, val);
-                       /* store in db */
-                       udev_list_entry_set_flag(entry, 1);
+                       /* store in db, skip private keys */
+                       if (key[0] != '.')
+                               udev_list_entry_set_num(entry, true);
                }
        }
        return 0;
@@ -804,6 +829,8 @@ static int wait_for_file(struct udev_device *dev, const char *file, int timeout)
 
        dbg(udev, "will wait %i sec for '%s'\n", timeout, file);
        while (--loop) {
+               const struct timespec duration = { 0, 1000 * 1000 * 1000 / WAIT_LOOP_PER_SECOND };
+
                /* lookup file */
                if (stat(file, &stats) == 0) {
                        info(udev, "file '%s' appeared after %i loops\n", file, (timeout * WAIT_LOOP_PER_SECOND) - loop-1);
@@ -815,7 +842,7 @@ static int wait_for_file(struct udev_device *dev, const char *file, int timeout)
                        return -2;
                }
                info(udev, "wait for '%s' for %i mseconds\n", file, 1000 / WAIT_LOOP_PER_SECOND);
-               usleep(1000 * 1000 / WAIT_LOOP_PER_SECOND);
+               nanosleep(&duration, NULL);
        }
        info(udev, "waiting for '%s' failed\n", file);
        return -1;
@@ -823,7 +850,7 @@ static int wait_for_file(struct udev_device *dev, const char *file, int timeout)
 
 static int attr_subst_subdir(char *attr, size_t len)
 {
-       int found = 0;
+       bool found = false;
 
        if (strstr(attr, "/*/")) {
                char *pos;
@@ -848,7 +875,7 @@ static int attr_subst_subdir(char *attr, size_t len)
                                        continue;
                                util_strscpyl(attr, len, dirname, "/", dent->d_name, tail, NULL);
                                if (stat(attr, &stats) == 0) {
-                                       found = 1;
+                                       found = true;
                                        break;
                                }
                        }
@@ -865,7 +892,7 @@ static int get_key(struct udev *udev, char **line, char **key, enum operation_ty
        char *temp;
 
        linepos = *line;
-       if (linepos == NULL && linepos[0] == '\0')
+       if (linepos == NULL || linepos[0] == '\0')
                return -1;
 
        /* skip whitespace */
@@ -877,7 +904,7 @@ static int get_key(struct udev *udev, char **line, char **key, enum operation_ty
                return -1;
        *key = linepos;
 
-       while (1) {
+       for (;;) {
                linepos++;
                if (linepos[0] == '\0')
                        return -1;
@@ -973,8 +1000,7 @@ static int rule_add_key(struct rule_tmp *rule_tmp, enum token_type type,
                        const char *value, const void *data)
 {
        struct token *token = &rule_tmp->token[rule_tmp->token_cur];
-       const char *attr = data;
-       enum string_glob_type glob;
+       const char *attr = NULL;
 
        memset(token, 0x00, sizeof(struct token));
 
@@ -990,17 +1016,21 @@ static int rule_add_key(struct rule_tmp *rule_tmp, enum token_type type,
        case TK_M_KERNELS:
        case TK_M_SUBSYSTEMS:
        case TK_M_DRIVERS:
+       case TK_M_TAGS:
        case TK_M_PROGRAM:
        case TK_M_IMPORT_FILE:
        case TK_M_IMPORT_PROG:
+       case TK_M_IMPORT_DB:
+       case TK_M_IMPORT_CMDLINE:
        case TK_M_IMPORT_PARENT:
        case TK_M_RESULT:
        case TK_A_OWNER:
        case TK_A_GROUP:
        case TK_A_MODE:
        case TK_A_NAME:
-       case TK_A_DEVLINK:
        case TK_A_GOTO:
+       case TK_M_TAG:
+       case TK_A_TAG:
                token->key.value_off = add_string(rule_tmp->rules, value);
                break;
        case TK_M_ENV:
@@ -1008,26 +1038,28 @@ static int rule_add_key(struct rule_tmp *rule_tmp, enum token_type type,
        case TK_M_ATTRS:
        case TK_A_ATTR:
        case TK_A_ENV:
+               attr = data;
                token->key.value_off = add_string(rule_tmp->rules, value);
                token->key.attr_off = add_string(rule_tmp->rules, attr);
                break;
+       case TK_A_DEVLINK:
+               token->key.value_off = add_string(rule_tmp->rules, value);
+               token->key.devlink_unique = *(int *)data;
+               break;
        case TK_M_TEST:
                token->key.value_off = add_string(rule_tmp->rules, value);
                if (data != NULL)
                        token->key.mode = *(mode_t *)data;
                break;
-       case TK_A_IGNORE_DEVICE:
        case TK_A_STRING_ESCAPE_NONE:
        case TK_A_STRING_ESCAPE_REPLACE:
-       case TK_A_IGNORE_REMOVE:
-       case TK_A_LAST_RULE:
+       case TK_A_DB_PERSIST:
                break;
        case TK_A_RUN:
                token->key.value_off = add_string(rule_tmp->rules, value);
-               token->key.ignore_error = *(int *)data;
+               token->key.fail_on_error = *(int *)data;
                break;
        case TK_A_INOTIFY_WATCH:
-       case TK_A_NUM_FAKE_PART:
        case TK_A_DEVLINK_PRIO:
                token->key.devlink_prio = *(int *)data;
                break;
@@ -1040,7 +1072,10 @@ static int rule_add_key(struct rule_tmp *rule_tmp, enum token_type type,
        case TK_A_MODE_ID:
                token->key.mode = *(mode_t *)data;
                break;
-       case TK_A_EVENT_TIMEOUT:
+       case TK_A_STATIC_NODE:
+               token->key.value_off = add_string(rule_tmp->rules, value);
+               break;
+       case TK_M_EVENT_TIMEOUT:
                token->key.event_timeout = *(int *)data;
                break;
        case TK_RULE:
@@ -1053,15 +1088,14 @@ static int rule_add_key(struct rule_tmp *rule_tmp, enum token_type type,
                return -1;
        }
 
-       glob = GL_PLAIN;
        if (value != NULL && type < TK_M_MAX) {
                /* check if we need to split or call fnmatch() while matching rules */
+               enum string_glob_type glob;
                int has_split;
                int has_glob;
 
                has_split = (strchr(value, '|') != NULL);
-               has_glob = (strchr(value, '*') != NULL || strchr(value, '?') != NULL ||
-                           strchr(value, '[') != NULL || strchr(value, ']') != NULL);
+               has_glob = (strchr(value, '*') != NULL || strchr(value, '?') != NULL || strchr(value, '[') != NULL);
                if (has_split && has_glob) {
                        glob = GL_SPLIT_GLOB;
                } else if (has_split) {
@@ -1071,12 +1105,34 @@ static int rule_add_key(struct rule_tmp *rule_tmp, enum token_type type,
                                glob = GL_SOMETHING;
                        else
                                glob = GL_GLOB;
+               } else {
+                       glob = GL_PLAIN;
                }
+               token->key.glob = glob;
+       }
+
+       if (value != NULL && type > TK_M_MAX) {
+               /* check if assigned value has substitution chars */
+               if (value[0] == '[')
+                       token->key.subst = SB_SUBSYS;
+               else if (strchr(value, '%') != NULL || strchr(value, '$') != NULL)
+                       token->key.subst = SB_FORMAT;
+               else
+                       token->key.subst = SB_NONE;
+       }
+
+       if (attr != NULL) {
+               /* check if property/attribut name has substitution chars */
+               if (attr[0] == '[')
+                       token->key.attrsubst = SB_SUBSYS;
+               else if (strchr(attr, '%') != NULL || strchr(attr, '$') != NULL)
+                       token->key.attrsubst = SB_FORMAT;
+               else
+                       token->key.attrsubst = SB_NONE;
        }
 
        token->key.type = type;
        token->key.op = op;
-       token->key.glob = glob;
        rule_tmp->token_cur++;
        if (rule_tmp->token_cur >= ARRAY_SIZE(rule_tmp->token)) {
                err(rule_tmp->rules->udev, "temporary rule array too small\n");
@@ -1093,7 +1149,7 @@ static int sort_token(struct udev_rules *rules, struct rule_tmp *rule_tmp)
 
        for (i = 0; i < rule_tmp->token_cur; i++) {
                enum token_type next_val = TK_UNSET;
-               unsigned int next_idx;
+               unsigned int next_idx = 0;
                unsigned int j;
 
                /* find smallest value */
@@ -1126,6 +1182,9 @@ static int add_rule(struct udev_rules *rules, char *line,
        char *linepos;
        char *attr;
        struct rule_tmp rule_tmp;
+       bool bus_warn = false;
+       bool sysfs_warn = false;
+       bool id_warn = false;
 
        memset(&rule_tmp, 0x00, sizeof(struct rule_tmp));
        rule_tmp.rules = rules;
@@ -1134,7 +1193,7 @@ static int add_rule(struct udev_rules *rules, char *line,
        rule_tmp.rule.rule.filename_line = lineno;
 
        linepos = line;
-       while (1) {
+       for (;;) {
                char *key;
                char *value;
                enum operation_type op;
@@ -1210,8 +1269,22 @@ static int add_rule(struct udev_rules *rules, char *line,
                        continue;
                }
 
-               if (strcmp(key, "KERNELS") == 0 ||
-                   strcmp(key, "ID") == 0) {
+               if (strcmp(key, "KERNELS") == 0) {
+                       if (op > OP_MATCH_MAX) {
+                               err(rules->udev, "invalid KERNELS operation\n");
+                               goto invalid;
+                       }
+                       rule_add_key(&rule_tmp, TK_M_KERNELS, op, value, NULL);
+                       continue;
+               }
+
+               if (strcmp(key, "ID") == 0) {
+                       if (!id_warn) {
+                               id_warn = true;
+                               err(rules->udev, "ID= will be removed in a future udev version, "
+                                   "please use KERNEL= to match the event device, or KERNELS= "
+                                   "to match a parent device, in %s:%u\n", filename, lineno);
+                       }
                        if (op > OP_MATCH_MAX) {
                                err(rules->udev, "invalid KERNELS operation\n");
                                goto invalid;
@@ -1220,8 +1293,22 @@ static int add_rule(struct udev_rules *rules, char *line,
                        continue;
                }
 
-               if (strcmp(key, "SUBSYSTEMS") == 0 ||
-                   strcmp(key, "BUS") == 0) {
+               if (strcmp(key, "SUBSYSTEMS") == 0) {
+                       if (op > OP_MATCH_MAX) {
+                               err(rules->udev, "invalid SUBSYSTEMS operation\n");
+                               goto invalid;
+                       }
+                       rule_add_key(&rule_tmp, TK_M_SUBSYSTEMS, op, value, NULL);
+                       continue;
+               }
+
+               if (strcmp(key, "BUS") == 0) {
+                       if (!bus_warn) {
+                               bus_warn = true;
+                               err(rules->udev, "BUS= will be removed in a future udev version, "
+                                   "please use SUBSYSTEM= to match the event device, or SUBSYSTEMS= "
+                                   "to match a parent device, in %s:%u\n", filename, lineno);
+                       }
                        if (op > OP_MATCH_MAX) {
                                err(rules->udev, "invalid SUBSYSTEMS operation\n");
                                goto invalid;
@@ -1239,8 +1326,7 @@ static int add_rule(struct udev_rules *rules, char *line,
                        continue;
                }
 
-               if (strncmp(key, "ATTRS{", sizeof("ATTRS{")-1) == 0 ||
-                   strncmp(key, "SYSFS{", sizeof("SYSFS{")-1) == 0) {
+               if (strncmp(key, "ATTRS{", sizeof("ATTRS{")-1) == 0) {
                        if (op > OP_MATCH_MAX) {
                                err(rules->udev, "invalid ATTRS operation\n");
                                goto invalid;
@@ -1260,6 +1346,35 @@ static int add_rule(struct udev_rules *rules, char *line,
                        continue;
                }
 
+               if (strcmp(key, "TAGS") == 0) {
+                       if (op > OP_MATCH_MAX) {
+                               err(rules->udev, "invalid TAGS operation\n");
+                               goto invalid;
+                       }
+                       rule_add_key(&rule_tmp, TK_M_TAGS, op, value, NULL);
+                       continue;
+               }
+
+               if (strncmp(key, "SYSFS{", sizeof("SYSFS{")-1) == 0) {
+                       if (!sysfs_warn) {
+                               sysfs_warn = true;
+                               err(rules->udev, "SYSFS{}= will be removed in a future udev version, "
+                                   "please use ATTR{}= to match the event device, or ATTRS{}= "
+                                   "to match a parent device, in %s:%u\n", filename, lineno);
+                       }
+                       if (op > OP_MATCH_MAX) {
+                               err(rules->udev, "invalid ATTRS operation\n");
+                               goto invalid;
+                       }
+                       attr = get_key_attribute(rules->udev, key + sizeof("ATTRS")-1);
+                       if (attr == NULL) {
+                               err(rules->udev, "error parsing ATTRS attribute\n");
+                               goto invalid;
+                       }
+                       rule_add_key(&rule_tmp, TK_M_ATTRS, op, value, attr);
+                       continue;
+               }
+
                if (strncmp(key, "ENV{", sizeof("ENV{")-1) == 0) {
                        attr = get_key_attribute(rules->udev, key + sizeof("ENV")-1);
                        if (attr == NULL) {
@@ -1276,6 +1391,14 @@ static int add_rule(struct udev_rules *rules, char *line,
                        continue;
                }
 
+               if (strcmp(key, "TAG") == 0) {
+                       if (op < OP_MATCH_MAX)
+                               rule_add_key(&rule_tmp, TK_M_TAG, op, value, NULL);
+                       else
+                               rule_add_key(&rule_tmp, TK_A_TAG, op, value, NULL);
+                       continue;
+               }
+
                if (strcmp(key, "PROGRAM") == 0) {
                        rule_add_key(&rule_tmp, TK_M_PROGRAM, op, value, NULL);
                        continue;
@@ -1298,6 +1421,12 @@ static int add_rule(struct udev_rules *rules, char *line,
                        } else if (attr != NULL && strstr(attr, "file")) {
                                dbg(rules->udev, "IMPORT will be included as file\n");
                                rule_add_key(&rule_tmp, TK_M_IMPORT_FILE, op, value, NULL);
+                       } else if (attr != NULL && strstr(attr, "db")) {
+                               dbg(rules->udev, "IMPORT will include db values\n");
+                               rule_add_key(&rule_tmp, TK_M_IMPORT_DB, op, value, NULL);
+                       } else if (attr != NULL && strstr(attr, "cmdline")) {
+                               dbg(rules->udev, "IMPORT will include db values\n");
+                               rule_add_key(&rule_tmp, TK_M_IMPORT_CMDLINE, op, value, NULL);
                        } else if (attr != NULL && strstr(attr, "parent")) {
                                dbg(rules->udev, "IMPORT will include the parent values\n");
                                rule_add_key(&rule_tmp, TK_M_IMPORT_PARENT, op, value, NULL);
@@ -1309,7 +1438,7 @@ static int add_rule(struct udev_rules *rules, char *line,
 
                                /* allow programs in /lib/udev called without the path */
                                if (value[0] != '/')
-                                       util_strscpyl(file, sizeof(file), UDEV_PREFIX "/lib/udev/", value, NULL);
+                                       util_strscpyl(file, sizeof(file), LIBEXECDIR "/", value, NULL);
                                else
                                        util_strscpy(file, sizeof(file), value);
                                pos = strchr(file, ' ');
@@ -1348,7 +1477,7 @@ static int add_rule(struct udev_rules *rules, char *line,
                        int flag = 0;
 
                        attr = get_key_attribute(rules->udev, key + sizeof("RUN")-1);
-                       if (attr != NULL && strstr(attr, "ignore_error"))
+                       if (attr != NULL && strstr(attr, "fail_event_on_error"))
                                flag = 1;
                        rule_add_key(&rule_tmp, TK_A_RUN, op, value, &flag);
                        continue;
@@ -1373,33 +1502,34 @@ static int add_rule(struct udev_rules *rules, char *line,
                        if (op < OP_MATCH_MAX) {
                                rule_add_key(&rule_tmp, TK_M_NAME, op, value, NULL);
                        } else {
-                               if (value[0] == '\0')
-                                       info(rules->udev, "name empty, node creation suppressed\n");
-                               rule_add_key(&rule_tmp, TK_A_NAME, op, value, NULL);
-                               attr = get_key_attribute(rules->udev, key + sizeof("NAME")-1);
-                               if (attr != NULL) {
-                                       if (strstr(attr, "all_partitions") != NULL) {
-                                               int num = DEFAULT_FAKE_PARTITIONS_COUNT;
-
-                                               dbg(rules->udev, "creation of partition nodes requested\n");
-                                               rule_add_key(&rule_tmp, TK_A_NUM_FAKE_PART, 0, NULL, &num);
-                                       }
-                                       if (strstr(attr, "ignore_remove") != NULL) {
-                                               dbg(rules->udev, "remove event should be ignored\n");
-                                               rule_add_key(&rule_tmp, TK_A_IGNORE_REMOVE, 0, NULL, NULL);
-                                       }
+                               if (strcmp(value, "%k") == 0) {
+                                       err(rules->udev, "NAME=\"%%k\" is ignored, because it breaks kernel supplied names, "
+                                           "please remove it from %s:%u\n", filename, lineno);
+                                       continue;
                                }
+                               if (value[0] == '\0') {
+                                       info(rules->udev, "NAME=\"\" is ignored, because udev will not delete any device nodes, "
+                                            "please remove it from %s:%u\n", filename, lineno);
+                                       continue;
+                               }
+                               rule_add_key(&rule_tmp, TK_A_NAME, op, value, NULL);
                        }
-                       rule_tmp.rule.rule.flags = 1;
+                       rule_tmp.rule.rule.can_set_name = true;
                        continue;
                }
 
-               if (strcmp(key, "SYMLINK") == 0) {
-                       if (op < OP_MATCH_MAX)
+               if (strncmp(key, "SYMLINK", sizeof("SYMLINK")-1) == 0) {
+                       if (op < OP_MATCH_MAX) {
                                rule_add_key(&rule_tmp, TK_M_DEVLINK, op, value, NULL);
-                       else
-                               rule_add_key(&rule_tmp, TK_A_DEVLINK, op, value, NULL);
-                       rule_tmp.rule.rule.flags = 1;
+                       } else {
+                               int flag = 0;
+
+                               attr = get_key_attribute(rules->udev, key + sizeof("SYMLINK")-1);
+                               if (attr != NULL && strstr(attr, "unique") != NULL)
+                                       flag = 1;
+                               rule_add_key(&rule_tmp, TK_A_DEVLINK, op, value, &flag);
+                       }
+                       rule_tmp.rule.rule.can_set_name = true;
                        continue;
                }
 
@@ -1416,7 +1546,7 @@ static int add_rule(struct udev_rules *rules, char *line,
                        } else if (rules->resolve_names >= 0) {
                                rule_add_key(&rule_tmp, TK_A_OWNER, op, value, NULL);
                        }
-                       rule_tmp.rule.rule.flags = 1;
+                       rule_tmp.rule.rule.can_set_name = true;
                        continue;
                }
 
@@ -1433,7 +1563,7 @@ static int add_rule(struct udev_rules *rules, char *line,
                        } else if (rules->resolve_names >= 0) {
                                rule_add_key(&rule_tmp, TK_A_GROUP, op, value, NULL);
                        }
-                       rule_tmp.rule.rule.flags = 1;
+                       rule_tmp.rule.rule.can_set_name = true;
                        continue;
                }
 
@@ -1446,68 +1576,64 @@ static int add_rule(struct udev_rules *rules, char *line,
                                rule_add_key(&rule_tmp, TK_A_MODE_ID, op, NULL, &mode);
                        else
                                rule_add_key(&rule_tmp, TK_A_MODE, op, value, NULL);
-                       rule_tmp.rule.rule.flags = 1;
+                       rule_tmp.rule.rule.can_set_name = true;
                        continue;
                }
 
                if (strcmp(key, "OPTIONS") == 0) {
                        const char *pos;
 
-                       if (strstr(value, "last_rule") != NULL) {
-                               dbg(rules->udev, "last rule to be applied\n");
-                               rule_add_key(&rule_tmp, TK_A_LAST_RULE, 0, NULL, NULL);
-                       }
-                       if (strstr(value, "ignore_device") != NULL) {
-                               dbg(rules->udev, "device should be ignored\n");
-                               rule_add_key(&rule_tmp, TK_A_IGNORE_DEVICE, 0, NULL, NULL);
-                       }
-                       if (strstr(value, "ignore_remove") != NULL) {
-                               dbg(rules->udev, "remove event should be ignored\n");
-                               rule_add_key(&rule_tmp, TK_A_IGNORE_REMOVE, 0, NULL, NULL);
-                       }
                        pos = strstr(value, "link_priority=");
                        if (pos != NULL) {
                                int prio = atoi(&pos[strlen("link_priority=")]);
 
-                               rule_add_key(&rule_tmp, TK_A_DEVLINK_PRIO, 0, NULL, &prio);
+                               rule_add_key(&rule_tmp, TK_A_DEVLINK_PRIO, op, NULL, &prio);
                                dbg(rules->udev, "link priority=%i\n", prio);
                        }
+
                        pos = strstr(value, "event_timeout=");
                        if (pos != NULL) {
                                int tout = atoi(&pos[strlen("event_timeout=")]);
 
-                               rule_add_key(&rule_tmp, TK_A_EVENT_TIMEOUT, 0, NULL, &tout);
-                               dbg(rules->udev, "event timout=%i\n", tout);
+                               rule_add_key(&rule_tmp, TK_M_EVENT_TIMEOUT, op, NULL, &tout);
+                               dbg(rules->udev, "event timeout=%i\n", tout);
                        }
+
                        pos = strstr(value, "string_escape=");
                        if (pos != NULL) {
                                pos = &pos[strlen("string_escape=")];
                                if (strncmp(pos, "none", strlen("none")) == 0)
-                                       rule_add_key(&rule_tmp, TK_A_STRING_ESCAPE_NONE, 0, NULL, NULL);
+                                       rule_add_key(&rule_tmp, TK_A_STRING_ESCAPE_NONE, op, NULL, NULL);
                                else if (strncmp(pos, "replace", strlen("replace")) == 0)
-                                       rule_add_key(&rule_tmp, TK_A_STRING_ESCAPE_REPLACE, 0, NULL, NULL);
+                                       rule_add_key(&rule_tmp, TK_A_STRING_ESCAPE_REPLACE, op, NULL, NULL);
                        }
-                       if (strstr(value, "all_partitions") != NULL) {
-                               int num = DEFAULT_FAKE_PARTITIONS_COUNT;
 
-                               rule_add_key(&rule_tmp, TK_A_NUM_FAKE_PART, 0, NULL, &num);
-                               dbg(rules->udev, "creation of partition nodes requested\n");
-                       }
+                       pos = strstr(value, "db_persist");
+                       if (pos != NULL)
+                               rule_add_key(&rule_tmp, TK_A_DB_PERSIST, op, NULL, NULL);
+
                        pos = strstr(value, "nowatch");
                        if (pos != NULL) {
                                const int off = 0;
 
-                               rule_add_key(&rule_tmp, TK_A_INOTIFY_WATCH, 0, NULL, &off);
+                               rule_add_key(&rule_tmp, TK_A_INOTIFY_WATCH, op, NULL, &off);
                                dbg(rules->udev, "inotify watch of device disabled\n");
                        } else {
                                pos = strstr(value, "watch");
                                if (pos != NULL) {
                                        const int on = 1;
 
-                                       rule_add_key(&rule_tmp, TK_A_INOTIFY_WATCH, 0, NULL, &on);
+                                       rule_add_key(&rule_tmp, TK_A_INOTIFY_WATCH, op, NULL, &on);
                                        dbg(rules->udev, "inotify watch of device requested\n");
                                }
                        }
+
+                       pos = strstr(value, "static_node=");
+                       if (pos != NULL) {
+                               rule_add_key(&rule_tmp, TK_A_STATIC_NODE, op, &pos[strlen("static_node=")], NULL);
+                               rule_tmp.rule.rule.has_static_node = true;
+                       }
+
                        continue;
                }
                err(rules->udev, "unknown key '%s' in %s:%u\n", key, filename, lineno);
@@ -1544,7 +1670,7 @@ static int parse_file(struct udev_rules *rules, const char *filename, unsigned s
 
        first_token = rules->token_cur;
 
-       while(fgets(line, sizeof(line), f) != NULL) {
+       while (fgets(line, sizeof(line), f) != NULL) {
                char *key;
                size_t len;
 
@@ -1566,6 +1692,8 @@ static int parse_file(struct udev_rules *rules, const char *filename, unsigned s
                while (line[len-2] == '\\') {
                        if (fgets(&line[len-2], (sizeof(line)-len)+2, f) == NULL)
                                break;
+                       if (strlen(&line[len-2]) < 2)
+                               break;
                        line_nr++;
                        len = strlen(line);
                }
@@ -1604,6 +1732,7 @@ static int parse_file(struct udev_rules *rules, const char *filename, unsigned s
 static int add_matching_files(struct udev *udev, struct udev_list_node *file_list, const char *dirname, const char *suffix)
 {
        DIR *dir;
+       struct dirent *dent;
        char filename[UTIL_PATH_SIZE];
 
        dbg(udev, "open directory '%s'\n", dirname);
@@ -1613,13 +1742,7 @@ static int add_matching_files(struct udev *udev, struct udev_list_node *file_lis
                return -1;
        }
 
-       while (1) {
-               struct dirent *dent;
-
-               dent = readdir(dir);
-               if (dent == NULL || dent->d_name[0] == '\0')
-                       break;
-
+       for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
                if (dent->d_name[0] == '.')
                        continue;
 
@@ -1635,7 +1758,12 @@ static int add_matching_files(struct udev *udev, struct udev_list_node *file_lis
                }
                util_strscpyl(filename, sizeof(filename), dirname, "/", dent->d_name, NULL);
                dbg(udev, "put file '%s' into list\n", filename);
-               udev_list_entry_add(udev, file_list, filename, NULL, 1, 1);
+               /*
+                * the basename is the key, the filename the value
+                * identical basenames from different directories overwrite each other
+                * entries are sorted after basename
+                */
+               udev_list_entry_add(udev, file_list, dent->d_name, filename, UDEV_LIST_UNIQUE|UDEV_LIST_SORT);
        }
 
        closedir(dir);
@@ -1645,28 +1773,31 @@ static int add_matching_files(struct udev *udev, struct udev_list_node *file_lis
 struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names)
 {
        struct udev_rules *rules;
-       struct stat statbuf;
        struct udev_list_node file_list;
-       struct udev_list_entry *file_loop, *file_tmp;
+       struct udev_list_entry *file_loop;
        struct token end_token;
 
-       rules = malloc(sizeof(struct udev_rules));
+       rules = calloc(1, sizeof(struct udev_rules));
        if (rules == NULL)
                return NULL;
-       memset(rules, 0x00, sizeof(struct udev_rules));
        rules->udev = udev;
        rules->resolve_names = resolve_names;
        udev_list_init(&file_list);
 
        /* init token array and string buffer */
        rules->tokens = malloc(PREALLOC_TOKEN * sizeof(struct token));
-       if (rules->tokens == NULL)
+       if (rules->tokens == NULL) {
+               free(rules);
                return NULL;
+       }
        rules->token_max = PREALLOC_TOKEN;
 
        rules->buf = malloc(PREALLOC_STRBUF);
-       if (rules->buf == NULL)
+       if (rules->buf == NULL) {
+               free(rules->tokens);
+               free(rules);
                return NULL;
+       }
        rules->buf_max = PREALLOC_STRBUF;
        /* offset 0 is always '\0' */
        rules->buf[0] = '\0';
@@ -1675,98 +1806,66 @@ struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names)
            rules->token_max * sizeof(struct token), rules->token_max, sizeof(struct token), rules->buf_max);
 
        rules->trie_nodes = malloc(PREALLOC_TRIE * sizeof(struct trie_node));
-       if (rules->trie_nodes == NULL)
+       if (rules->trie_nodes == NULL) {
+               free(rules->buf);
+               free(rules->tokens);
+               free(rules);
                return NULL;
+       }
        rules->trie_nodes_max = PREALLOC_TRIE;
        /* offset 0 is the trie root, with an empty string */
        memset(rules->trie_nodes, 0x00, sizeof(struct trie_node));
        rules->trie_nodes_cur = 1;
 
-       if (udev_get_rules_path(udev) != NULL) {
-               /* custom rules location for testing */
-               add_matching_files(udev, &file_list, udev_get_rules_path(udev), ".rules");
-       } else {
-               char filename[PATH_MAX];
-               struct udev_list_node sort_list;
-               struct udev_list_entry *sort_loop, *sort_tmp;
-
-               /* read user/custom rules */
-               add_matching_files(udev, &file_list, SYSCONFDIR "/udev/rules.d", ".rules");
-
-               /* read dynamic/temporary rules */
-               util_strscpyl(filename, sizeof(filename), udev_get_dev_path(udev), "/.udev/rules.d", NULL);
-               if (stat(filename, &statbuf) != 0) {
-                       util_create_path(udev, filename);
-                       udev_selinux_setfscreatecon(udev, filename, S_IFDIR|0755);
-                       mkdir(filename, 0755);
-                       udev_selinux_resetfscreatecon(udev);
-               }
-               udev_list_init(&sort_list);
-               add_matching_files(udev, &sort_list, filename, ".rules");
+       if (udev_get_rules_path(udev) == NULL) {
+               char filename[UTIL_PATH_SIZE];
 
-               /* read default rules */
-               add_matching_files(udev, &sort_list, UDEV_PREFIX "/lib/udev/rules.d", ".rules");
+               /* /lib/udev -- default/package rules */
+               add_matching_files(udev, &file_list, LIBEXECDIR "/rules.d", ".rules");
 
-               /* sort all rules files by basename into list of files */
-               udev_list_entry_foreach_safe(sort_loop, sort_tmp, udev_list_get_entry(&sort_list)) {
-                       const char *sort_name = udev_list_entry_get_name(sort_loop);
-                       const char *sort_base = strrchr(sort_name, '/');
-
-                       if (sort_base == NULL)
-                               continue;
-                       /* sort entry into existing list */
-                       udev_list_entry_foreach_safe(file_loop, file_tmp, udev_list_get_entry(&file_list)) {
-                               const char *file_name = udev_list_entry_get_name(file_loop);
-                               const char *file_base = strrchr(file_name, '/');
+               /* /etc/udev -- system-specific/user/admin rules */
+               add_matching_files(udev, &file_list, SYSCONFDIR "/udev/rules.d", ".rules");
 
-                               if (file_base == NULL)
-                                       continue;
-                               if (strcmp(file_base, sort_base) == 0) {
-                                       info(udev, "rule file basename '%s' already added, ignoring '%s'\n",
-                                            file_name, sort_name);
-                                       udev_list_entry_delete(sort_loop);
-                                       sort_loop = NULL;
-                                       break;
-                               }
-                               if (strcmp(file_base, sort_base) > 0) {
-                                       /* found later file, insert before */
-                                       udev_list_entry_remove(sort_loop);
-                                       udev_list_entry_insert_before(sort_loop, file_loop);
-                                       sort_loop = NULL;
-                                       break;
-                               }
-                       }
-                       /* current file already handled */
-                       if (sort_loop == NULL)
-                               continue;
-                       /* no later file, append to end of list */
-                       udev_list_entry_remove(sort_loop);
-                       udev_list_entry_append(sort_loop, &file_list);
-               }
+               /* /run/udev -- throw-away/temporary rules */
+               util_strscpyl(filename, sizeof(filename), udev_get_run_path(udev), "/rules.d", NULL);
+               add_matching_files(udev, &file_list, filename, ".rules");
+       } else {
+               /* custom rules files location for testing */
+               add_matching_files(udev, &file_list, udev_get_rules_path(udev), ".rules");
        }
 
        /* add all filenames to the string buffer */
        udev_list_entry_foreach(file_loop, udev_list_get_entry(&file_list)) {
-               const char *filename = udev_list_entry_get_name(file_loop);
+               const char *filename = udev_list_entry_get_value(file_loop);
                unsigned int filename_off;
 
                filename_off = add_string(rules, filename);
                /* the offset in the rule is limited to unsigned short */
                if (filename_off < USHRT_MAX)
-                       udev_list_entry_set_flag(file_loop, filename_off);
+                       udev_list_entry_set_num(file_loop, filename_off);
        }
 
-       /* parse list of files */
-       udev_list_entry_foreach_safe(file_loop, file_tmp, udev_list_get_entry(&file_list)) {
-               const char *filename = udev_list_entry_get_name(file_loop);
-               unsigned int filename_off = udev_list_entry_get_flag(file_loop);
+       /* parse all rules files */
+       udev_list_entry_foreach(file_loop, udev_list_get_entry(&file_list)) {
+               const char *filename = udev_list_entry_get_value(file_loop);
+               unsigned int filename_off = udev_list_entry_get_num(file_loop);
+               struct stat st;
 
-               if (stat(filename, &statbuf) == 0 && statbuf.st_size > 0)
-                       parse_file(rules, filename, filename_off);
-               else
-                       info(udev, "can not read '%s'\n", filename);
-               udev_list_entry_delete(file_loop);
+               if (stat(filename, &st) != 0) {
+                       err(udev, "can not find '%s': %m\n", filename);
+                       continue;
+               }
+               if (S_ISREG(st.st_mode) && st.st_size <= 0) {
+                       info(udev, "ignore empty '%s'\n", filename);
+                       continue;
+               }
+               if (S_ISCHR(st.st_mode)) {
+                       info(udev, "ignore masked '%s'\n", filename);
+                       continue;
+               }
+               parse_file(rules, filename, filename_off);
        }
+       udev_list_cleanup_entries(udev, &file_list);
 
        memset(&end_token, 0x00, sizeof(struct token));
        end_token.type = TK_END;
@@ -1833,7 +1932,7 @@ static int match_key(struct udev_rules *rules, struct token *token, const char *
 {
        char *key_value = &rules->buf[token->key.value_off];
        char *pos;
-       int match = 0;
+       bool match = false;
 
        if (val == NULL)
                val = "";
@@ -1852,7 +1951,7 @@ static int match_key(struct udev_rules *rules, struct token *token, const char *
 
                        split = &rules->buf[token->key.value_off];
                        len = strlen(val);
-                       while (1) {
+                       for (;;) {
                                const char *next;
 
                                next = strchr(split, '|');
@@ -1911,35 +2010,51 @@ static int match_key(struct udev_rules *rules, struct token *token, const char *
 
 static int match_attr(struct udev_rules *rules, struct udev_device *dev, struct udev_event *event, struct token *cur)
 {
-       const char *key_name = &rules->buf[cur->key.attr_off];
-       const char *key_value = &rules->buf[cur->key.value_off];
-       char value[UTIL_NAME_SIZE];
+       const char *name;
+       char nbuf[UTIL_NAME_SIZE];
+       const char *value;
+       char vbuf[UTIL_NAME_SIZE];
        size_t len;
 
-       value[0] = '\0';
-       if (key_name[0] == '[') {
-               char attr[UTIL_PATH_SIZE];
-
-               util_strscpy(attr, sizeof(attr), key_name);
-               util_resolve_subsys_kernel(event->udev, attr, value, sizeof(value), 1);
-       }
-       if (value[0] == '\0') {
-               const char *val;
-
-               val = udev_device_get_sysattr_value(dev, key_name);
-               if (val == NULL)
+       name = &rules->buf[cur->key.attr_off];
+       switch (cur->key.attrsubst) {
+       case SB_FORMAT:
+               udev_event_apply_format(event, name, nbuf, sizeof(nbuf));
+               name = nbuf;
+               /* fall through */
+       case SB_NONE:
+               value = udev_device_get_sysattr_value(dev, name);
+               if (value == NULL)
+                       return -1;
+               break;
+       case SB_SUBSYS:
+               if (util_resolve_subsys_kernel(event->udev, name, vbuf, sizeof(vbuf), 1) != 0)
                        return -1;
-               util_strscpy(value, sizeof(value), val);
+               value = vbuf;
+               break;
+       default:
+               return -1;
        }
 
-       /* strip trailing whitespace of value, if not asked to match for it */
-       len = strlen(key_value);
-       if (len > 0 && !isspace(key_value[len-1])) {
-               len = strlen(value);
-               while (len > 0 && isspace(value[--len]))
-                       value[len] = '\0';
-               dbg(rules->udev, "removed trailing whitespace from '%s'\n", value);
+       /* remove trailing whitespace, if not asked to match for it */
+       len = strlen(value);
+       if (len > 0 && isspace(value[len-1])) {
+               const char *key_value;
+               size_t klen;
+
+               key_value = &rules->buf[cur->key.value_off];
+               klen = strlen(key_value);
+               if (klen > 0 && !isspace(key_value[klen-1])) {
+                       if (value != vbuf) {
+                               util_strscpy(vbuf, sizeof(vbuf), value);
+                               value = vbuf;
+                       }
+                       while (len > 0 && isspace(vbuf[--len]))
+                               vbuf[len] = '\0';
+                       dbg(rules->udev, "removed trailing whitespace from '%s'\n", value);
+               }
        }
+
        return match_key(rules, cur, value);
 }
 
@@ -1949,32 +2064,31 @@ enum escape_type {
        ESCAPE_REPLACE,
 };
 
-int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event)
+int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event, const sigset_t *sigmask)
 {
        struct token *cur;
        struct token *rule;
        enum escape_type esc = ESCAPE_UNSET;
-       int can_set_name;
+       bool can_set_name;
 
        if (rules->tokens == NULL)
                return -1;
 
-       can_set_name = ((strcmp(udev_device_get_action(event->dev), "add") == 0 ||
-                        strcmp(udev_device_get_action(event->dev), "change") == 0) &&
+       can_set_name = ((strcmp(udev_device_get_action(event->dev), "remove") != 0) &&
                        (major(udev_device_get_devnum(event->dev)) > 0 ||
-                        strcmp(udev_device_get_subsystem(event->dev), "net") == 0));
+                        udev_device_get_ifindex(event->dev) > 0));
 
        /* loop through token list, match, run actions or forward to next rule */
        cur = &rules->tokens[0];
        rule = cur;
-       while (1) {
+       for (;;) {
                dump_token(rules, cur);
                switch (cur->type) {
                case TK_RULE:
                        /* current rule */
                        rule = cur;
                        /* possibly skip rules which want to set NAME, SYMLINK, OWNER, GROUP, MODE */
-                       if (!can_set_name && rule->rule.flags)
+                       if (!can_set_name && rule->rule.can_set_name)
                                goto nomatch;
                        esc = ESCAPE_UNSET;
                        break;
@@ -1990,43 +2104,55 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                        if (match_key(rules, cur, udev_device_get_sysname(event->dev)) != 0)
                                goto nomatch;
                        break;
-               case TK_M_DEVLINK:
-                       {
-                               size_t devlen = strlen(udev_get_dev_path(event->udev))+1;
-                               struct udev_list_entry *list_entry;
-                               int match = 0;
-
-                               udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(event->dev)) {
-                                       const char *devlink;
-
-                                       devlink =  &udev_list_entry_get_name(list_entry)[devlen];
-                                       if (match_key(rules, cur, devlink) == 0) {
-                                               match = 1;
-                                               break;
-                                       }
+               case TK_M_DEVLINK: {
+                       size_t devlen = strlen(udev_get_dev_path(event->udev))+1;
+                       struct udev_list_entry *list_entry;
+                       bool match = false;
+
+                       udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(event->dev)) {
+                               const char *devlink;
+
+                               devlink =  &udev_list_entry_get_name(list_entry)[devlen];
+                               if (match_key(rules, cur, devlink) == 0) {
+                                       match = true;
+                                       break;
                                }
-                               if (!match)
-                                       goto nomatch;
-                               break;
                        }
+                       if (!match)
+                               goto nomatch;
+                       break;
+               }
                case TK_M_NAME:
                        if (match_key(rules, cur, event->name) != 0)
                                goto nomatch;
                        break;
-               case TK_M_ENV:
-                       {
-                               const char *key_name = &rules->buf[cur->key.attr_off];
-                               const char *value;
-
-                               value = udev_device_get_property_value(event->dev, key_name);
-                               if (value == NULL) {
-                                       dbg(event->udev, "ENV{%s} is not set, treat as empty\n", key_name);
-                                       value = "";
+               case TK_M_ENV: {
+                       const char *key_name = &rules->buf[cur->key.attr_off];
+                       const char *value;
+
+                       value = udev_device_get_property_value(event->dev, key_name);
+                       if (value == NULL) {
+                               dbg(event->udev, "ENV{%s} is not set, treat as empty\n", key_name);
+                               value = "";
+                       }
+                       if (match_key(rules, cur, value))
+                               goto nomatch;
+                       break;
+               }
+               case TK_M_TAG: {
+                       struct udev_list_entry *list_entry;
+                       bool match = false;
+
+                       udev_list_entry_foreach(list_entry, udev_device_get_tags_list_entry(event->dev)) {
+                               if (strcmp(&rules->buf[cur->key.value_off], udev_list_entry_get_name(list_entry)) == 0) {
+                                       match = true;
+                                       break;
                                }
-                               if (match_key(rules, cur, value))
-                                       goto nomatch;
-                               break;
                        }
+                       if (!match && (cur->key.op != OP_NOMATCH))
+                               goto nomatch;
+                       break;
+               }
                case TK_M_SUBSYSTEM:
                        if (match_key(rules, cur, udev_device_get_subsystem(event->dev)) != 0)
                                goto nomatch;
@@ -2035,17 +2161,16 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                        if (match_key(rules, cur, udev_device_get_driver(event->dev)) != 0)
                                goto nomatch;
                        break;
-               case TK_M_WAITFOR:
-                       {
-                               char filename[UTIL_PATH_SIZE];
-                               int found;
-
-                               udev_event_apply_format(event, &rules->buf[cur->key.value_off], filename, sizeof(filename));
-                               found = (wait_for_file(event->dev, filename, 10) == 0);
-                               if (!found && (cur->key.op != OP_NOMATCH))
-                                       goto nomatch;
-                               break;
-                       }
+               case TK_M_WAITFOR: {
+                       char filename[UTIL_PATH_SIZE];
+                       int found;
+
+                       udev_event_apply_format(event, &rules->buf[cur->key.value_off], filename, sizeof(filename));
+                       found = (wait_for_file(event->dev, filename, 10) == 0);
+                       if (!found && (cur->key.op != OP_NOMATCH))
+                               goto nomatch;
+                       break;
+               }
                case TK_M_ATTR:
                        if (match_attr(rules, event->dev, event, cur) != 0)
                                goto nomatch;
@@ -2054,242 +2179,304 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                case TK_M_SUBSYSTEMS:
                case TK_M_DRIVERS:
                case TK_M_ATTRS:
-                       {
-                               struct token *next;
-
-                               /* get whole sequence of parent matches */
-                               next = cur;
-                               while (next->type > TK_M_PARENTS_MIN && next->type < TK_M_PARENTS_MAX)
-                                       next++;
+               case TK_M_TAGS: {
+                       struct token *next;
+
+                       /* get whole sequence of parent matches */
+                       next = cur;
+                       while (next->type > TK_M_PARENTS_MIN && next->type < TK_M_PARENTS_MAX)
+                               next++;
+
+                       /* loop over parents */
+                       event->dev_parent = event->dev;
+                       for (;;) {
+                               struct token *key;
+
+                               dbg(event->udev, "parent: '%s'\n", udev_device_get_syspath(event->dev_parent));
+                               /* loop over sequence of parent match keys */
+                               for (key = cur; key < next; key++ ) {
+                                       dump_token(rules, key);
+                                       switch(key->type) {
+                                       case TK_M_KERNELS:
+                                               if (match_key(rules, key, udev_device_get_sysname(event->dev_parent)) != 0)
+                                                       goto try_parent;
+                                               break;
+                                       case TK_M_SUBSYSTEMS:
+                                               if (match_key(rules, key, udev_device_get_subsystem(event->dev_parent)) != 0)
+                                                       goto try_parent;
+                                               break;
+                                       case TK_M_DRIVERS:
+                                               if (match_key(rules, key, udev_device_get_driver(event->dev_parent)) != 0)
+                                                       goto try_parent;
+                                               break;
+                                       case TK_M_ATTRS:
+                                               if (match_attr(rules, event->dev_parent, event, key) != 0)
+                                                       goto try_parent;
+                                               break;
+                                       case TK_M_TAGS: {
+                                               bool match = udev_device_has_tag(event->dev_parent, &rules->buf[cur->key.value_off]);
 
-                               /* loop over parents */
-                               event->dev_parent = event->dev;
-                               while (1) {
-                                       struct token *key;
-
-                                       dbg(event->udev, "parent: '%s'\n", udev_device_get_syspath(event->dev_parent));
-                                       /* loop over sequence of parent match keys */
-                                       for (key = cur; key < next; key++ ) {
-                                               dump_token(rules, key);
-                                               switch(key->type) {
-                                               case TK_M_KERNELS:
-                                                       if (match_key(rules, key, udev_device_get_sysname(event->dev_parent)) != 0)
-                                                               goto try_parent;
-                                                       break;
-                                               case TK_M_SUBSYSTEMS:
-                                                       if (match_key(rules, key, udev_device_get_subsystem(event->dev_parent)) != 0)
-                                                               goto try_parent;
-                                                       break;
-                                               case TK_M_DRIVERS:
-                                                       if (match_key(rules, key, udev_device_get_driver(event->dev_parent)) != 0)
-                                                               goto try_parent;
-                                                       break;
-                                               case TK_M_ATTRS:
-                                                       if (match_attr(rules, event->dev_parent, event, key) != 0)
-                                                               goto try_parent;
-                                                       break;
-                                               default:
-                                                       goto nomatch;
-                                               }
-                                               dbg(event->udev, "parent key matched\n");
+                                               if (match && key->key.op == OP_NOMATCH)
+                                                       goto try_parent;
+                                               if (!match && key->key.op == OP_MATCH)
+                                                       goto try_parent;
+                                               break;
                                        }
-                                       dbg(event->udev, "all parent keys matched\n");
-                                       /* all keys matched */
-                                       break;
-
-                               try_parent:
-                                       event->dev_parent = udev_device_get_parent(event->dev_parent);
-                                       if (event->dev_parent == NULL)
+                                       default:
                                                goto nomatch;
+                                       }
+                                       dbg(event->udev, "parent key matched\n");
                                }
-                               /* move behind our sequence of parent match keys */
-                               cur = next;
-                               continue;
+                               dbg(event->udev, "all parent keys matched\n");
+                               break;
+
+                       try_parent:
+                               event->dev_parent = udev_device_get_parent(event->dev_parent);
+                               if (event->dev_parent == NULL)
+                                       goto nomatch;
                        }
-               case TK_M_TEST:
-                       {
-                               char filename[UTIL_PATH_SIZE];
-                               struct stat statbuf;
-                               int match;
+                       /* move behind our sequence of parent match keys */
+                       cur = next;
+                       continue;
+               }
+               case TK_M_TEST: {
+                       char filename[UTIL_PATH_SIZE];
+                       struct stat statbuf;
+                       int match;
+
+                       udev_event_apply_format(event, &rules->buf[cur->key.value_off], filename, sizeof(filename));
+                       if (util_resolve_subsys_kernel(event->udev, filename, filename, sizeof(filename), 0) != 0) {
+                               if (filename[0] != '/') {
+                                       char tmp[UTIL_PATH_SIZE];
+
+                                       util_strscpy(tmp, sizeof(tmp), filename);
+                                       util_strscpyl(filename, sizeof(filename),
+                                                     udev_device_get_syspath(event->dev), "/", tmp, NULL);
+                               }
+                       }
+                       attr_subst_subdir(filename, sizeof(filename));
+
+                       match = (stat(filename, &statbuf) == 0);
+                       dbg(event->udev, "'%s' %s", filename, match ? "exists\n" : "does not exist\n");
+                       if (match && cur->key.mode > 0) {
+                               match = ((statbuf.st_mode & cur->key.mode) > 0);
+                               dbg(event->udev, "'%s' has mode=%#o and %s %#o\n", filename, statbuf.st_mode,
+                                   match ? "matches" : "does not match", cur->key.mode);
+                       }
+                       if (match && cur->key.op == OP_NOMATCH)
+                               goto nomatch;
+                       if (!match && cur->key.op == OP_MATCH)
+                               goto nomatch;
+                       break;
+               }
+               case TK_M_EVENT_TIMEOUT:
+                       info(event->udev, "OPTIONS event_timeout=%u\n", cur->key.event_timeout);
+                       event->timeout_usec = cur->key.event_timeout * 1000 * 1000;
+                       break;
+               case TK_M_PROGRAM: {
+                       char program[UTIL_PATH_SIZE];
+                       char **envp;
+                       char result[UTIL_PATH_SIZE];
+
+                       free(event->program_result);
+                       event->program_result = NULL;
+                       udev_event_apply_format(event, &rules->buf[cur->key.value_off], program, sizeof(program));
+                       envp = udev_device_get_properties_envp(event->dev);
+                       info(event->udev, "PROGRAM '%s' %s:%u\n",
+                            program,
+                            &rules->buf[rule->rule.filename_off],
+                            rule->rule.filename_line);
 
-                               udev_event_apply_format(event, &rules->buf[cur->key.value_off], filename, sizeof(filename));
-                               if (util_resolve_subsys_kernel(event->udev, filename, filename, sizeof(filename), 0) != 0) {
-                                       if (filename[0] != '/') {
-                                               char tmp[UTIL_PATH_SIZE];
+                       if (udev_event_spawn(event, program, envp, sigmask, result, sizeof(result)) < 0) {
+                               if (cur->key.op != OP_NOMATCH)
+                                       goto nomatch;
+                       } else {
+                               int count;
 
-                                               util_strscpy(tmp, sizeof(tmp), filename);
-                                               util_strscpyl(filename, sizeof(filename),
-                                                             udev_device_get_syspath(event->dev), "/", tmp, NULL);
-                                       }
-                               }
-                               attr_subst_subdir(filename, sizeof(filename));
-
-                               match = (stat(filename, &statbuf) == 0);
-                               dbg(event->udev, "'%s' %s", filename, match ? "exists\n" : "does not exist\n");
-                               if (match && cur->key.mode > 0) {
-                                       match = ((statbuf.st_mode & cur->key.mode) > 0);
-                                       dbg(event->udev, "'%s' has mode=%#o and %s %#o\n", filename, statbuf.st_mode,
-                                           match ? "matches" : "does not match", cur->key.mode);
+                               util_remove_trailing_chars(result, '\n');
+                               if (esc == ESCAPE_UNSET || esc == ESCAPE_REPLACE) {
+                                       count = udev_util_replace_chars(result, UDEV_ALLOWED_CHARS_INPUT);
+                                       if (count > 0)
+                                               info(event->udev, "%i character(s) replaced\n" , count);
                                }
-                               if (match && cur->key.op == OP_NOMATCH)
+                               event->program_result = strdup(result);
+                               dbg(event->udev, "storing result '%s'\n", event->program_result);
+                               if (cur->key.op == OP_NOMATCH)
                                        goto nomatch;
-                               if (!match && cur->key.op == OP_MATCH)
-                                       goto nomatch;
-                               break;
                        }
-               case TK_M_PROGRAM:
-                       {
-                               char program[UTIL_PATH_SIZE];
-                               char **envp;
-                               char result[UTIL_PATH_SIZE];
-
-                               free(event->program_result);
-                               event->program_result = NULL;
-                               udev_event_apply_format(event, &rules->buf[cur->key.value_off], program, sizeof(program));
-                               envp = udev_device_get_properties_envp(event->dev);
-                               info(event->udev, "PROGRAM '%s' %s:%u\n",
-                                    program,
-                                    &rules->buf[rule->rule.filename_off],
-                                    rule->rule.filename_line);
-                               if (util_run_program(event->udev, program, envp, result, sizeof(result), NULL) != 0) {
-                                       if (cur->key.op != OP_NOMATCH)
-                                               goto nomatch;
-                               } else {
-                                       int count;
+                       break;
+               }
+               case TK_M_IMPORT_FILE: {
+                       char import[UTIL_PATH_SIZE];
 
-                                       util_remove_trailing_chars(result, '\n');
-                                       if (esc == ESCAPE_UNSET || esc == ESCAPE_REPLACE) {
-                                               count = udev_util_replace_chars(result, UDEV_ALLOWED_CHARS_INPUT);
-                                               if (count > 0)
-                                                       info(event->udev, "%i character(s) replaced\n" , count);
-                                       }
-                                       event->program_result = strdup(result);
-                                       dbg(event->udev, "storing result '%s'\n", event->program_result);
-                                       if (cur->key.op == OP_NOMATCH)
-                                               goto nomatch;
-                               }
-                               break;
-                       }
-               case TK_M_IMPORT_FILE:
-                       {
-                               char import[UTIL_PATH_SIZE];
+                       udev_event_apply_format(event, &rules->buf[cur->key.value_off], import, sizeof(import));
+                       if (import_file_into_properties(event->dev, import) != 0)
+                               if (cur->key.op != OP_NOMATCH)
+                                       goto nomatch;
+                       break;
+               }
+               case TK_M_IMPORT_PROG: {
+                       char import[UTIL_PATH_SIZE];
 
-                               udev_event_apply_format(event, &rules->buf[cur->key.value_off], import, sizeof(import));
-                               if (import_file_into_properties(event->dev, import) != 0)
-                                       if (cur->key.op != OP_NOMATCH)
-                                               goto nomatch;
-                               break;
+                       udev_event_apply_format(event, &rules->buf[cur->key.value_off], import, sizeof(import));
+                       info(event->udev, "IMPORT '%s' %s:%u\n",
+                            import,
+                            &rules->buf[rule->rule.filename_off],
+                            rule->rule.filename_line);
+
+                       if (import_program_into_properties(event, import, sigmask) != 0)
+                               if (cur->key.op != OP_NOMATCH)
+                                       goto nomatch;
+                       break;
+               }
+               case TK_M_IMPORT_DB: {
+                       const char *key = &rules->buf[cur->key.value_off];
+                       const char *value;
+
+                       value = udev_device_get_property_value(event->dev_db, key);
+                       if (value != NULL) {
+                               struct udev_list_entry *entry;
+
+                               entry = udev_device_add_property(event->dev, key, value);
+                               udev_list_entry_set_num(entry, true);
+                       } else {
+                               if (cur->key.op != OP_NOMATCH)
+                                       goto nomatch;
                        }
-               case TK_M_IMPORT_PROG:
-                       {
-                               char import[UTIL_PATH_SIZE];
-
-                               udev_event_apply_format(event, &rules->buf[cur->key.value_off], import, sizeof(import));
-                               info(event->udev, "IMPORT '%s' %s:%u\n",
-                                    import,
-                                    &rules->buf[rule->rule.filename_off],
-                                    rule->rule.filename_line);
-                               if (import_program_into_properties(event->dev, import) != 0)
-                                       if (cur->key.op != OP_NOMATCH)
-                                               goto nomatch;
-                               break;
+                       break;
+               }
+               case TK_M_IMPORT_CMDLINE: {
+                       FILE *f;
+                       bool imported = false;
+
+                       f = fopen("/proc/cmdline", "r");
+                       if (f != NULL) {
+                               char cmdline[4096];
+
+                               if (fgets(cmdline, sizeof(cmdline), f) != NULL) {
+                                       const char *key = &rules->buf[cur->key.value_off];
+                                       char *pos;
+
+                                       pos = strstr(cmdline, key);
+                                       if (pos != NULL) {
+                                               struct udev_list_entry *entry;
+
+                                               pos += strlen(key);
+                                               if (pos[0] == '\0' || isspace(pos[0])) {
+                                                       /* we import simple flags as 'FLAG=1' */
+                                                       entry = udev_device_add_property(event->dev, key, "1");
+                                                       udev_list_entry_set_num(entry, true);
+                                                       imported = true;
+                                               } else if (pos[0] == '=') {
+                                                       const char *value;
+
+                                                       pos++;
+                                                       value = pos;
+                                                       while (pos[0] != '\0' && !isspace(pos[0]))
+                                                               pos++;
+                                                       pos[0] = '\0';
+                                                       entry = udev_device_add_property(event->dev, key, value);
+                                                       udev_list_entry_set_num(entry, true);
+                                                       imported = true;
+                                               }
+                                       }
+                               }
+                               fclose(f);
                        }
-               case TK_M_IMPORT_PARENT:
-                       {
-                               char import[UTIL_PATH_SIZE];
+                       if (!imported && cur->key.op != OP_NOMATCH)
+                               goto nomatch;
+                       break;
+               }
+               case TK_M_IMPORT_PARENT: {
+                       char import[UTIL_PATH_SIZE];
 
-                               udev_event_apply_format(event, &rules->buf[cur->key.value_off], import, sizeof(import));
-                               if (import_parent_into_properties(event->dev, import) != 0)
-                                       if (cur->key.op != OP_NOMATCH)
-                                               goto nomatch;
-                               break;
-                       }
+                       udev_event_apply_format(event, &rules->buf[cur->key.value_off], import, sizeof(import));
+                       if (import_parent_into_properties(event->dev, import) != 0)
+                               if (cur->key.op != OP_NOMATCH)
+                                       goto nomatch;
+                       break;
+               }
                case TK_M_RESULT:
                        if (match_key(rules, cur, event->program_result) != 0)
                                goto nomatch;
                        break;
-
-               case TK_A_IGNORE_DEVICE:
-                       event->ignore_device = 1;
-                       return 0;
-                       break;
                case TK_A_STRING_ESCAPE_NONE:
                        esc = ESCAPE_NONE;
                        break;
                case TK_A_STRING_ESCAPE_REPLACE:
                        esc = ESCAPE_REPLACE;
                        break;
-               case TK_A_NUM_FAKE_PART:
-                       if (strcmp(udev_device_get_subsystem(event->dev), "block") != 0)
-                               break;
-                       if (udev_device_get_sysnum(event->dev) != NULL)
-                               break;
-                       udev_device_set_num_fake_partitions(event->dev, cur->key.num_fake_part);
+               case TK_A_DB_PERSIST:
+                       udev_device_set_db_persist(event->dev);
                        break;
                case TK_A_INOTIFY_WATCH:
+                       if (event->inotify_watch_final)
+                               break;
+                       if (cur->key.op == OP_ASSIGN_FINAL)
+                               event->inotify_watch_final = true;
                        event->inotify_watch = cur->key.watch;
                        break;
                case TK_A_DEVLINK_PRIO:
                        udev_device_set_devlink_priority(event->dev, cur->key.devlink_prio);
                        break;
-               case TK_A_OWNER:
-                       {
-                               char owner[UTIL_NAME_SIZE];
+               case TK_A_OWNER: {
+                       char owner[UTIL_NAME_SIZE];
 
-                               if (event->owner_final)
-                                       break;
-                               if (cur->key.op == OP_ASSIGN_FINAL)
-                                       event->owner_final = 1;
-                               udev_event_apply_format(event, &rules->buf[cur->key.value_off], owner, sizeof(owner));
-                               event->uid = util_lookup_user(event->udev, owner);
-                               info(event->udev, "OWNER %u %s:%u\n",
-                                    event->uid,
-                                    &rules->buf[rule->rule.filename_off],
-                                    rule->rule.filename_line);
+                       if (event->owner_final)
                                break;
-                       }
-               case TK_A_GROUP:
-                       {
-                               char group[UTIL_NAME_SIZE];
+                       if (cur->key.op == OP_ASSIGN_FINAL)
+                               event->owner_final = true;
+                       udev_event_apply_format(event, &rules->buf[cur->key.value_off], owner, sizeof(owner));
+                       event->uid = util_lookup_user(event->udev, owner);
+                       info(event->udev, "OWNER %u %s:%u\n",
+                            event->uid,
+                            &rules->buf[rule->rule.filename_off],
+                            rule->rule.filename_line);
+                       break;
+               }
+               case TK_A_GROUP: {
+                       char group[UTIL_NAME_SIZE];
 
-                               if (event->group_final)
-                                       break;
-                               if (cur->key.op == OP_ASSIGN_FINAL)
-                                       event->group_final = 1;
-                               udev_event_apply_format(event, &rules->buf[cur->key.value_off], group, sizeof(group));
-                               event->gid = util_lookup_group(event->udev, group);
-                               info(event->udev, "GROUP %u %s:%u\n",
-                                    event->gid,
-                                    &rules->buf[rule->rule.filename_off],
-                                    rule->rule.filename_line);
+                       if (event->group_final)
                                break;
-                       }
-               case TK_A_MODE:
-                       {
-                               char mode[UTIL_NAME_SIZE];
-                               char *endptr;
+                       if (cur->key.op == OP_ASSIGN_FINAL)
+                               event->group_final = true;
+                       udev_event_apply_format(event, &rules->buf[cur->key.value_off], group, sizeof(group));
+                       event->gid = util_lookup_group(event->udev, group);
+                       info(event->udev, "GROUP %u %s:%u\n",
+                            event->gid,
+                            &rules->buf[rule->rule.filename_off],
+                            rule->rule.filename_line);
+                       break;
+               }
+               case TK_A_MODE: {
+                       char mode_str[UTIL_NAME_SIZE];
+                       mode_t mode;
+                       char *endptr;
 
-                               if (event->mode_final)
-                                       break;
-                               if (cur->key.op == OP_ASSIGN_FINAL)
-                                       event->mode_final = 1;
-                               udev_event_apply_format(event, &rules->buf[cur->key.value_off], mode, sizeof(mode));
-                               event->mode = strtol(mode, &endptr, 8);
-                               if (endptr[0] != '\0') {
-                                       err(event->udev, "invalide mode '%s' set default mode 0660\n", mode);
-                                       event->mode = 0660;
-                               }
-                               info(event->udev, "MODE %#o %s:%u\n",
-                                    event->mode,
-                                    &rules->buf[rule->rule.filename_off],
-                                    rule->rule.filename_line);
+                       if (event->mode_final)
+                               break;
+                       udev_event_apply_format(event, &rules->buf[cur->key.value_off], mode_str, sizeof(mode_str));
+                       mode = strtol(mode_str, &endptr, 8);
+                       if (endptr[0] != '\0') {
+                               err(event->udev, "ignoring invalid mode '%s'\n", mode_str);
                                break;
                        }
+                       if (cur->key.op == OP_ASSIGN_FINAL)
+                               event->mode_final = true;
+                       event->mode_set = true;
+                       event->mode = mode;
+                       info(event->udev, "MODE %#o %s:%u\n",
+                            event->mode,
+                            &rules->buf[rule->rule.filename_off],
+                            rule->rule.filename_line);
+                       break;
+               }
                case TK_A_OWNER_ID:
                        if (event->owner_final)
                                break;
                        if (cur->key.op == OP_ASSIGN_FINAL)
-                               event->owner_final = 1;
+                               event->owner_final = true;
                        event->uid = cur->key.uid;
                        info(event->udev, "OWNER %u %s:%u\n",
                             event->uid,
@@ -2300,7 +2487,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                        if (event->group_final)
                                break;
                        if (cur->key.op == OP_ASSIGN_FINAL)
-                               event->group_final = 1;
+                               event->group_final = true;
                        event->gid = cur->key.gid;
                        info(event->udev, "GROUP %u %s:%u\n",
                             event->gid,
@@ -2311,160 +2498,157 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                        if (event->mode_final)
                                break;
                        if (cur->key.op == OP_ASSIGN_FINAL)
-                               event->mode_final = 1;
+                               event->mode_final = true;
+                       event->mode_set = true;
                        event->mode = cur->key.mode;
                        info(event->udev, "MODE %#o %s:%u\n",
                             event->mode,
                             &rules->buf[rule->rule.filename_off],
                             rule->rule.filename_line);
                        break;
-               case TK_A_ENV:
-                       {
-                               const char *name = &rules->buf[cur->key.attr_off];
-                               char *value = &rules->buf[cur->key.value_off];
-
-                               if (value[0] != '\0') {
-                                       char temp_value[UTIL_NAME_SIZE];
-                                       struct udev_list_entry *entry;
-
-                                       udev_event_apply_format(event, value, temp_value, sizeof(temp_value));
-                                       entry = udev_device_add_property(event->dev, name, temp_value);
-                                       /* store in db */
-                                       udev_list_entry_set_flag(entry, 1);
-                               } else {
-                                       udev_device_add_property(event->dev, name, NULL);
-                               }
-                               break;
+               case TK_A_STATIC_NODE:
+                       break;
+               case TK_A_ENV: {
+                       const char *name = &rules->buf[cur->key.attr_off];
+                       char *value = &rules->buf[cur->key.value_off];
+
+                       if (value[0] != '\0') {
+                               char temp_value[UTIL_NAME_SIZE];
+                               struct udev_list_entry *entry;
+
+                               udev_event_apply_format(event, value, temp_value, sizeof(temp_value));
+                               entry = udev_device_add_property(event->dev, name, temp_value);
+                               /* store in db, skip private keys */
+                               if (name[0] != '.')
+                                       udev_list_entry_set_num(entry, true);
+                       } else {
+                               udev_device_add_property(event->dev, name, NULL);
                        }
-               case TK_A_NAME:
-                       {
-                               const char *name  = &rules->buf[cur->key.value_off];
-                               char name_str[UTIL_PATH_SIZE];
-                               int count;
+                       break;
+               }
+               case TK_A_TAG: {
+                       char tag[UTIL_PATH_SIZE];
 
-                               if (event->name_final)
-                                       break;
-                               if (cur->key.op == OP_ASSIGN_FINAL)
-                                       event->name_final = 1;
-                               udev_event_apply_format(event, name, name_str, sizeof(name_str));
-                               if (esc == ESCAPE_UNSET || esc == ESCAPE_REPLACE) {
-                                       count = udev_util_replace_chars(name_str, "/");
-                                       if (count > 0)
-                                               info(event->udev, "%i character(s) replaced\n", count);
-                               }
-                               free(event->name);
-                               event->name = strdup(name_str);
-                               info(event->udev, "NAME '%s' %s:%u\n",
-                                    event->name,
-                                    &rules->buf[rule->rule.filename_off],
-                                    rule->rule.filename_line);
+                       udev_event_apply_format(event, &rules->buf[cur->key.value_off], tag, sizeof(tag));
+                       if (cur->key.op == OP_ASSIGN || cur->key.op == OP_ASSIGN_FINAL)
+                               udev_device_cleanup_tags_list(event->dev);
+                       udev_device_add_tag(event->dev, tag);
+                       break;
+               }
+               case TK_A_NAME: {
+                       const char *name  = &rules->buf[cur->key.value_off];
+                       char name_str[UTIL_PATH_SIZE];
+                       int count;
+
+                       if (event->name_final)
                                break;
-                       }
-               case TK_A_DEVLINK:
-                       {
-                               char temp[UTIL_PATH_SIZE];
-                               char filename[UTIL_PATH_SIZE];
-                               char *pos, *next;
-                               int count = 0;
-
-                               if (event->devlink_final)
-                                       break;
-                               if (major(udev_device_get_devnum(event->dev)) == 0)
-                                       break;
-                               if (cur->key.op == OP_ASSIGN_FINAL)
-                                       event->devlink_final = 1;
-                               if (cur->key.op == OP_ASSIGN || cur->key.op == OP_ASSIGN_FINAL)
-                                       udev_device_cleanup_devlinks_list(event->dev);
-
-                               /* allow  multiple symlinks separated by spaces */
-                               udev_event_apply_format(event, &rules->buf[cur->key.value_off], temp, sizeof(temp));
-                               if (esc == ESCAPE_UNSET)
-                                       count = udev_util_replace_chars(temp, "/ ");
-                               else if (esc == ESCAPE_REPLACE)
-                                       count = udev_util_replace_chars(temp, "/");
+                       if (cur->key.op == OP_ASSIGN_FINAL)
+                               event->name_final = true;
+                       udev_event_apply_format(event, name, name_str, sizeof(name_str));
+                       if (esc == ESCAPE_UNSET || esc == ESCAPE_REPLACE) {
+                               count = udev_util_replace_chars(name_str, "/");
                                if (count > 0)
-                                       info(event->udev, "%i character(s) replaced\n" , count);
-                               dbg(event->udev, "rule applied, added symlink(s) '%s'\n", temp);
-                               pos = temp;
-                               while (isspace(pos[0]))
-                                       pos++;
-                               next = strchr(pos, ' ');
-                               while (next) {
-                                       next[0] = '\0';
-                                       info(event->udev, "LINK '%s' %s:%u\n",
-                                            pos,
-                                            &rules->buf[rule->rule.filename_off],
-                                            rule->rule.filename_line);
-                                       util_strscpyl(filename, sizeof(filename), udev_get_dev_path(event->udev), "/", pos, NULL);
-                                       udev_device_add_devlink(event->dev, filename);
-                                       while (isspace(next[1]))
-                                               next++;
-                                       pos = &next[1];
-                                       next = strchr(pos, ' ');
-                               }
-                               if (pos[0] != '\0') {
-                                       info(event->udev, "LINK '%s' %s:%u\n",
-                                            pos,
-                                            &rules->buf[rule->rule.filename_off],
-                                            rule->rule.filename_line);
-                                       util_strscpyl(filename, sizeof(filename), udev_get_dev_path(event->udev), "/", pos, NULL);
-                                       udev_device_add_devlink(event->dev, filename);
-                               }
+                                       info(event->udev, "%i character(s) replaced\n", count);
                        }
+                       free(event->name);
+                       event->name = strdup(name_str);
+                       info(event->udev, "NAME '%s' %s:%u\n",
+                            event->name,
+                            &rules->buf[rule->rule.filename_off],
+                            rule->rule.filename_line);
                        break;
-               case TK_A_EVENT_TIMEOUT:
-                       udev_device_set_event_timeout(event->dev, cur->key.event_timeout);
-                       break;
-               case TK_A_IGNORE_REMOVE:
-                       udev_device_set_ignore_remove(event->dev, 1);
-                       break;
-               case TK_A_ATTR:
-                       {
-                               const char *key_name = &rules->buf[cur->key.attr_off];
-                               char attr[UTIL_PATH_SIZE];
-                               char value[UTIL_NAME_SIZE];
-                               FILE *f;
-
-                               if (util_resolve_subsys_kernel(event->udev, key_name, attr, sizeof(attr), 0) != 0)
-                                       util_strscpyl(attr, sizeof(attr), udev_device_get_syspath(event->dev), "/", key_name, NULL);
-                               attr_subst_subdir(attr, sizeof(attr));
-
-                               udev_event_apply_format(event, &rules->buf[cur->key.value_off], value, sizeof(value));
-                               info(event->udev, "ATTR '%s' writing '%s' %s:%u\n", attr, value,
-                                    &rules->buf[rule->rule.filename_off],
-                                    rule->rule.filename_line);
-                               f = fopen(attr, "w");
-                               if (f != NULL) {
-                                       if (fprintf(f, "%s", value) <= 0)
-                                               err(event->udev, "error writing ATTR{%s}: %m\n", attr);
-                                       fclose(f);
-                               } else {
-                                       err(event->udev, "error opening ATTR{%s} for writing: %m\n", attr);
-                               }
+               }
+               case TK_A_DEVLINK: {
+                       char temp[UTIL_PATH_SIZE];
+                       char filename[UTIL_PATH_SIZE];
+                       char *pos, *next;
+                       int count = 0;
+
+                       if (event->devlink_final)
                                break;
-                       }
-               case TK_A_RUN:
-                       {
-                               struct udev_list_entry *list_entry;
-
-                               if (cur->key.op == OP_ASSIGN || cur->key.op == OP_ASSIGN_FINAL)
-                                       udev_list_cleanup_entries(event->udev, &event->run_list);
-                               info(event->udev, "RUN '%s' %s:%u\n",
-                                    &rules->buf[cur->key.value_off],
-                                    &rules->buf[rule->rule.filename_off],
-                                    rule->rule.filename_line);
-                               list_entry = udev_list_entry_add(event->udev, &event->run_list,
-                                                                &rules->buf[cur->key.value_off], NULL, 1, 0);
-                               if (cur->key.ignore_error)
-                                       udev_list_entry_set_flag(list_entry, 1);
+                       if (major(udev_device_get_devnum(event->dev)) == 0)
                                break;
+                       if (cur->key.op == OP_ASSIGN_FINAL)
+                               event->devlink_final = true;
+                       if (cur->key.op == OP_ASSIGN || cur->key.op == OP_ASSIGN_FINAL)
+                               udev_device_cleanup_devlinks_list(event->dev);
+
+                       /* allow  multiple symlinks separated by spaces */
+                       udev_event_apply_format(event, &rules->buf[cur->key.value_off], temp, sizeof(temp));
+                       if (esc == ESCAPE_UNSET)
+                               count = udev_util_replace_chars(temp, "/ ");
+                       else if (esc == ESCAPE_REPLACE)
+                               count = udev_util_replace_chars(temp, "/");
+                       if (count > 0)
+                               info(event->udev, "%i character(s) replaced\n" , count);
+                       dbg(event->udev, "rule applied, added symlink(s) '%s'\n", temp);
+                       pos = temp;
+                       while (isspace(pos[0]))
+                               pos++;
+                       next = strchr(pos, ' ');
+                       while (next != NULL) {
+                               next[0] = '\0';
+                               info(event->udev, "LINK '%s' %s:%u\n", pos,
+                                    &rules->buf[rule->rule.filename_off], rule->rule.filename_line);
+                               util_strscpyl(filename, sizeof(filename), udev_get_dev_path(event->udev), "/", pos, NULL);
+                               udev_device_add_devlink(event->dev, filename, cur->key.devlink_unique);
+                               while (isspace(next[1]))
+                                       next++;
+                               pos = &next[1];
+                               next = strchr(pos, ' ');
+                       }
+                       if (pos[0] != '\0') {
+                               info(event->udev, "LINK '%s' %s:%u\n", pos,
+                                    &rules->buf[rule->rule.filename_off], rule->rule.filename_line);
+                               util_strscpyl(filename, sizeof(filename), udev_get_dev_path(event->udev), "/", pos, NULL);
+                               udev_device_add_devlink(event->dev, filename, cur->key.devlink_unique);
                        }
+                       break;
+               }
+               case TK_A_ATTR: {
+                       const char *key_name = &rules->buf[cur->key.attr_off];
+                       char attr[UTIL_PATH_SIZE];
+                       char value[UTIL_NAME_SIZE];
+                       FILE *f;
+
+                       if (util_resolve_subsys_kernel(event->udev, key_name, attr, sizeof(attr), 0) != 0)
+                               util_strscpyl(attr, sizeof(attr), udev_device_get_syspath(event->dev), "/", key_name, NULL);
+                       attr_subst_subdir(attr, sizeof(attr));
+
+                       udev_event_apply_format(event, &rules->buf[cur->key.value_off], value, sizeof(value));
+                       info(event->udev, "ATTR '%s' writing '%s' %s:%u\n", attr, value,
+                            &rules->buf[rule->rule.filename_off],
+                            rule->rule.filename_line);
+                       f = fopen(attr, "w");
+                       if (f != NULL) {
+                               if (fprintf(f, "%s", value) <= 0)
+                                       err(event->udev, "error writing ATTR{%s}: %m\n", attr);
+                               fclose(f);
+                       } else {
+                               err(event->udev, "error opening ATTR{%s} for writing: %m\n", attr);
+                       }
+                       break;
+               }
+               case TK_A_RUN: {
+                       struct udev_list_entry *list_entry;
+
+                       if (cur->key.op == OP_ASSIGN || cur->key.op == OP_ASSIGN_FINAL)
+                               udev_list_cleanup_entries(event->udev, &event->run_list);
+                       info(event->udev, "RUN '%s' %s:%u\n",
+                            &rules->buf[cur->key.value_off],
+                            &rules->buf[rule->rule.filename_off],
+                            rule->rule.filename_line);
+                       list_entry = udev_list_entry_add(event->udev, &event->run_list,
+                                                        &rules->buf[cur->key.value_off], NULL, UDEV_LIST_UNIQUE);
+                       if (cur->key.fail_on_error)
+                               udev_list_entry_set_num(list_entry, true);
+                       break;
+               }
                case TK_A_GOTO:
                        if (cur->key.rule_goto == 0)
                                break;
                        cur = &rules->tokens[cur->key.rule_goto];
                        continue;
-               case TK_A_LAST_RULE:
                case TK_END:
                        return 0;
 
@@ -2485,3 +2669,75 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                                 (unsigned int) (cur - rules->tokens));
        }
 }
+
+void udev_rules_apply_static_dev_perms(struct udev_rules *rules)
+{
+       struct token *cur;
+       struct token *rule;
+       uid_t uid = 0;
+       gid_t gid = 0;
+       mode_t mode = 0;
+
+       if (rules->tokens == NULL)
+               return;
+
+       cur = &rules->tokens[0];
+       rule = cur;
+       for (;;) {
+               switch (cur->type) {
+               case TK_RULE:
+                       /* current rule */
+                       rule = cur;
+
+                       /* skip rules without a static_node tag */
+                       if (!rule->rule.has_static_node)
+                               goto next;
+
+                       uid = 0;
+                       gid = 0;
+                       mode = 0;
+                       break;
+               case TK_A_OWNER_ID:
+                       uid = cur->key.uid;
+                       break;
+               case TK_A_GROUP_ID:
+                       gid = cur->key.gid;
+                       break;
+               case TK_A_MODE_ID:
+                       mode = cur->key.mode;
+                       break;
+               case TK_A_STATIC_NODE: {
+                       char filename[UTIL_PATH_SIZE];
+                       struct stat stats;
+                       /* we assure, that the permissions tokens are sorted before the static token */
+                       if (mode == 0 && uid == 0 && gid == 0)
+                               goto next;
+                       util_strscpyl(filename, sizeof(filename), udev_get_dev_path(rules->udev), "/",
+                                     &rules->buf[cur->key.value_off], NULL);
+                       if (stat(filename, &stats) != 0)
+                               goto next;
+                       if (!S_ISBLK(stats.st_mode) && !S_ISCHR(stats.st_mode))
+                               goto next;
+                       if (mode != 0 && mode != (stats.st_mode & 0777)) {
+                               chmod(filename, mode);
+                               info(rules->udev, "chmod '%s' %#o\n", filename, mode);
+                       }
+                       if ((uid != 0 && uid != stats.st_uid) || (gid != 0 && gid != stats.st_gid)) {
+                               chown(filename, uid, gid);
+                               info(rules->udev, "chown '%s' %u %u\n", filename, uid, gid);
+                       }
+                       utimensat(AT_FDCWD, filename, NULL, 0);
+                       break;
+               }
+               case TK_END:
+                       return;
+               }
+
+               cur++;
+               continue;
+next:
+               /* fast-forward to next rule */
+               cur = rule + rule->rule.token_count;
+               continue;
+       }
+}