udevd: avoid implicit memset in match_attr()

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

diff --git a/udev/udev-rules.c b/udev/udev-rules.c
index 0643811d7a458809bf6d5e517f0f55dd4d8f886d..44b26906b48465d8cfe3de3583d14933f8c59223 100644 (file)
--- a/udev/udev-rules.c
+++ b/udev/udev-rules.c
@@ -1726,21 +1726,26 @@ static int match_key(struct udev_rules *rules, struct token *token, const char *
                break;
        case GL_SPLIT:
                {
-                       char value[UTIL_PATH_SIZE];
+                       const char *split;
+                       size_t len;
 
-                       util_strlcpy(value, &rules->buf[token->key.value_off], sizeof(value));
-                       key_value = value;
-                       while (key_value != NULL) {
-                               pos = strchr(key_value, '|');
-                               if (pos != NULL) {
-                                       pos[0] = '\0';
-                                       pos = &pos[1];
-                               }
-                               dbg(rules->udev, "match %s '%s' <-> '%s'\n", token_str[token->type], key_value, val);
-                               match = (strcmp(key_value, val) == 0);
-                               if (match)
+                       split = &rules->buf[token->key.value_off];
+                       len = strlen(val);
+                       while (1) {
+                               const char *next;
+
+                               next = strchr(split, '|');
+                               if (next != NULL) {
+                                       size_t matchlen = (size_t)(next - split);
+
+                                       match = (matchlen == len && strncmp(split, val, matchlen) == 0);
+                                       if (match)
+                                               break;
+                               } else {
+                                       match = (strcmp(split, val) == 0);
                                        break;
-                               key_value = pos;
+                               }
+                               split = &next[1];
                        }
                        break;
                }
@@ -1789,10 +1794,11 @@ static int match_attr(struct udev_rules *rules, struct udev_device *dev, struct
        char attr[UTIL_PATH_SIZE];
        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] = "";
+       char value[UTIL_NAME_SIZE];
        size_t len;
 
        util_strlcpy(attr, key_name, sizeof(attr));
+       util_strlcpy(value, "", sizeof(value));
        util_resolve_subsys_kernel(event->udev, attr, value, sizeof(value), 1);
        if (value[0] == '\0') {
                const char *val;
@@ -1825,6 +1831,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 {
        struct token *cur;
        struct token *rule;
+       enum escape_type esc = ESCAPE_UNSET;
 
        if (rules->tokens == NULL)
                return -1;
@@ -1833,7 +1840,6 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
        cur = &rules->tokens[0];
        rule = cur;
        while (cur != NULL && cur->type != TK_END) {
-               enum escape_type esc = ESCAPE_UNSET;
                unsigned int idx;
 
                dump_token(rules, cur);