udev-rules: replace udev_device by sd_device in udev_rules_apply_to_event()

1 files changed, 83 insertions, 73 deletions

diff --git a/src/udev/udev-rules.c b/src/udev/udev-rules.c
index a5ead0930b..11104d62d0 100644
--- a/src/udev/udev-rules.c
+++ b/src/udev/udev-rules.c
@@ -1727,18 +1727,23 @@ int udev_rules_apply_to_event(
                 usec_t timeout_usec,
                 usec_t timeout_warn_usec,
                 Hashmap *properties_list) {
-        struct token *cur;
-        struct token *rule;
+        sd_device *dev = event->dev->device;
         enum escape_type esc = ESCAPE_UNSET;
+        struct token *cur, *rule;
+        const char *action, *val;
         bool can_set_name;
         int r;
 
         if (!rules->tokens)
                 return 0;
 
-        can_set_name = ((!streq(udev_device_get_action(event->dev), "remove")) &&
-                        (major(udev_device_get_devnum(event->dev)) > 0 ||
-                         udev_device_get_ifindex(event->dev) > 0));
+        r = sd_device_get_property_value(dev, "ACTION", &action);
+        if (r < 0)
+                return r;
+
+        can_set_name = (!streq(action, "remove") &&
+                        (sd_device_get_devnum(dev, NULL) >= 0 ||
+                         sd_device_get_ifindex(dev, NULL) >= 0));
 
         /* loop through token list, match, run actions or forward to next rule */
         cur = &rules->tokens[0];
@@ -1755,22 +1760,26 @@ int udev_rules_apply_to_event(
                         esc = ESCAPE_UNSET;
                         break;
                 case TK_M_ACTION:
-                        if (match_key(rules, cur, udev_device_get_action(event->dev)) != 0)
+                        if (match_key(rules, cur, action) != 0)
                                 goto nomatch;
                         break;
                 case TK_M_DEVPATH:
-                        if (match_key(rules, cur, udev_device_get_devpath(event->dev)) != 0)
+                        if (sd_device_get_devpath(dev, &val) < 0)
+                                goto nomatch;
+                        if (match_key(rules, cur, val) != 0)
                                 goto nomatch;
                         break;
                 case TK_M_KERNEL:
-                        if (match_key(rules, cur, udev_device_get_sysname(event->dev)) != 0)
+                        if (sd_device_get_sysname(dev, &val) < 0)
+                                goto nomatch;
+                        if (match_key(rules, cur, val) != 0)
                                 goto nomatch;
                         break;
                 case TK_M_DEVLINK: {
                         const char *devlink;
                         bool match = false;
 
-                        FOREACH_DEVICE_DEVLINK(event->dev->device, devlink)
+                        FOREACH_DEVICE_DEVLINK(dev, devlink)
                                 if (match_key(rules, cur, devlink + STRLEN("/dev/")) == 0) {
                                         match = true;
                                         break;
@@ -1786,15 +1795,16 @@ int udev_rules_apply_to_event(
                         break;
                 case TK_M_ENV: {
                         const char *key_name = rules_str(rules, cur->key.attr_off);
-                        const char *value;
-
-                        value = udev_device_get_property_value(event->dev, key_name);
 
-                        /* check global properties */
-                        if (!value && properties_list)
-                                value = hashmap_get(properties_list, key_name);
+                        if (sd_device_get_property_value(dev, key_name, &val) < 0) {
+                                /* check global properties */
+                                if (properties_list)
+                                        val = hashmap_get(properties_list, key_name);
+                                else
+                                        val = NULL;
+                        }
 
-                        if (match_key(rules, cur, strempty(value)))
+                        if (match_key(rules, cur, strempty(val)))
                                 goto nomatch;
                         break;
                 }
@@ -1802,7 +1812,7 @@ int udev_rules_apply_to_event(
                         bool match = false;
                         const char *tag;
 
-                        FOREACH_DEVICE_TAG(event->dev->device, tag)
+                        FOREACH_DEVICE_TAG(dev, tag)
                                 if (streq(rules_str(rules, cur->key.value_off), tag)) {
                                         match = true;
                                         break;
@@ -1814,15 +1824,19 @@ int udev_rules_apply_to_event(
                         break;
                 }
                 case TK_M_SUBSYSTEM:
-                        if (match_key(rules, cur, udev_device_get_subsystem(event->dev)) != 0)
+                        if (sd_device_get_subsystem(dev, &val) < 0)
+                                goto nomatch;
+                        if (match_key(rules, cur, val) != 0)
                                 goto nomatch;
                         break;
                 case TK_M_DRIVER:
-                        if (match_key(rules, cur, udev_device_get_driver(event->dev)) != 0)
+                        if (sd_device_get_driver(dev, &val) < 0)
+                                goto nomatch;
+                        if (match_key(rules, cur, val) != 0)
                                 goto nomatch;
                         break;
                 case TK_M_ATTR:
-                        if (match_attr(rules, event->dev->device, event, cur) != 0)
+                        if (match_attr(rules, dev, event, cur) != 0)
                                 goto nomatch;
                         break;
                 case TK_M_SYSCTL: {
@@ -1855,10 +1869,9 @@ int udev_rules_apply_to_event(
                                 next++;
 
                         /* loop over parents */
-                        event->dev_parent = event->dev->device;
+                        event->dev_parent = dev;
                         for (;;) {
                                 struct token *key;
-                                const char *val;
 
                                 /* loop over sequence of parent match keys */
                                 for (key = cur; key < next; key++ ) {
@@ -1921,9 +1934,11 @@ int udev_rules_apply_to_event(
                                 if (filename[0] != '/') {
                                         char tmp[UTIL_PATH_SIZE];
 
+                                        if (sd_device_get_syspath(dev, &val) < 0)
+                                                goto nomatch;
+
                                         strscpy(tmp, sizeof(tmp), filename);
-                                        strscpyl(filename, sizeof(filename),
-                                                      udev_device_get_syspath(event->dev), "/", tmp, NULL);
+                                        strscpyl(filename, sizeof(filename), val, "/", tmp, NULL);
                                 }
                         }
                         attr_subst_subdir(filename, sizeof(filename));
@@ -1938,8 +1953,7 @@ int udev_rules_apply_to_event(
                         break;
                 }
                 case TK_M_PROGRAM: {
-                        char program[UTIL_PATH_SIZE];
-                        char result[UTIL_LINE_SIZE];
+                        char program[UTIL_PATH_SIZE], result[UTIL_LINE_SIZE];
 
                         event->program_result = mfree(event->program_result);
                         udev_event_apply_format(event, rules_str(rules, cur->key.value_off), program, sizeof(program), false);
@@ -1970,7 +1984,7 @@ int udev_rules_apply_to_event(
                         char import[UTIL_PATH_SIZE];
 
                         udev_event_apply_format(event, rules_str(rules, cur->key.value_off), import, sizeof(import), false);
-                        if (import_file_into_properties(event->dev->device, import) != 0)
+                        if (import_file_into_properties(dev, import) != 0)
                                 if (cur->key.op != OP_NOMATCH)
                                         goto nomatch;
                         break;
@@ -2015,7 +2029,7 @@ int udev_rules_apply_to_event(
                                   rules_str(rules, rule->rule.filename_off),
                                   rule->rule.filename_line);
 
-                        r = udev_builtin_run(event->dev->device, cur->key.builtin_cmd, command, false);
+                        r = udev_builtin_run(dev, cur->key.builtin_cmd, command, false);
                         if (r < 0) {
                                 /* remember failure */
                                 log_debug_errno(r, "IMPORT builtin '%s' fails: %m",
@@ -2027,11 +2041,11 @@ int udev_rules_apply_to_event(
                         break;
                 }
                 case TK_M_IMPORT_DB: {
-                        const char *key = rules_str(rules, cur->key.value_off);
-                        const char *value;
+                        const char *key;
 
-                        if (sd_device_get_property_value(event->dev_db_clone, key, &value) >= 0)
-                                udev_device_add_property(event->dev, key, value);
+                        key = rules_str(rules, cur->key.value_off);
+                        if (sd_device_get_property_value(event->dev_db_clone, key, &val) >= 0)
+                                device_add_property(dev, key, val);
                         else if (cur->key.op != OP_NOMATCH)
                                 goto nomatch;
                         break;
@@ -2042,7 +2056,6 @@ int udev_rules_apply_to_event(
                         const char *key;
 
                         key = rules_str(rules, cur->key.value_off);
-
                         r = proc_cmdline_get_key(key, PROC_CMDLINE_VALUE_OPTIONAL, &value);
                         if (r < 0)
                                 log_debug_errno(r, "Failed to read %s from /proc/cmdline, ignoring: %m", key);
@@ -2050,10 +2063,10 @@ int udev_rules_apply_to_event(
                                 imported = true;
 
                                 if (value)
-                                        udev_device_add_property(event->dev, key, value);
+                                        device_add_property(dev, key, value);
                                 else
                                         /* we import simple flags as 'FLAG=1' */
-                                        udev_device_add_property(event->dev, key, "1");
+                                        device_add_property(dev, key, "1");
                         }
 
                         if (!imported && cur->key.op != OP_NOMATCH)
@@ -2064,7 +2077,7 @@ int udev_rules_apply_to_event(
                         char import[UTIL_PATH_SIZE];
 
                         udev_event_apply_format(event, rules_str(rules, cur->key.value_off), import, sizeof(import), false);
-                        if (import_parent_into_properties(event->dev->device, import) != 0)
+                        if (import_parent_into_properties(dev, import) != 0)
                                 if (cur->key.op != OP_NOMATCH)
                                         goto nomatch;
                         break;
@@ -2080,7 +2093,7 @@ int udev_rules_apply_to_event(
                         esc = ESCAPE_REPLACE;
                         break;
                 case TK_A_DB_PERSIST:
-                        udev_device_set_db_persist(event->dev);
+                        device_set_db_persist(dev);
                         break;
                 case TK_A_INOTIFY_WATCH:
                         if (event->inotify_watch_final)
@@ -2090,7 +2103,7 @@ int udev_rules_apply_to_event(
                         event->inotify_watch = cur->key.watch;
                         break;
                 case TK_A_DEVLINK_PRIO:
-                        udev_device_set_devlink_priority(event->dev, cur->key.devlink_prio);
+                        device_set_devlink_priority(dev, cur->key.devlink_prio);
                         break;
                 case TK_A_OWNER: {
                         char owner[UTIL_NAME_SIZE];
@@ -2135,9 +2148,8 @@ int udev_rules_apply_to_event(
                         break;
                 }
                 case TK_A_MODE: {
-                        char mode_str[UTIL_NAME_SIZE];
+                        char mode_str[UTIL_NAME_SIZE], *endptr;
                         mode_t mode;
-                        char *endptr;
 
                         if (event->mode_final)
                                 break;
@@ -2229,30 +2241,29 @@ int udev_rules_apply_to_event(
                         break;
                 }
                 case TK_A_ENV: {
-                        const char *name = rules_str(rules, cur->key.attr_off);
-                        char *value = rules_str(rules, cur->key.value_off);
                         char value_new[UTIL_NAME_SIZE];
-                        const char *value_old = NULL;
+                        const char *name, *value_old;
 
-                        if (value[0] == '\0') {
+                        name = rules_str(rules, cur->key.attr_off);
+                        val = rules_str(rules, cur->key.value_off);
+                        if (val[0] == '\0') {
                                 if (cur->key.op == OP_ADD)
                                         break;
-                                udev_device_add_property(event->dev, name, NULL);
+                                device_add_property(dev, name, NULL);
                                 break;
                         }
 
-                        if (cur->key.op == OP_ADD)
-                                value_old = udev_device_get_property_value(event->dev, name);
-                        if (value_old) {
+                        if (cur->key.op == OP_ADD &&
+                            sd_device_get_property_value(dev, name, &value_old) >= 0) {
                                 char temp[UTIL_NAME_SIZE];
 
                                 /* append value separated by space */
-                                udev_event_apply_format(event, value, temp, sizeof(temp), false);
+                                udev_event_apply_format(event, val, temp, sizeof(temp), false);
                                 strscpyl(value_new, sizeof(value_new), value_old, " ", temp, NULL);
                         } else
-                                udev_event_apply_format(event, value, value_new, sizeof(value_new), false);
+                                udev_event_apply_format(event, val, value_new, sizeof(value_new), false);
 
-                        udev_device_add_property(event->dev, name, value_new);
+                        device_add_property(dev, name, value_new);
                         break;
                 }
                 case TK_A_TAG: {
@@ -2261,7 +2272,7 @@ int udev_rules_apply_to_event(
 
                         udev_event_apply_format(event, rules_str(rules, cur->key.value_off), tag, sizeof(tag), false);
                         if (IN_SET(cur->key.op, OP_ASSIGN, OP_ASSIGN_FINAL))
-                                udev_device_cleanup_tags_list(event->dev);
+                                device_cleanup_tags(dev);
                         for (p = tag; *p != '\0'; p++) {
                                 if ((*p >= 'a' && *p <= 'z') ||
                                     (*p >= 'A' && *p <= 'Z') ||
@@ -2272,17 +2283,17 @@ int udev_rules_apply_to_event(
                                 break;
                         }
                         if (cur->key.op == OP_REMOVE)
-                                udev_device_remove_tag(event->dev, tag);
+                                device_remove_tag(dev, tag);
                         else
-                                udev_device_add_tag(event->dev, tag);
+                                device_add_tag(dev, tag);
                         break;
                 }
                 case TK_A_NAME: {
-                        const char *name  = rules_str(rules, cur->key.value_off);
-
                         char name_str[UTIL_PATH_SIZE];
+                        const char *name;
                         int count;
 
+                        name = rules_str(rules, cur->key.value_off);
                         if (event->name_final)
                                 break;
                         if (cur->key.op == OP_ASSIGN_FINAL)
@@ -2293,8 +2304,9 @@ int udev_rules_apply_to_event(
                                 if (count > 0)
                                         log_debug("%i character(s) replaced", count);
                         }
-                        if (major(udev_device_get_devnum(event->dev)) &&
-                            !streq(name_str, udev_device_get_devnode(event->dev) + STRLEN("/dev/"))) {
+                        if (sd_device_get_devnum(dev, NULL) >= 0 &&
+                            (sd_device_get_devname(dev, &val) < 0 ||
+                             !streq(name_str, val + STRLEN("/dev/")))) {
                                 log_error("NAME=\"%s\" ignored, kernel device nodes cannot be renamed; please fix it in %s:%u\n",
                                           name,
                                           rules_str(rules, rule->rule.filename_off),
@@ -2311,19 +2323,17 @@ int udev_rules_apply_to_event(
                         break;
                 }
                 case TK_A_DEVLINK: {
-                        char temp[UTIL_PATH_SIZE];
-                        char filename[UTIL_PATH_SIZE];
-                        char *pos, *next;
+                        char temp[UTIL_PATH_SIZE], filename[UTIL_PATH_SIZE], *pos, *next;
                         int count = 0;
 
                         if (event->devlink_final)
                                 break;
-                        if (major(udev_device_get_devnum(event->dev)) == 0)
+                        if (sd_device_get_devnum(dev, NULL) < 0)
                                 break;
                         if (cur->key.op == OP_ASSIGN_FINAL)
                                 event->devlink_final = true;
                         if (IN_SET(cur->key.op, OP_ASSIGN, OP_ASSIGN_FINAL))
-                                udev_device_cleanup_devlinks_list(event->dev);
+                                device_cleanup_devlinks(dev);
 
                         /* allow  multiple symlinks separated by spaces */
                         udev_event_apply_format(event, rules_str(rules, cur->key.value_off), temp, sizeof(temp), esc != ESCAPE_NONE);
@@ -2337,12 +2347,12 @@ int udev_rules_apply_to_event(
                         while (isspace(pos[0]))
                                 pos++;
                         next = strchr(pos, ' ');
-                        while (next != NULL) {
+                        while (next) {
                                 next[0] = '\0';
                                 log_debug("LINK '%s' %s:%u", pos,
                                           rules_str(rules, rule->rule.filename_off), rule->rule.filename_line);
                                 strscpyl(filename, sizeof(filename), "/dev/", pos, NULL);
-                                udev_device_add_devlink(event->dev, filename);
+                                device_add_devlink(dev, filename);
                                 while (isspace(next[1]))
                                         next++;
                                 pos = &next[1];
@@ -2352,18 +2362,19 @@ int udev_rules_apply_to_event(
                                 log_debug("LINK '%s' %s:%u", pos,
                                           rules_str(rules, rule->rule.filename_off), rule->rule.filename_line);
                                 strscpyl(filename, sizeof(filename), "/dev/", pos, NULL);
-                                udev_device_add_devlink(event->dev, filename);
+                                device_add_devlink(dev, filename);
                         }
                         break;
                 }
                 case TK_A_ATTR: {
-                        const char *key_name = rules_str(rules, cur->key.attr_off);
-                        char attr[UTIL_PATH_SIZE];
-                        char value[UTIL_NAME_SIZE];
+                        char attr[UTIL_PATH_SIZE], value[UTIL_NAME_SIZE];
                         _cleanup_fclose_ FILE *f = NULL;
+                        const char *key_name;
 
-                        if (util_resolve_subsys_kernel(key_name, attr, sizeof(attr), 0) != 0)
-                                strscpyl(attr, sizeof(attr), udev_device_get_syspath(event->dev), "/", key_name, NULL);
+                        key_name = rules_str(rules, cur->key.attr_off);
+                        if (util_resolve_subsys_kernel(key_name, attr, sizeof(attr), 0) != 0 &&
+                            sd_device_get_syspath(dev, &val) >= 0)
+                                strscpyl(attr, sizeof(attr), val, "/", key_name, NULL);
                         attr_subst_subdir(attr, sizeof(attr));
 
                         udev_event_apply_format(event, rules_str(rules, cur->key.value_off), value, sizeof(value), false);
@@ -2378,8 +2389,7 @@ int udev_rules_apply_to_event(
                         break;
                 }
                 case TK_A_SYSCTL: {
-                        char filename[UTIL_PATH_SIZE];
-                        char value[UTIL_NAME_SIZE];
+                        char filename[UTIL_PATH_SIZE], value[UTIL_NAME_SIZE];
 
                         udev_event_apply_format(event, rules_str(rules, cur->key.attr_off), filename, sizeof(filename), false);
                         sysctl_normalize(filename);