allow final assignment for OPTIONS:="nowatch"

[elogind.git] / udev / udev-rules.c

diff --git a/udev/udev-rules.c b/udev/udev-rules.c
index 5dcd760c55956447bce490810cf377e05d9020a9..6d32e7301702bd19083b6f7db5a665c04c0514e5 100644 (file)
--- a/udev/udev-rules.c
+++ b/udev/udev-rules.c
@@ -143,6 +143,7 @@ enum token_type {
        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,
@@ -276,6 +277,7 @@ static const char *token_str(enum token_type type)
                [TK_M_IMPORT_FILE] =            "M IMPORT_FILE",
                [TK_M_IMPORT_PROG] =            "M IMPORT_PROG",
                [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",
@@ -321,11 +323,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:
@@ -343,6 +344,7 @@ static void dump_token(struct udev_rules *rules, struct token *token)
        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:
@@ -895,7 +897,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;
@@ -1011,6 +1013,7 @@ static int rule_add_key(struct rule_tmp *rule_tmp, enum token_type type,
        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:
@@ -1181,7 +1184,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;
@@ -1403,6 +1406,9 @@ static int add_rule(struct udev_rules *rules, char *line,
                        } 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);
@@ -1563,42 +1569,42 @@ static int add_rule(struct udev_rules *rules, char *line,
                        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);
+                               rule_add_key(&rule_tmp, TK_A_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);
                        }
                        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, 0, &pos[strlen("static_node=")], 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;
@@ -1708,7 +1714,7 @@ static int add_matching_files(struct udev *udev, struct udev_list_node *file_lis
                return -1;
        }
 
-       while (1) {
+       for (;;) {
                struct dirent *dent;
 
                dent = readdir(dir);
@@ -1941,7 +1947,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, '|');
@@ -2183,7 +2189,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 
                                /* loop over parents */
                                event->dev_parent = event->dev;
-                               while (1) {
+                               for (;;) {
                                        struct token *key;
 
                                        dbg(event->udev, "parent: '%s'\n", udev_device_get_syspath(event->dev_parent));
@@ -2330,6 +2336,49 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                                }
                                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_flags(entry, 1);
+                                                               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_flags(entry, 1);
+                                                               imported = true;
+                                                       }
+                                               }
+                                       }
+                                       fclose(f);
+                               }
+                               if (!imported && cur->key.op != OP_NOMATCH)
+                                       goto nomatch;
+                               break;
+                       }
                case TK_M_IMPORT_PARENT:
                        {
                                char import[UTIL_PATH_SIZE];
@@ -2351,6 +2400,10 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                        esc = ESCAPE_REPLACE;
                        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: