HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/udev/udev-rules.c

146,142 bytesGit mode 100644Download original fileGPL-2.0-or-later

Git blob: c7443a98981e096d10358ad4f663909ffd0ee64a

Lines 2001–3000 of 3,362

                        break;
                case MATCH_TYPE_PLAIN_WITH_EMPTY:
                case MATCH_TYPE_PLAIN:
                case MATCH_TYPE_GLOB_WITH_EMPTY:
                case MATCH_TYPE_GLOB: {
                        _cleanup_free_ char *joined = NULL;
                        unsigned c = 0;
 
                        if (IN_SET(token->match_type & _MATCH_TYPE_MASK, MATCH_TYPE_PLAIN_WITH_EMPTY, MATCH_TYPE_GLOB_WITH_EMPTY)) {
                                (void) strextend_with_separator(&joined, ", ", "\"\"");
                                c++;
                        }
 
                        NULSTR_FOREACH(i, value) {
                                (void) strextendf_with_separator(&joined, ", ", "\"%s\"", i);
                                c++;
                        }
 
                        assert(c > 0);
                        log_event_trace(event, token, "String \"%s\" %s %s%s",
                                        strempty(str),
                                        match ? (c > 1 ? "matches one of" : "matches") : (c > 1 ? "matches neither of" : "does not match"),
                                        strempty(joined),
                                        log_result ? result ? ": PASS" : ": FAIL" : ".");
                        break;
                }
                default:
                        assert_not_reached();
                }
 
        return result;
}
 
static bool token_match_attr(UdevRuleToken *token, sd_device *dev, UdevEvent *event) {
        char nbuf[UDEV_NAME_SIZE], vbuf[UDEV_NAME_SIZE];
        const char *name, *value;
        int r;
 
        assert(token);
        assert(IN_SET(token->type, TK_M_ATTR, TK_M_PARENTS_ATTR));
        assert(dev);
        assert(event);
 
        name = token->data;
 
        switch (token->attr_subst_type) {
        case SUBST_TYPE_FORMAT:
                if (!apply_format_attr(event, token, nbuf, sizeof(nbuf), "sysfs attribute name"))
                        return false;
 
                name = nbuf;
                _fallthrough_;
        case SUBST_TYPE_PLAIN:
                r = sd_device_get_sysattr_value(dev, name, &value);
                if (r < 0) {
                        log_event_trace_errno(event, token, r, "Cannot read sysfs attribute%s%s%s: %m",
                                              name != token->data ? " \"" : "",
                                              name != token->data ? name : "",
                                              name != token->data ? "\"" : "");
                        return false;
                }
 
                /* remove trailing whitespace, if not asked to match for it */
                if (FLAGS_SET(token->match_type, MATCH_REMOVE_TRAILING_WHITESPACE)) {
                        strscpy(vbuf, sizeof(vbuf), value);
                        value = delete_trailing_chars(vbuf, NULL);
                }
 
                return token_match_string(event, token, value, /* log_result= */ true);
 
        case SUBST_TYPE_SUBSYS:
                r = udev_resolve_subsys_kernel(name, vbuf, sizeof(vbuf), true);
                if (r < 0) {
                        log_event_trace_errno(event, token, r, "Cannot read sysfs attribute: %m");
                        return false;
                }
 
                /* remove trailing whitespace, if not asked to match for it */
                if (FLAGS_SET(token->match_type, MATCH_REMOVE_TRAILING_WHITESPACE))
                        delete_trailing_chars(vbuf, NULL);
 
                return token_match_string(event, token, vbuf, /* log_result= */ true);
 
        default:
                assert_not_reached();
        }
}
 
static int get_property_from_string(char *line, char **ret_key, char **ret_value) {
        char *key, *val;
        size_t len;
 
        assert(line);
        assert(ret_key);
        assert(ret_value);
 
        /* find key */
        key = skip_leading_chars(line, NULL);
 
        /* comment or empty line */
        if (IN_SET(key[0], '#', '\0')) {
                *ret_key = *ret_value = NULL;
                return 0;
        }
 
        /* split key/value */
        val = strchr(key, '=');
        if (!val)
                return -EINVAL;
        *val++ = '\0';
 
        key = strstrip(key);
        if (isempty(key))
                return -EINVAL;
 
        val = strstrip(val);
        if (isempty(val))
                return -EINVAL;
 
        /* unquote */
        if (IN_SET(val[0], '"', '\'')) {
                len = strlen(val);
                if (len == 1 || val[len-1] != val[0])
                        return -EINVAL;
                val[len-1] = '\0';
                val++;
        }
 
        *ret_key = key;
        *ret_value = val;
        return 1;
}
 
static int attr_subst_subdir(char attr[static UDEV_PATH_SIZE]) {
        _cleanup_closedir_ DIR *dir = NULL;
        char buf[UDEV_PATH_SIZE], *p;
        const char *tail;
        size_t len, size;
        bool truncated;
 
        assert(attr);
 
        tail = strstr(attr, "/*/");
        if (!tail)
                return 0;
 
        len = tail - attr + 1; /* include slash at the end */
        tail += 2; /* include slash at the beginning */
 
        p = buf;
        size = strnpcpy_full(&p, sizeof(buf), attr, len, &truncated);
        if (truncated)
                return -ENOENT;
 
        dir = opendir(buf);
        if (!dir)
                return -errno;
 
        FOREACH_DIRENT_ALL(de, dir, break) {
                if (de->d_name[0] == '.')
                        continue;
 
                strscpyl_full(p, size, &truncated, de->d_name, tail, NULL);
                if (truncated)
                        continue;
 
                if (faccessat(dirfd(dir), p, F_OK, 0) < 0)
                        continue;
 
                strcpy(attr, buf);
                return 0;
        }
 
        return -ENOENT;
}
 
static size_t udev_replace_ifname_strict(char *str) {
        size_t replaced = 0;
 
        assert(str);
 
        /* See ifname_valid_full(). */
 
        for (char *p = str; *p != '\0'; p++)
                if (!ifname_valid_char(*p)) {
                        *p = '_';
                        replaced++;
                }
 
        return replaced;
}
 
static void udev_replace_ifname(UdevEvent *event, UdevRuleToken *token, char *buf) {
        assert(event);
        assert(token);
        assert(buf);
 
        size_t count;
        if (naming_scheme_has(NAMING_REPLACE_STRICTLY))
                count = udev_replace_ifname_strict(buf);
        else
                count = udev_replace_chars(buf, "/");
        if (count > 0)
                log_event_trace(event, token,
                                "Replaced %zu character(s) from network interface name, results to \"%s\"",
                                count, buf);
}
 
static void udev_replace_chars_and_log(UdevEvent *event, UdevRuleToken *token, char *buf, const char *allow, const char *what) {
        assert(event);
        assert(token);
        assert(buf);
        assert(what);
 
        size_t count = udev_replace_chars(buf, allow);
        if (count > 0)
                log_event_trace(event, token,
                                "Replaced %zu character(s) from %s, results to \"%s\"",
                                count, what, buf);
}
 
static int udev_rule_apply_token_to_event(
                UdevRuleToken *token,
                sd_device *dev,
                UdevEvent *event) {
 
        int r;
 
        assert(token);
        assert(dev);
        assert(event);
 
        /* This returns the following values:
         * 0 on the current token does not match the event,
         * 1 on the current token matches the event, and
         * negative errno on some critical errors. */
 
        switch (token->type) {
        case TK_M_ACTION: {
                sd_device_action_t a;
 
                r = sd_device_get_action(dev, &a);
                if (r < 0)
                        return log_event_error_errno(event, token, r, "Failed to get uevent action type: %m");
 
                return token_match_string(event, token, device_action_to_string(a), /* log_result= */ true);
        }
        case TK_M_DEVPATH: {
                const char *val;
 
                r = sd_device_get_devpath(dev, &val);
                if (r < 0)
                        return log_event_error_errno(event, token, r, "Failed to get devpath: %m");
 
                return token_match_string(event, token, val, /* log_result= */ true);
        }
        case TK_M_KERNEL:
        case TK_M_PARENTS_KERNEL: {
                const char *val;
 
                r = sd_device_get_sysname(dev, &val);
                if (r < 0)
                        return log_event_error_errno(event, token, r, "Failed to get sysname: %m");
 
                return token_match_string(event, token, val, /* log_result= */ true);
        }
        case TK_M_DEVLINK:
                FOREACH_DEVICE_DEVLINK(dev, val)
                        if (token_match_string(event, token, strempty(startswith(val, "/dev/")), /* log_result= */ false) == (token->op == OP_MATCH))
                                return log_event_result(event, token, token->op == OP_MATCH);
                return log_event_result(event, token, token->op == OP_NOMATCH);
 
        case TK_M_NAME:
                return token_match_string(event, token, event->name, /* log_result= */ true);
 
        case TK_M_ENV: {
                const char *val = NULL;
 
                (void) device_get_property_value_with_fallback(dev, token->data, event->worker ? event->worker->properties : NULL, &val);
 
                return token_match_string(event, token, val, /* log_result= */ true);
        }
        case TK_M_CONST: {
                const char *val, *k = token->data;
 
                if (streq(k, "arch"))
                        val = architecture_to_string(uname_architecture());
                else if (streq(k, "virt"))
                        val = virtualization_to_string(detect_virtualization());
                else if (streq(k, "cvm"))
                        val = confidential_virtualization_to_string(detect_confidential_virtualization());
                else
                        assert_not_reached();
                return token_match_string(event, token, val, /* log_result= */ true);
        }
        case TK_M_TAG:
        case TK_M_PARENTS_TAG:
                FOREACH_DEVICE_CURRENT_TAG(dev, val)
                        if (token_match_string(event, token, val, /* log_result= */ false) == (token->op == OP_MATCH))
                                return log_event_result(event, token, token->op == OP_MATCH);
                return log_event_result(event, token, token->op == OP_NOMATCH);
 
        case TK_M_SUBSYSTEM:
        case TK_M_PARENTS_SUBSYSTEM: {
                const char *val;
 
                r = sd_device_get_subsystem(dev, &val);
                if (r == -ENOENT)
                        val = NULL;
                else if (r < 0)
                        return log_event_error_errno(event, token, r, "Failed to get subsystem: %m");
 
                return token_match_string(event, token, val, /* log_result= */ true);
        }
        case TK_M_DRIVER:
        case TK_M_PARENTS_DRIVER: {
                const char *val;
 
                r = sd_device_get_driver(dev, &val);
                if (r == -ENOENT)
                        val = NULL;
                else if (r < 0)
                        return log_event_error_errno(event, token, r, "Failed to get driver: %m");
 
                return token_match_string(event, token, val, /* log_result= */ true);
        }
        case TK_M_ATTR:
        case TK_M_PARENTS_ATTR:
                return token_match_attr(token, dev, event);
 
        case TK_M_SYSCTL: {
                _cleanup_free_ char *value = NULL;
                char buf[UDEV_PATH_SIZE];
 
                if (!apply_format_attr(event, token, buf, sizeof(buf), "sysctl entry name"))
                        return false;
 
                r = sysctl_read(sysctl_normalize(buf), &value);
                if (r < 0 && r != -ENOENT)
                        return log_event_error_errno(event, token, r, "Failed to read sysctl \"%s\": %m", buf);
 
                return token_match_string(event, token, strstrip(value), /* log_result= */ true);
        }
        case TK_M_TEST: {
                mode_t mode = PTR_TO_MODE(token->data);
                char buf[UDEV_PATH_SIZE];
                struct stat statbuf;
                bool match;
 
                if (!apply_format_value(event, token, buf, sizeof(buf), "file name"))
                        return false;
 
                if (!path_is_absolute(buf) &&
                    udev_resolve_subsys_kernel(buf, buf, sizeof(buf), false) < 0) {
                        char tmp[UDEV_PATH_SIZE];
                        const char *val;
 
                        r = sd_device_get_syspath(dev, &val);
                        if (r < 0)
                                return log_event_error_errno(event, token, r, "Failed to get syspath: %m");
 
                        bool truncated;
                        strscpy_full(tmp, sizeof(tmp), buf, &truncated);
                        assert(!truncated);
                        strscpyl_full(buf, sizeof(buf), &truncated, val, "/", tmp, NULL);
                        if (truncated)
                                return log_event_result(event, token, false);
                }
 
                r = attr_subst_subdir(buf);
                if (r == -ENOENT)
                        return log_event_result(event, token, token->op == OP_NOMATCH);
                if (r < 0)
                        return log_event_error_errno(event, token, r, "Failed to test for the existence of \"%s\": %m", buf);
 
                if (stat(buf, &statbuf) < 0) {
                        if (errno != ENOENT)
                                log_event_warning_errno(event, token, errno, "Failed to stat \"%s\", ignoring: %m", buf);
                        return log_event_result(event, token, token->op == OP_NOMATCH);
                }
 
                if (mode == MODE_INVALID)
                        return log_event_result(event, token, token->op == OP_MATCH);
 
                match = (statbuf.st_mode & mode) > 0;
                return log_event_result(event, token, token->op == (match ? OP_MATCH : OP_NOMATCH));
        }
        case TK_M_PROGRAM: {
                char buf[UDEV_LINE_SIZE], result[UDEV_LINE_SIZE];
 
                event->program_result = mfree(event->program_result);
 
                if (!apply_format_value(event, token, buf, sizeof(buf), "command"))
                        return false;
 
                log_event_debug(event, token, "Running command \"%s\"", buf);
 
                r = udev_event_spawn(event, /* accept_failure= */ true, buf, result, sizeof(result), NULL);
                if (r != 0) {
                        if (r < 0)
                                log_event_warning_errno(event, token, r, "Failed to execute \"%s\": %m", buf);
                        else /* returned value is positive when program fails */
                                log_event_debug(event, token, "Command \"%s\" returned %d (error)", buf, r);
                        return log_event_result(event, token, token->op == OP_NOMATCH);
                }
 
                delete_trailing_chars(result, "\n");
                udev_replace_chars_and_log(event, token, result, UDEV_ALLOWED_CHARS_INPUT, "command output");
 
                event->program_result = strdup(result);
                return log_event_result(event, token, token->op == OP_MATCH);
        }
        case TK_M_IMPORT_FILE: {
                _cleanup_fclose_ FILE *f = NULL;
                char buf[UDEV_PATH_SIZE];
 
                if (!apply_format_value(event, token, buf, sizeof(buf), "file name to be imported"))
                        return false;
 
                log_event_debug(event, token, "Importing properties from \"%s\"", buf);
 
                f = fopen(buf, "re");
                if (!f) {
                        if (errno != ENOENT)
                                return log_event_error_errno(event, token, errno, "Failed to open \"%s\": %m", buf);
                        return log_event_result(event, token, token->op == OP_NOMATCH);
                }
 
                for (;;) {
                        _cleanup_free_ char *line = NULL;
                        char *key, *value;
 
                        r = read_line(f, LONG_LINE_MAX, &line);
                        if (r < 0) {
                                log_event_debug_errno(event, token, r, "Failed to read \"%s\", ignoring: %m", buf);
                                return log_event_result(event, token, token->op == OP_NOMATCH);
                        }
                        if (r == 0)
                                return log_event_result(event, token, token->op == OP_MATCH);
 
                        r = get_property_from_string(line, &key, &value);
                        if (r < 0) {
                                log_event_debug_errno(event, token, r,
                                                      "Failed to parse key and value from \"%s\", ignoring: %m",
                                                      line);
                                continue;
                        }
                        if (r == 0)
                                continue;
 
                        r = device_add_property(dev, key, value);
                        if (r == -ENOMEM)
                                return log_oom();
                        if (r < 0)
                                log_event_warning_errno(event, token, r, "Failed to import property \"%s=%s\", ignoring: %m", key, value);
                        else
                                log_event_trace(event, token, "Imported property \"%s=%s\".", key, value);
                }
 
                assert_not_reached();
        }
        case TK_M_IMPORT_PROGRAM: {
                _cleanup_strv_free_ char **lines = NULL;
                char buf[UDEV_LINE_SIZE], result[UDEV_LINE_SIZE];
                bool truncated;
 
                if (!apply_format_value(event, token, buf, sizeof(buf), "command"))
                        return false;
 
                log_event_debug(event, token, "Importing properties from results of \"%s\"", buf);
 
                r = udev_event_spawn(event, /* accept_failure= */ true, buf, result, sizeof result, &truncated);
                if (r != 0) {
                        if (r < 0)
                                log_event_warning_errno(event, token, r, "Failed to execute \"%s\", ignoring: %m", buf);
                        else /* returned value is positive when program fails */
                                log_event_debug(event, token, "Command \"%s\" returned %d (error), ignoring", buf, r);
                        return log_event_result(event, token, token->op == OP_NOMATCH);
                }
 
                if (truncated) {
                        log_event_debug(event, token, "Result of \"%s\" is too long and truncated, ignoring the last line of the result.", buf);
 
                        /* Drop the last line. */
                        bool found = false;
                        for (char *p = PTR_SUB1(result + strlen(result), result); p; p = PTR_SUB1(p, result))
                                if (strchr(NEWLINE, *p)) {
                                        *p = '\0';
                                        found = true;
                                        break;
                                }
                        if (!found)
                                result[0] = '\0';
                }
 
                r = strv_split_newlines_full(&lines, result, EXTRACT_RETAIN_ESCAPE);
                if (r == -ENOMEM)
                        return log_oom();
                if (r < 0) {
                        log_event_warning_errno(event, token, r,
                                                "Failed to extract lines from result of command \"%s\", ignoring: %m", buf);
                        return log_event_result(event, token, false);
                }
 
                STRV_FOREACH(line, lines) {
                        char *key, *value;
 
                        r = get_property_from_string(*line, &key, &value);
                        if (r < 0) {
                                log_event_debug_errno(event, token, r,
                                                      "Failed to parse key and value from \"%s\", ignoring: %m",
                                                      *line);
                                continue;
                        }
                        if (r == 0)
                                continue;
 
                        r = device_add_property(dev, key, value);
                        if (r == -ENOMEM)
                                return log_oom();
                        if (r < 0)
                                log_event_warning_errno(event, token, r, "Failed to import property \"%s=%s\", ignoring: %m", key, value);
                        else
                                log_event_trace(event, token, "Imported property \"%s=%s\".", key, value);
                }
 
                return log_event_result(event, token, token->op == OP_MATCH);
        }
        case TK_M_IMPORT_BUILTIN: {
                UdevBuiltinCommand cmd = PTR_TO_UDEV_BUILTIN_CMD(token->data);
                assert(cmd >= 0 && cmd < _UDEV_BUILTIN_MAX);
                unsigned mask = 1U << (int) cmd;
                char buf[UDEV_LINE_SIZE];
 
                if (udev_builtin_run_once(cmd)) {
                        /* check if we ran already */
                        if (event->builtin_run & mask) {
                                log_event_debug(event, token, "Builtin command \"%s\" has already run, skipping.",
                                                udev_builtin_name(cmd));
                                /* return the result from earlier run */
                                return log_event_result(event, token, token->op == (event->builtin_ret & mask ? OP_NOMATCH : OP_MATCH));
                        }
                        /* mark as ran */
                        event->builtin_run |= mask;
                }
 
                if (!apply_format_value(event, token, buf, sizeof(buf), "builtin command"))
                        return false;
 
                log_event_debug(event, token, "Importing properties from results of builtin command \"%s\".", buf);
 
                r = udev_builtin_run(event, cmd, buf);
                if (r < 0) {
                        /* remember failure */
                        log_event_debug_errno(event, token, r, "Failed to run builtin \"%s\": %m", buf);
                        event->builtin_ret |= mask;
                }
                return log_event_result(event, token, token->op == (r >= 0 ? OP_MATCH : OP_NOMATCH));
        }
        case TK_M_IMPORT_DB: {
                const char *val;
 
                if (!event->dev_db_clone)
                        return log_event_result(event, token, token->op == OP_NOMATCH);
                r = sd_device_get_property_value(event->dev_db_clone, token->value, &val);
                if (r == -ENOENT)
                        return log_event_result(event, token, token->op == OP_NOMATCH);
                if (r < 0)
                        return log_event_error_errno(event, token, r,
                                                     "Failed to get property \"%s\" from database: %m",
                                                     token->value);
 
                r = device_add_property(dev, token->value, val);
                if (r == -ENOMEM)
                        return log_oom();
                if (r < 0)
                        log_event_warning_errno(event, token, r, "Failed to import property \"%s=%s\", ignoring: %m", token->value, val);
                else
                        log_event_trace(event, token, "Imported property \"%s=%s\".", token->value, val);
 
                return log_event_result(event, token, token->op == OP_MATCH);
        }
        case TK_M_IMPORT_CMDLINE: {
                _cleanup_free_ char *value = NULL;
 
                r = proc_cmdline_get_key(token->value, PROC_CMDLINE_VALUE_OPTIONAL, &value);
                if (r < 0)
                        return log_event_error_errno(event, token, r,
                                                     "Failed to read \"%s\" option from /proc/cmdline: %m",
                                                     token->value);
                if (r == 0)
                        return log_event_result(event, token, token->op == OP_NOMATCH);
 
                const char *val = value ?: "1";
                r = device_add_property(dev, token->value, val);
                if (r == -ENOMEM)
                        return log_oom();
                if (r < 0)
                        log_event_warning_errno(event, token, r, "Failed to import property \"%s=%s\", ignoring: %m", token->value, val);
                else
                        log_event_trace(event, token, "Imported property \"%s=%s\".", token->value, val);
 
                return log_event_result(event, token, token->op == OP_MATCH);
        }
        case TK_M_IMPORT_PARENT: {
                char buf[UDEV_PATH_SIZE];
 
                if (!apply_format_value(event, token, buf, sizeof(buf), "property name"))
                        return false;
 
                sd_device *parent;
                r = sd_device_get_parent(dev, &parent);
                if (ERRNO_IS_NEG_DEVICE_ABSENT(r))
                        return log_event_result(event, token, token->op == OP_NOMATCH);
                if (r < 0)
                        return log_event_error_errno(event, token, r, "Failed to get parent device: %m");
 
                bool have = false;
                FOREACH_DEVICE_PROPERTY(parent, key, val) {
                        if (fnmatch(buf, key, 0) != 0)
                                continue;
 
                        r = device_add_property(dev, key, val);
                        if (r == -ENOMEM)
                                return log_oom();
                        if (r < 0)
                                log_event_warning_errno(event, token, r, "Failed to import property \"%s=%s\", ignoring: %m", key, val);
                        else {
                                log_event_trace(event, token, "Imported property \"%s=%s\".", key, val);
                                have = true;
                        }
                }
 
                return log_event_result(event, token, token->op == (have ? OP_MATCH : OP_NOMATCH));
        }
        case TK_M_RESULT:
                return token_match_string(event, token, event->program_result, /* log_result= */ true);
 
        case TK_A_OPTIONS_DUMP: {
                sd_json_format_flags_t flags = PTR_TO_UINT(token->data);
 
                log_event_info(event, token, "Dumping current state:");
 
                _cleanup_(memstream_done) MemStream m = {};
                FILE *f = memstream_init(&m);
                if (!f)
                        return log_oom();
 
                (void) dump_event(event, flags, f);
 
                _cleanup_free_ char *buf = NULL;
                r = memstream_finalize(&m, &buf, NULL);
                if (r < 0)
                        log_event_warning_errno(event, token, r, "Failed to finalize memory stream, ignoring: %m");
                else
                        log_device_info(dev, "%s", buf);
 
                log_event_info(event, token, "DONE");
                return true;
        }
        case TK_A_OPTIONS_STRING_ESCAPE_NONE:
                event->esc = ESCAPE_NONE;
                return log_event_done(event, token);
 
        case TK_A_OPTIONS_STRING_ESCAPE_REPLACE:
                event->esc = ESCAPE_REPLACE;
                return log_event_done(event, token);
 
        case TK_A_OPTIONS_DB_PERSIST:
                device_set_db_persist(dev);
                return log_event_done(event, token);
 
        case TK_A_OPTIONS_INOTIFY_WATCH:
                if (event->inotify_watch_final)
                        return log_event_final_set(event, token);
 
                if (token->op == OP_ASSIGN_FINAL)
                        event->inotify_watch_final = true;
 
                event->inotify_watch = token->data;
                return log_event_done(event, token);
 
        case TK_A_OPTIONS_DEVLINK_PRIORITY:
                device_set_devlink_priority(dev, PTR_TO_INT(token->data));
                return log_event_done(event, token);
 
        case TK_A_OPTIONS_LOG_LEVEL: {
                int level = PTR_TO_INT(token->data);
 
                if (level < 0)
                        level = event->default_log_level;
 
                if (event->event_mode == EVENT_UDEV_WORKER)
                        log_set_max_level(level);
                else {
                        _cleanup_free_ char *level_str = NULL;
                        (void) log_level_to_string_alloc(level, &level_str);
                        log_event_debug(event, token, "Running in test mode, skipping changing maximum log level to %s.", strna(level_str));
                }
 
                if (level == LOG_DEBUG && !event->log_level_was_debug) {
                        /* The log level becomes LOG_DEBUG at first time. Let's log basic information. */
                        if (event->event_mode == EVENT_UDEV_WORKER)
                                log_device_uevent(dev, "The log level is changed to 'debug' while processing device");
                        event->log_level_was_debug = true;
                }
 
                return log_event_done(event, token);
        }
        case TK_A_OWNER: {
                char owner[UDEV_NAME_SIZE];
 
                if (event->owner_final)
                        return log_event_final_set(event, token);
 
                if (token->op == OP_ASSIGN_FINAL)
                        event->owner_final = true;
 
                if (!apply_format_value(event, token, owner, sizeof(owner), "user name"))
                        return true;
 
                _cleanup_(user_record_unrefp) UserRecord *ur = NULL;
                r = userdb_by_name(owner, /* match= */ NULL,
                                   USERDB_SUPPRESS_SHADOW | USERDB_PARSE_NUMERIC | USERDB_SYNTHESIZE_NUMERIC,
                                   &ur);
                if (r < 0)
                        log_event_error_errno(event, token, r,
                                              "Failed to resolve user \"%s\", ignoring: %s",
                                              owner, STRERROR_USER(r));
                else {
                        if (!uid_is_system(ur->uid))
                                log_udev_event_syntax(event, token, LOG_WARNING,
                                                      SD_MESSAGE_SYSTEM_ACCOUNT_REQUIRED_STR,
                                                      "User %s configured to own a device node is not a system user. "
                                                      "Support for device node ownership by non-system accounts is deprecated and will be removed in the future.",
                                                      owner);
 
                        event->uid = ur->uid;
                        log_event_debug(event, token, "Set owner: %s("UID_FMT")", owner, event->uid);
                }
                return true;
        }
        case TK_A_GROUP: {
                char group[UDEV_NAME_SIZE];
 
                if (event->group_final)
                        return log_event_final_set(event, token);
 
                if (token->op == OP_ASSIGN_FINAL)
                        event->group_final = true;
 
                if (!apply_format_value(event, token, group, sizeof(group), "group name"))
                        return true;
 
                _cleanup_(group_record_unrefp) GroupRecord *gr = NULL;
                r = groupdb_by_name(group, /* match= */ NULL,
                                    USERDB_SUPPRESS_SHADOW | USERDB_PARSE_NUMERIC | USERDB_SYNTHESIZE_NUMERIC,
                                    &gr);
                if (r < 0)
                        log_event_error_errno(event, token, r,
                                              "Failed to resolve group \"%s\", ignoring: %s",
                                              group, STRERROR_GROUP(r));
                else {
                        if (!gid_is_system(gr->gid))
                                log_udev_event_syntax(event, token, LOG_WARNING,
                                                      SD_MESSAGE_SYSTEM_ACCOUNT_REQUIRED_STR,
                                                      "Group %s configured to own a device node is not a system group. "
                                                      "Support for device node ownership by non-system accounts is deprecated and will be removed in the future.",
                                                      group);
 
                        event->gid = gr->gid;
                        log_event_debug(event, token, "Set group: %s("GID_FMT")", group, event->gid);
                }
                return true;
        }
        case TK_A_MODE: {
                char mode_str[UDEV_NAME_SIZE];
 
                if (event->mode_final)
                        return log_event_final_set(event, token);
 
                if (token->op == OP_ASSIGN_FINAL)
                        event->mode_final = true;
 
                if (!apply_format_value(event, token, mode_str, sizeof(mode_str), "mode"))
                        return true;
 
                r = parse_mode(mode_str, &event->mode);
                if (r < 0)
                        log_event_error_errno(event, token, r, "Failed to parse mode \"%s\", ignoring: %m", mode_str);
                else
                        log_event_debug(event, token, "Set mode: %#o", event->mode);
                return true;
        }
        case TK_A_OWNER_ID:
                if (event->owner_final)
                        return log_event_final_set(event, token);
 
                if (token->op == OP_ASSIGN_FINAL)
                        event->owner_final = true;
 
                event->uid = PTR_TO_UID(ASSERT_PTR(token->data));
                log_event_debug(event, token, "Set owner ID: %u", event->uid);
                return true;
 
        case TK_A_GROUP_ID:
                if (event->group_final)
                        return log_event_final_set(event, token);
 
                if (token->op == OP_ASSIGN_FINAL)
                        event->group_final = true;
 
                event->gid = PTR_TO_GID(ASSERT_PTR(token->data));
                log_event_debug(event, token, "Set group ID: %u", event->gid);
                return true;
 
        case TK_A_MODE_ID:
                if (event->mode_final)
                        return log_event_final_set(event, token);
 
                if (token->op == OP_ASSIGN_FINAL)
                        event->mode_final = true;
 
                event->mode = PTR_TO_MODE(ASSERT_PTR(token->data));
                log_event_debug(event, token, "Set mode: %#o", event->mode);
                return true;
 
        case TK_A_SECLABEL: {
                _cleanup_free_ char *name = NULL, *label = NULL;
                char label_str[UDEV_LINE_SIZE] = {};
 
                name = strdup(token->data);
                if (!name)
                        return log_oom();
 
                if (!apply_format_value(event, token, label_str, sizeof(label_str), "security label"))
                        return true;
 
                if (!isempty(label_str))
                        label = strdup(label_str);
                else
                        label = strdup(token->value);
                if (!label)
                        return log_oom();
 
                if (token->op == OP_ASSIGN)
                        ordered_hashmap_clear(event->seclabel_list);
 
                r = ordered_hashmap_ensure_put(&event->seclabel_list, &trivial_hash_ops_free_free, name, label);
                if (r == -ENOMEM)
                        return log_oom();
                if (r < 0)
                        return log_event_error_errno(event, token, r, "Failed to store security label \"%s=%s\": %m", name, label);
 
                log_event_debug(event, token, "Set security label: %s=%s", name, label);
 
                TAKE_PTR(name);
                TAKE_PTR(label);
                return true;
        }
        case TK_A_ENV: {
                const char *val, *name = token->data;
                char value_new[UDEV_NAME_SIZE], *p = value_new;
                size_t l = sizeof(value_new);
 
                if (isempty(token->value)) {
                        if (token->op == OP_ADD)
                                return log_event_done(event, token);
 
                        r = device_add_property(dev, name, NULL);
                        if (r < 0)
                                return log_event_error_errno(event, token, r, "Failed to remove property \"%s\": %m", name);
                        log_event_trace(event, token, "Removed property \"%s\".", name);
                        return true;
                }
 
                if (token->op == OP_ADD &&
                    device_get_property_value_with_fallback(dev, name, event->worker ? event->worker->properties : NULL, &val) >= 0) {
                        bool truncated;
                        l = strpcpyl_full(&p, l, &truncated, val, " ", NULL);
                        if (truncated) {
                                log_event_warning(event, token,
                                                  "The buffer for the property is full, refusing to append new property \"%s=%s\".",
                                                  name, token->value);
                                return true;
                        }
                }
 
                if (!apply_format_value(event, token, p, l, "property value"))
                        return true;
 
                if (event->esc == ESCAPE_REPLACE)
                        udev_replace_chars_and_log(event, token, p, /* allow= */ NULL, "property value");
 
                r = device_add_property(dev, name, value_new);
                if (r == -ENOMEM)
                        return log_oom();
                if (r < 0)
                        log_event_warning_errno(event, token, r, "Failed to set property \"%s=%s\", ignoring: %m", name, value_new);
                else
                        log_event_trace(event, token, "Set property \"%s=%s\".", name, value_new);
                return true;
        }
        case TK_A_TAG: {
                char buf[UDEV_PATH_SIZE];
 
                if (!apply_format_value(event, token, buf, sizeof(buf), "tag name"))
                        return true;
 
                if (token->op == OP_REMOVE) {
                        device_remove_tag(dev, buf);
                        log_event_trace(event, token, "Removed tag \"%s\".", buf);
                        return true;
                }
 
                assert(IN_SET(token->op, OP_ASSIGN, OP_ADD));
 
                if (token->op == OP_ASSIGN) {
                        r = device_cleanup_tags(dev, event->dev_db_clone);
                        if (r < 0)
                                log_event_warning_errno(event, token, r, "Failed to clear previously assigned tags, ignoring: %m");
                }
 
                r = device_add_tag(dev, buf, /* both= */ true);
                if (r == -ENOMEM)
                        return log_oom();
                if (r < 0)
                        log_event_warning_errno(event, token, r, "Failed to %s tag \"%s\", ignoring: %m",
                                                token->op == OP_ASSIGN ? "set" : "add", buf);
                else
                        log_event_trace(event, token, "%s tag \"%s\".", token->op == OP_ASSIGN ? "Set" : "Added", buf);
                return true;
        }
        case TK_A_NAME: {
                char buf[UDEV_PATH_SIZE];
 
                if (event->name_final)
                        return log_event_final_set(event, token);
 
                if (token->op == OP_ASSIGN_FINAL)
                        event->name_final = true;
 
                if (sd_device_get_ifindex(dev, NULL) < 0) {
                        log_event_warning(event, token, "Only network interfaces can be renamed, ignoring.");
                        return true;
                }
 
                if (!apply_format_value(event, token, buf, sizeof(buf), "network interface name"))
                        return true;
 
                if (IN_SET(event->esc, ESCAPE_UNSET, ESCAPE_REPLACE))
                        udev_replace_ifname(event, token, buf);
 
                r = free_and_strdup_warn(&event->name, buf);
                if (r < 0)
                        return r;
 
                log_event_debug(event, token, "Set network interface name: %s", event->name);
                return true;
        }
        case TK_A_DEVLINK: {
                char buf[UDEV_PATH_SIZE];
 
                if (event->devlink_final)
                        return log_event_final_set(event, token);
 
                if (sd_device_get_devnum(dev, NULL) < 0) {
                        log_event_debug(event, token, "Device does not have device node, ignoring to manage device node symlink.");
                        return true;
                }
 
                if (token->op == OP_ASSIGN_FINAL)
                        event->devlink_final = true;
 
                if (IN_SET(token->op, OP_ASSIGN, OP_ASSIGN_FINAL))
                        device_cleanup_devlinks(dev);
 
                if (!apply_format_full(event, token, token->value, buf, sizeof(buf),
                                       /* replace_whitespace= */ event->esc != ESCAPE_NONE,
                                       "symbolic link path"))
                        return true;
 
                /* By default or string_escape=none, allow multiple symlinks separated by spaces. */
                if (event->esc == ESCAPE_UNSET)
                        udev_replace_chars_and_log(event, token, buf, /* allow= */ "/ ", "device node symlink");
                else if (event->esc == ESCAPE_REPLACE)
                        udev_replace_chars_and_log(event, token, buf, /* allow= */ "/", "device node symlink");
 
                for (const char *p = buf;;) {
                        _cleanup_free_ char *path = NULL;
 
                        r = extract_first_word(&p, &path, NULL, EXTRACT_RETAIN_ESCAPE);
                        if (r == -ENOMEM)
                                return log_oom();
                        if (r < 0) {
                                log_warning_errno(r, "Failed to extract first path in device node symlinks, ignoring: %m");
                                return true;
                        }
                        if (r == 0)
                                return true;