udevd: use facility == LOG_DAEMON when writing to /dev/kmsg

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

diff --git a/udev/udev-rules.c b/udev/udev-rules.c
index 230916a92e2ed6b20ea2629c01a7687fafe4694e..4a5b8debcab444af52f1ed15f7eed5427c7bc798 100644 (file)
--- a/udev/udev-rules.c
+++ b/udev/udev-rules.c
@@ -751,7 +751,7 @@ static int import_program_into_properties(struct udev_device *dev, const char *p
 {
        struct udev *udev = udev_device_get_udev(dev);
        char **envp;
-       char result[4096];
+       char result[UTIL_LINE_SIZE];
        size_t reslen;
        char *line;
 
@@ -1569,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;
@@ -1751,23 +1751,27 @@ struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names)
        struct udev_list_entry *file_loop, *file_tmp;
        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';
@@ -1776,8 +1780,12 @@ 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));
@@ -1795,7 +1803,7 @@ struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names)
                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);
+               util_strscpyl(filename, sizeof(filename), udev_get_dev_path(udev), "/.run/udev/rules.d", NULL);
                udev_list_init(&sort_list);
                add_matching_files(udev, &sort_list, filename, ".rules");
 
@@ -2072,7 +2080,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 
        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];
@@ -2400,6 +2408,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: