HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/udev/udev-rules.c
Git blob: c7443a98981e096d10358ad4f663909ffd0ee64a
Lines 1–1000 of 3,362
/* SPDX-License-Identifier: GPL-2.0-or-later */
#include <ctype.h>
#include <fnmatch.h>
#include <unistd.h>
#include "sd-json.h"
#include "sd-messages.h"
#include "alloc-util.h"
#include "architecture.h"
#include "chase.h" /* IWYU pragma: keep */
#include "conf-files.h"
#include "conf-parser.h"
#include "confidential-virt.h"
#include "constants.h"
#include "device-private.h"
#include "device-util.h"
#include "dirent-util.h"
#include "errno-util.h"
#include "escape.h"
#include "extract-word.h"
#include "fd-util.h"
#include "fileio.h"
#include "format-util.h"
#include "fs-util.h"
#include "glob-util.h"
#include "hashmap.h"
#include "list.h"
#include "memstream-util.h"
#include "netif-naming-scheme.h"
#include "nulstr-util.h"
#include "parse-util.h"
#include "path-util.h"
#include "proc-cmdline.h"
#include "socket-util.h"
#include "stat-util.h"
#include "string-table.h"
#include "string-util.h"
#include "strv.h"
#include "strxcpyx.h"
#include "sysctl-util.h"
#include "syslog-util.h"
#include "udev-builtin.h"
#include "udev-dump.h"
#include "udev-event.h"
#include "udev-format.h"
#include "udev-node.h"
#include "udev-rules.h"
#include "udev-spawn.h"
#include "udev-trace.h"
#include "udev-util.h"
#include "udev-worker.h"
#include "uid-classification.h"
#include "user-record.h"
#include "user-util.h"
#include "userdb.h"
#include "virt.h"
#define RULES_DIRS ((const char* const*) CONF_PATHS_STRV("udev/rules.d"))
typedef enum {
OP_MATCH, /* == */
OP_NOMATCH, /* != */
OP_ADD, /* += */
OP_REMOVE, /* -= */
OP_ASSIGN, /* = */
OP_ASSIGN_FINAL, /* := */
_OP_TYPE_MAX,
_OP_TYPE_INVALID = -EINVAL,
} UdevRuleOperatorType;
typedef enum {
MATCH_TYPE_EMPTY, /* empty string */
MATCH_TYPE_PLAIN, /* no special characters */
MATCH_TYPE_PLAIN_WITH_EMPTY, /* no special characters with empty string, e.g., "|foo" */
MATCH_TYPE_GLOB, /* shell globs ?,*,[] */
MATCH_TYPE_GLOB_WITH_EMPTY, /* shell globs ?,*,[] with empty string, e.g., "|foo*" */
MATCH_TYPE_SUBSYSTEM, /* "subsystem", "bus", or "class" */
_MATCH_TYPE_MAX,
_MATCH_TYPE_MASK = (1 << 5) - 1,
MATCH_REMOVE_TRAILING_WHITESPACE = 1 << 5, /* Remove trailing whitespaces in attribute */
MATCH_CASE_INSENSITIVE = 1 << 6, /* string or pattern is matched case-insensitively */
_MATCH_TYPE_INVALID = -EINVAL,
} UdevRuleMatchType;
assert_cc(_MATCH_TYPE_MAX <= _MATCH_TYPE_MASK);
typedef enum {
SUBST_TYPE_PLAIN, /* no substitution */
SUBST_TYPE_FORMAT, /* % or $ */
SUBST_TYPE_SUBSYS, /* "[<SUBSYSTEM>/<KERNEL>]<attribute>" format */
_SUBST_TYPE_MAX,
_SUBST_TYPE_INVALID = -EINVAL,
} UdevRuleSubstituteType;
typedef enum {
/* lvalues which take match or nomatch operator */
TK_M_ACTION, /* string, device_get_action() */
TK_M_DEVPATH, /* path, sd_device_get_devpath() */
TK_M_KERNEL, /* string, sd_device_get_sysname() */
TK_M_DEVLINK, /* strv, sd_device_get_devlink_first(), sd_device_get_devlink_next() */
TK_M_NAME, /* string, name of network interface */
TK_M_ENV, /* string, device property, takes key through attribute */
TK_M_CONST, /* string, system-specific hard-coded constant */
TK_M_TAG, /* strv, sd_device_get_tag_first(), sd_device_get_tag_next() */
TK_M_SUBSYSTEM, /* string, sd_device_get_subsystem() */
TK_M_DRIVER, /* string, sd_device_get_driver() */
TK_M_ATTR, /* string, takes filename through attribute, sd_device_get_sysattr_value(), udev_resolve_subsys_kernel(), etc. */
TK_M_SYSCTL, /* string, takes kernel parameter through attribute */
/* matches parent parameters */
TK_M_PARENTS_KERNEL, /* string */
TK_M_PARENTS_SUBSYSTEM, /* string */
TK_M_PARENTS_DRIVER, /* string */
TK_M_PARENTS_ATTR, /* string */
TK_M_PARENTS_TAG, /* strv */
TK_M_TEST, /* path, optionally mode_t can be specified by attribute, test the existence of a file */
TK_M_PROGRAM, /* string, execute a program */
TK_M_IMPORT_FILE, /* path */
TK_M_IMPORT_PROGRAM, /* string, import properties from the result of program */
TK_M_IMPORT_BUILTIN, /* string, import properties from the result of built-in command */
TK_M_IMPORT_DB, /* string, import properties from database */
TK_M_IMPORT_CMDLINE, /* string, kernel command line */
TK_M_IMPORT_PARENT, /* string, parent property */
TK_M_RESULT, /* string, result of TK_M_PROGRAM */
#define _TK_M_MAX (TK_M_RESULT + 1)
#define _TK_A_MIN _TK_M_MAX
/* lvalues which take one of assign operators */
TK_A_OPTIONS_DUMP, /* no argument */
TK_A_OPTIONS_STRING_ESCAPE_NONE, /* no argument */
TK_A_OPTIONS_STRING_ESCAPE_REPLACE, /* no argument */
TK_A_OPTIONS_DB_PERSIST, /* no argument */
TK_A_OPTIONS_INOTIFY_WATCH, /* boolean */
TK_A_OPTIONS_DEVLINK_PRIORITY, /* int */
TK_A_OPTIONS_LOG_LEVEL, /* string of log level or "reset" */
TK_A_OWNER, /* user name */
TK_A_GROUP, /* group name */
TK_A_MODE, /* mode string */
TK_A_OWNER_ID, /* uid_t */
TK_A_GROUP_ID, /* gid_t */
TK_A_MODE_ID, /* mode_t */
TK_A_TAG, /* string */
TK_A_OPTIONS_STATIC_NODE, /* device path, /dev/... */
TK_A_SECLABEL, /* string with attribute */
TK_A_ENV, /* string with attribute */
TK_A_NAME, /* ifname */
TK_A_DEVLINK, /* string */
TK_A_ATTR, /* string with attribute */
TK_A_SYSCTL, /* string with attribute */
TK_A_RUN_BUILTIN, /* string */
TK_A_RUN_PROGRAM, /* string */
_TK_TYPE_MAX,
_TK_TYPE_INVALID = -EINVAL,
} UdevRuleTokenType;
typedef enum {
LINE_HAS_NAME = 1 << 0, /* has NAME= */
LINE_HAS_DEVLINK = 1 << 1, /* has SYMLINK=, OWNER=, GROUP= or MODE= */
LINE_HAS_STATIC_NODE = 1 << 2, /* has OPTIONS=static_node */
LINE_HAS_GOTO = 1 << 3, /* has GOTO= */
LINE_HAS_LABEL = 1 << 4, /* has LABEL= */
LINE_UPDATE_SOMETHING = 1 << 5, /* has other TK_A_* or TK_M_IMPORT tokens */
LINE_IS_REFERENCED = 1 << 6, /* is referenced by GOTO */
} UdevRuleLineType;
typedef struct UdevRuleFile UdevRuleFile;
typedef struct UdevRuleLine UdevRuleLine;
typedef struct UdevRuleToken UdevRuleToken;
struct UdevRuleToken {
UdevRuleTokenType type:8;
UdevRuleOperatorType op:8;
UdevRuleMatchType match_type:8;
UdevRuleSubstituteType attr_subst_type:8;
const char *value;
void *data;
const char *token_str; /* original token string for logging */
UdevRuleLine *rule_line;
LIST_FIELDS(UdevRuleToken, tokens);
};
struct UdevRuleLine {
char *line;
char *line_for_logging;
unsigned line_number;
UdevRuleLineType type;
const char *label;
const char *goto_label;
UdevRuleLine *goto_line;
UdevRuleFile *rule_file;
LIST_HEAD(UdevRuleToken, tokens);
LIST_FIELDS(UdevRuleLine, rule_lines);
};
struct UdevRuleFile {
char *filename;
unsigned issues; /* used by "udevadm verify" */
UdevRules *rules;
LIST_HEAD(UdevRuleLine, rule_lines);
LIST_FIELDS(UdevRuleFile, rule_files);
};
struct UdevRules {
ResolveNameTiming resolve_name_timing;
Hashmap *known_users;
Hashmap *known_groups;
Hashmap *stats_by_path;
LIST_HEAD(UdevRuleFile, rule_files);
};
#define LINE_GET_RULES(line) \
ASSERT_PTR(ASSERT_PTR(ASSERT_PTR(line)->rule_file)->rules)
static bool token_is_for_parents(UdevRuleToken *token) {
return token->type >= TK_M_PARENTS_KERNEL && token->type <= TK_M_PARENTS_TAG;
}
/*** Logging helpers ***/
#define log_udev_event_syntax(event, token, level, message_id, fmt, ...) \
({ \
UdevEvent *_event = (event); \
UdevRuleToken *_token = ASSERT_PTR(token); \
int _level = (level); \
sd_device *_d = token_is_for_parents(_token) ? _event->dev_parent : _event->dev; \
const char *_sysname = NULL; \
\
if (_d && log_get_max_level() >= LOG_PRI(_level)) \
(void) sd_device_get_sysname(_d, &_sysname); \
log_struct(_level, \
LOG_MESSAGE("%s:%u %s:" fmt, \
strna(_token->rule_line->rule_file ? _token->rule_line->rule_file->filename : NULL), \
_token->rule_line->line_number, \
_token->token_str, \
__VA_ARGS__), \
LOG_MESSAGE_ID(message_id), \
LOG_ITEM("DEVICE=%s", strempty(_sysname))); \
})
#define _log_udev_rule_file_full(device, device_u, file, file_u, line_nr, level, level_u, error, fmt, ...) \
({ \
int level_u = (level); \
sd_device *device_u = (device); \
UdevRuleFile *file_u = (file); \
\
if (!device_u && file_u) \
file_u->issues |= (1U << level_u); \
\
log_device_full_errno_zerook( \
device_u, level_u, error, "%s:%u " fmt, \
strna(file_u ? file_u->filename : NULL), \
line_nr, ##__VA_ARGS__); \
})
#define log_udev_rule_file_full(device, file, line_nr, level, error, fmt, ...) \
_log_udev_rule_file_full(device, UNIQ_T(d, UNIQ), file, UNIQ_T(f, UNIQ), line_nr, level, UNIQ_T(l, UNIQ), error, fmt, ##__VA_ARGS__)
#define _log_udev_rule_line_full(device, line, line_u, ...) \
({ \
UdevRuleLine *line_u = ASSERT_PTR(line); \
\
log_udev_rule_file_full( \
device, \
line_u->rule_file, line_u->line_number, \
__VA_ARGS__); \
})
#define log_udev_rule_line_full(device, line, ...) \
_log_udev_rule_line_full(device, line, UNIQ_T(l, UNIQ), __VA_ARGS__)
/* Mainly used when applying tokens to the event device. */
#define _log_event_full_errno_zerook(event, event_u, token, token_u, level, error, fmt, ...) \
({ \
UdevEvent *event_u = ASSERT_PTR(event); \
UdevRuleToken *token_u = ASSERT_PTR(token); \
\
log_udev_rule_line_full( \
token_is_for_parents(token_u) ? event_u->dev_parent : event_u->dev, \
token_u->rule_line, \
level, error, "%s: " fmt, \
token_u->token_str, ##__VA_ARGS__); \
})
#define log_event_full_errno_zerook(event, token, ...) \
_log_event_full_errno_zerook(event, UNIQ_T(e, UNIQ), token, UNIQ_T(t, UNIQ), __VA_ARGS__)
#define _log_event_full_errno(event, token, level, error, error_u, ...) \
({ \
int error_u = (error); \
ASSERT_NON_ZERO(error_u); \
log_event_full_errno_zerook( \
event, token, level, error_u, \
__VA_ARGS__); \
})
#define log_event_full_errno(event, token, level, error, ...) \
_log_event_full_errno(event, token, level, error, UNIQ_T(e, UNIQ), __VA_ARGS__)
#define log_event_full(event, token, level, ...) (void) log_event_full_errno_zerook(event, token, level, 0, __VA_ARGS__)
#define log_event_debug(event, token, ...) log_event_full(event, token, LOG_DEBUG, __VA_ARGS__)
#define log_event_info(event, token, ...) log_event_full(event, token, LOG_INFO, __VA_ARGS__)
#define log_event_notice(event, token, ...) log_event_full(event, token, LOG_NOTICE, __VA_ARGS__)
#define log_event_warning(event, token, ...) log_event_full(event, token, LOG_WARNING, __VA_ARGS__)
#define log_event_error(event, token, ...) log_event_full(event, token, LOG_ERR, __VA_ARGS__)
#define log_event_debug_errno(event, token, error, ...) log_event_full_errno(event, token, LOG_DEBUG, error, __VA_ARGS__)
#define log_event_info_errno(event, token, error, ...) log_event_full_errno(event, token, LOG_INFO, error, __VA_ARGS__)
#define log_event_notice_errno(event, token, error, ...) log_event_full_errno(event, token, LOG_NOTICE, error, __VA_ARGS__)
#define log_event_warning_errno(event, token, error, ...) log_event_full_errno(event, token, LOG_WARNING, error, __VA_ARGS__)
#define log_event_error_errno(event, token, error, ...) log_event_full_errno(event, token, LOG_ERR, error, __VA_ARGS__)
#define _log_event_trace_errno(event, event_u, ...) \
({ \
UdevEvent *event_u = ASSERT_PTR(event); \
\
event_u->trace ? \
log_event_debug_errno(event_u, __VA_ARGS__) : \
(void) 0; \
})
#define log_event_trace_errno(event, ...) \
_log_event_trace_errno(event, UNIQ_T(e, UNIQ), __VA_ARGS__)
#define _log_event_trace(event, event_u, ...) \
({ \
UdevEvent *event_u = ASSERT_PTR(event); \
\
event_u->trace ? \
log_event_debug(event_u, __VA_ARGS__) : \
(void) 0; \
})
#define log_event_trace(event, ...) \
_log_event_trace(event, UNIQ_T(e, UNIQ), __VA_ARGS__)
#define _log_event_result(event, token, result, result_u) \
({ \
bool result_u = (result); \
\
log_event_trace(event, token, "%s", \
result_u ? "PASS" : "FAIL"); \
result_u; \
})
#define log_event_result(event, token, result) \
_log_event_result(event, token, result, UNIQ_T(r, UNIQ))
#define log_event_done(event, token) \
({ \
log_event_trace(event, token, "DONE"); \
true; \
})
#define _log_event_final_set(event, token, token_u) \
({ \
UdevRuleToken *token_u = ASSERT_PTR(token); \
\
log_event_trace(event, token_u, \
"Already assigned final value, ignoring further %s.", \
token_u->op == OP_REMOVE ? "modification" : "assignment"); \
true; \
})
#define log_event_final_set(event, token) \
_log_event_final_set(event, token, UNIQ_T(t, UNIQ))
#define _log_event_truncated(event, token, token_u, what, format) \
({ \
UdevRuleToken *token_u = ASSERT_PTR(token); \
\
token_u->type < _TK_M_MAX ? \
log_event_debug(event, token_u, \
"The %s is truncated while substituting into \"%s\", assuming the token fails.", \
what, (const char*) format) : \
log_event_warning( \
event, token_u, \
"The %s is truncated while substituting into \"%s\", refusing to apply the token.", \
what, (const char*) format); \
})
#define log_event_truncated(event, token, what, format) \
_log_event_truncated(event, token, UNIQ_T(t, UNIQ), what, format)
#define _log_event_line(event, event_u, line, ...) \
({ \
UdevEvent *event_u = ASSERT_PTR(event); \
\
event_u->trace ? \
log_udev_rule_line_full( \
event_u->dev, line, \
LOG_DEBUG, 0, __VA_ARGS__) : \
0; \
})
#define log_event_line(event, line, ...) \
_log_event_line(event, UNIQ_T(e, UNIQ), line, __VA_ARGS__)
/* Mainly used when parsing .rules files. */
#define log_file_full_errno_zerook(...) \
log_udev_rule_file_full(NULL, __VA_ARGS__)
#define log_file_error(file, line_nr, ...) \
log_file_full_errno_zerook(file, line_nr, LOG_ERR, 0, __VA_ARGS__)
#define log_line_full_errno_zerook(...) \
log_udev_rule_line_full(NULL, __VA_ARGS__)
#define log_line_full_errno(line, level, error, ...) \
log_udev_rule_line_full(NULL, line, level, error, __VA_ARGS__)
#define log_line_full(line, level, ...) (void) log_line_full_errno_zerook(line, level, 0, __VA_ARGS__)
#define log_line_debug(line, ...) log_line_full(line, LOG_DEBUG, __VA_ARGS__)
#define log_line_info(line, ...) log_line_full(line, LOG_INFO, __VA_ARGS__)
#define log_line_notice(line, ...) log_line_full(line, LOG_NOTICE, __VA_ARGS__)
#define log_line_warning(line, ...) log_line_full(line, LOG_WARNING, __VA_ARGS__)
#define log_line_error(line, ...) log_line_full(line, LOG_ERR, __VA_ARGS__)
#define log_line_debug_errno(line, error, ...) log_line_full_errno(line, LOG_DEBUG, error, __VA_ARGS__)
#define log_line_info_errno(line, error, ...) log_line_full_errno(line, LOG_INFO, error, __VA_ARGS__)
#define log_line_notice_errno(line, error, ...) log_line_full_errno(line, LOG_NOTICE, error, __VA_ARGS__)
#define log_line_warning_errno(line, error, ...) log_line_full_errno(line, LOG_WARNING, error, __VA_ARGS__)
#define log_line_error_errno(line, error, ...) log_line_full_errno(line, LOG_ERR, error, __VA_ARGS__)
#define _log_line_invalid_token(line, key, type) \
log_line_error_errno(line, SYNTHETIC_ERRNO(EINVAL), \
"Invalid %s for %s.", type, key)
#define log_line_invalid_op(line, key) _log_line_invalid_token(line, key, "operator")
#define log_line_invalid_attr(line, key) _log_line_invalid_token(line, key, "attribute")
#define log_line_invalid_prefix(line, key) _log_line_invalid_token(line, key, "prefix 'i'")
#define log_line_invalid_attr_format(line, key, attr, offset, hint) \
log_line_error_errno(line, SYNTHETIC_ERRNO(EINVAL), \
"Invalid attribute \"%s\" for %s (char %zu: %s), ignoring.", \
attr, key, offset, hint)
#define log_line_invalid_value(line, key, value, offset, hint) \
log_line_error_errno(line, SYNTHETIC_ERRNO(EINVAL), \
"Invalid value \"%s\" for %s (char %zu: %s), ignoring.", \
value, key, offset, hint)
/*** Other functions ***/
static UdevRuleToken* udev_rule_token_free(UdevRuleToken *token) {
if (!token)
return NULL;
if (token->rule_line)
LIST_REMOVE(tokens, token->rule_line->tokens, token);
return mfree(token);
}
DEFINE_TRIVIAL_CLEANUP_FUNC(UdevRuleToken*, udev_rule_token_free);
static void udev_rule_line_clear_tokens(UdevRuleLine *rule_line) {
assert(rule_line);
LIST_FOREACH(tokens, i, rule_line->tokens)
udev_rule_token_free(i);
}
static UdevRuleLine* udev_rule_line_free(UdevRuleLine *rule_line) {
if (!rule_line)
return NULL;
udev_rule_line_clear_tokens(rule_line);
if (rule_line->rule_file)
LIST_REMOVE(rule_lines, rule_line->rule_file->rule_lines, rule_line);
free(rule_line->line);
free(rule_line->line_for_logging);
return mfree(rule_line);
}
DEFINE_TRIVIAL_CLEANUP_FUNC(UdevRuleLine*, udev_rule_line_free);
static UdevRuleFile* udev_rule_file_free(UdevRuleFile *rule_file) {
if (!rule_file)
return NULL;
LIST_FOREACH(rule_lines, i, rule_file->rule_lines)
udev_rule_line_free(i);
if (rule_file->rules)
LIST_REMOVE(rule_files, rule_file->rules->rule_files, rule_file);
free(rule_file->filename);
return mfree(rule_file);
}
DEFINE_TRIVIAL_CLEANUP_FUNC(UdevRuleFile*, udev_rule_file_free);
UdevRules* udev_rules_free(UdevRules *rules) {
if (!rules)
return NULL;
LIST_FOREACH(rule_files, i, rules->rule_files)
udev_rule_file_free(i);
hashmap_free(rules->known_users);
hashmap_free(rules->known_groups);
hashmap_free(rules->stats_by_path);
return mfree(rules);
}
static int rule_resolve_user(UdevRuleLine *rule_line, const char *name, uid_t *ret) {
Hashmap **known_users = &LINE_GET_RULES(rule_line)->known_users;
int r;
assert(name);
assert(ret);
void *val = hashmap_get(*known_users, name);
if (val) {
*ret = PTR_TO_UID(val);
return 0;
}
_cleanup_(user_record_unrefp) UserRecord *ur = NULL;
r = userdb_by_name(name, /* match= */ NULL,
USERDB_SUPPRESS_SHADOW | USERDB_PARSE_NUMERIC | USERDB_SYNTHESIZE_NUMERIC,
&ur);
if (r < 0)
return log_line_error_errno(rule_line, r,
"Failed to resolve user '%s', ignoring: %s",
name, STRERROR_USER(r));
if (!uid_is_system(ur->uid))
log_struct(LOG_WARNING,
LOG_MESSAGE("%s:%u 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.",
rule_line->rule_file->filename, rule_line->line_number, name),
LOG_MESSAGE_ID(SD_MESSAGE_SYSTEM_ACCOUNT_REQUIRED_STR));
_cleanup_free_ char *n = strdup(name);
if (!n)
return log_oom();
r = hashmap_ensure_put(known_users, &string_hash_ops_free, n, UID_TO_PTR(ur->uid));
if (r < 0)
return log_oom();
TAKE_PTR(n);
*ret = ur->uid;
return 0;
}
static int rule_resolve_group(UdevRuleLine *rule_line, const char *name, gid_t *ret) {
Hashmap **known_groups = &LINE_GET_RULES(rule_line)->known_groups;
int r;
assert(name);
assert(ret);
void *val = hashmap_get(*known_groups, name);
if (val) {
*ret = PTR_TO_GID(val);
return 0;
}
_cleanup_(group_record_unrefp) GroupRecord *gr = NULL;
r = groupdb_by_name(name, /* match= */ NULL,
USERDB_SUPPRESS_SHADOW | USERDB_PARSE_NUMERIC | USERDB_SYNTHESIZE_NUMERIC,
&gr);
if (r < 0)
return log_line_error_errno(rule_line, r,
"Failed to resolve group '%s', ignoring: %s",
name, STRERROR_GROUP(r));
if (!gid_is_system(gr->gid))
log_struct(LOG_WARNING,
LOG_MESSAGE("%s:%u 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.",
rule_line->rule_file->filename, rule_line->line_number, name),
LOG_MESSAGE_ID(SD_MESSAGE_SYSTEM_ACCOUNT_REQUIRED_STR));
_cleanup_free_ char *n = strdup(name);
if (!n)
return log_oom();
r = hashmap_ensure_put(known_groups, &string_hash_ops_free, n, GID_TO_PTR(gr->gid));
if (r < 0)
return log_oom();
TAKE_PTR(n);
*ret = gr->gid;
return 0;
}
static UdevRuleSubstituteType rule_get_substitution_type(const char *str) {
assert(str);
if (str[0] == '[')
return SUBST_TYPE_SUBSYS;
if (strchr(str, '%') || strchr(str, '$'))
return SUBST_TYPE_FORMAT;
return SUBST_TYPE_PLAIN;
}
static bool type_has_nulstr_value(UdevRuleTokenType type) {
return type < TK_M_TEST || type == TK_M_RESULT;
}
static int rule_line_add_token(
UdevRuleLine *rule_line,
UdevRuleTokenType type,
UdevRuleOperatorType op,
char *value,
void *data,
bool is_case_insensitive,
const char *token_str) {
_cleanup_(udev_rule_token_freep) UdevRuleToken *token = NULL;
UdevRuleMatchType match_type = _MATCH_TYPE_INVALID;
UdevRuleSubstituteType subst_type = _SUBST_TYPE_INVALID;
assert(rule_line);
assert(type >= 0 && type < _TK_TYPE_MAX);
assert(op >= 0 && op < _OP_TYPE_MAX);
if (type < _TK_M_MAX) {
assert(value);
assert(IN_SET(op, OP_MATCH, OP_NOMATCH));
if (type == TK_M_SUBSYSTEM && STR_IN_SET(value, "subsystem", "bus", "class"))
match_type = MATCH_TYPE_SUBSYSTEM;
else if (isempty(value))
match_type = MATCH_TYPE_EMPTY;
else if (streq(value, "?*")) {
/* Convert KEY=="?*" -> KEY!="" */
match_type = MATCH_TYPE_EMPTY;
op = op == OP_MATCH ? OP_NOMATCH : OP_MATCH;
} else if (string_is_glob(value))
match_type = MATCH_TYPE_GLOB;
else
match_type = MATCH_TYPE_PLAIN;
if (type_has_nulstr_value(type)) {
/* Convert value string to nulstr. */
bool bar = true, empty = false;
char *a, *b;
for (a = b = value; *a != '\0'; a++) {
if (*a != '|') {
*b++ = *a;
bar = false;
} else {
if (bar)
empty = true;
else
*b++ = '\0';
bar = true;
}
}
*b = '\0';
/* Make sure the value is end, so NULSTR_FOREACH can read correct match */
if (b < a)
b[1] = '\0';
if (bar)
empty = true;
if (empty) {
if (match_type == MATCH_TYPE_GLOB)
match_type = MATCH_TYPE_GLOB_WITH_EMPTY;
if (match_type == MATCH_TYPE_PLAIN)
match_type = MATCH_TYPE_PLAIN_WITH_EMPTY;
}
}
}
if (IN_SET(type, TK_M_ATTR, TK_M_PARENTS_ATTR)) {
size_t len;
assert(value);
assert(data);
assert(match_type >= 0 && match_type < _MATCH_TYPE_MAX);
len = strlen(value);
if (len > 0 && !isspace(value[len - 1]))
match_type |= MATCH_REMOVE_TRAILING_WHITESPACE;
subst_type = rule_get_substitution_type(data);
}
SET_FLAG(match_type, MATCH_CASE_INSENSITIVE, is_case_insensitive);
token = new(UdevRuleToken, 1);
if (!token)
return -ENOMEM;
*token = (UdevRuleToken) {
.type = type,
.op = op,
.value = value,
.data = data,
.match_type = match_type,
.attr_subst_type = subst_type,
.token_str = token_str,
.rule_line = rule_line,
};
LIST_APPEND(tokens, rule_line->tokens, token);
if (token->type == TK_A_NAME)
SET_FLAG(rule_line->type, LINE_HAS_NAME, true);
else if (IN_SET(token->type, TK_A_DEVLINK,
TK_A_OWNER, TK_A_GROUP, TK_A_MODE,
TK_A_OWNER_ID, TK_A_GROUP_ID, TK_A_MODE_ID))
SET_FLAG(rule_line->type, LINE_HAS_DEVLINK, true);
else if (token->type == TK_A_OPTIONS_STATIC_NODE)
SET_FLAG(rule_line->type, LINE_HAS_STATIC_NODE, true);
else if (token->type >= _TK_A_MIN ||
IN_SET(token->type, TK_M_PROGRAM,
TK_M_IMPORT_FILE, TK_M_IMPORT_PROGRAM, TK_M_IMPORT_BUILTIN,
TK_M_IMPORT_DB, TK_M_IMPORT_CMDLINE, TK_M_IMPORT_PARENT))
SET_FLAG(rule_line->type, LINE_UPDATE_SOMETHING, true);
TAKE_PTR(token);
return 0;
}
static void check_value_format_and_warn(UdevRuleLine *line, const char *key, const char *value, bool nonempty) {
size_t offset;
const char *hint;
if (nonempty && isempty(value))
log_line_invalid_value(line, key, value, (size_t) 0, "empty value");
else if (udev_check_format(value, &offset, &hint) < 0)
log_line_invalid_value(line, key, value, offset + 1, hint);
}
static int check_attr_format_and_warn(UdevRuleLine *line, const char *key, const char *value) {
size_t offset;
const char *hint;
if (isempty(value))
return log_line_invalid_attr(line, key);
if (udev_check_format(value, &offset, &hint) < 0)
log_line_invalid_attr_format(line, key, value, offset + 1, hint);
return 0;
}
static int parse_token(
UdevRuleLine *rule_line,
const char *key,
char *attr,
UdevRuleOperatorType op,
char *value,
bool is_case_insensitive,
const char *token_str) {
ResolveNameTiming resolve_name_timing = LINE_GET_RULES(rule_line)->resolve_name_timing;
bool is_match = IN_SET(op, OP_MATCH, OP_NOMATCH);
int r;
assert(key);
assert(value);
if (!is_match && is_case_insensitive)
return log_line_error_errno(rule_line, SYNTHETIC_ERRNO(EINVAL),
"Invalid prefix 'i' for '%s'. The 'i' prefix can be specified only for '==' or '!=' operator.", key);
if (streq(key, "ACTION")) {
if (attr)
return log_line_invalid_attr(rule_line, key);
if (!is_match)
return log_line_invalid_op(rule_line, key);
r = rule_line_add_token(rule_line, TK_M_ACTION, op, value, NULL, is_case_insensitive, token_str);
} else if (streq(key, "DEVPATH")) {
if (attr)
return log_line_invalid_attr(rule_line, key);
if (!is_match)
return log_line_invalid_op(rule_line, key);
r = rule_line_add_token(rule_line, TK_M_DEVPATH, op, value, NULL, is_case_insensitive, token_str);
} else if (streq(key, "KERNEL")) {
if (attr)
return log_line_invalid_attr(rule_line, key);
if (!is_match)
return log_line_invalid_op(rule_line, key);
r = rule_line_add_token(rule_line, TK_M_KERNEL, op, value, NULL, is_case_insensitive, token_str);
} else if (streq(key, "SYMLINK")) {
if (attr)
return log_line_invalid_attr(rule_line, key);
if (!is_match) {
check_value_format_and_warn(rule_line, key, value, false);
r = rule_line_add_token(rule_line, TK_A_DEVLINK, op, value, NULL, /* is_case_insensitive= */ false, token_str);
} else
r = rule_line_add_token(rule_line, TK_M_DEVLINK, op, value, NULL, is_case_insensitive, token_str);
} else if (streq(key, "NAME")) {
if (attr)
return log_line_invalid_attr(rule_line, key);
if (op == OP_REMOVE)
return log_line_invalid_op(rule_line, key);
if (op == OP_ADD) {
log_line_warning(rule_line, "%s key takes '==', '!=', '=', or ':=' operator, assuming '='.", key);
op = OP_ASSIGN;
}
if (!is_match) {
if (streq(value, "%k"))
return log_line_error_errno(rule_line, SYNTHETIC_ERRNO(EINVAL),
"Ignoring NAME=\"%%k\", as it will take no effect.");
if (isempty(value))
return log_line_error_errno(rule_line, SYNTHETIC_ERRNO(EINVAL),
"Ignoring NAME=\"\", as udev will not delete any network interfaces.");
check_value_format_and_warn(rule_line, key, value, false);
r = rule_line_add_token(rule_line, TK_A_NAME, op, value, NULL, /* is_case_insensitive= */ false, token_str);
} else
r = rule_line_add_token(rule_line, TK_M_NAME, op, value, NULL, is_case_insensitive, token_str);
} else if (streq(key, "ENV")) {
if (isempty(attr))
return log_line_invalid_attr(rule_line, key);
if (op == OP_REMOVE)
return log_line_invalid_op(rule_line, key);
if (op == OP_ASSIGN_FINAL) {
log_line_warning(rule_line, "%s key takes '==', '!=', '=', or '+=' operator, assuming '='.", key);
op = OP_ASSIGN;
}
if (!is_match) {
if (!device_property_can_set(attr))
return log_line_error_errno(rule_line, SYNTHETIC_ERRNO(EINVAL),
"Invalid ENV attribute. '%s' cannot be set.", attr);
check_value_format_and_warn(rule_line, key, value, false);
r = rule_line_add_token(rule_line, TK_A_ENV, op, value, attr, /* is_case_insensitive= */ false, token_str);
} else
r = rule_line_add_token(rule_line, TK_M_ENV, op, value, attr, is_case_insensitive, token_str);
} else if (streq(key, "CONST")) {
if (isempty(attr) || !STR_IN_SET(attr, "arch", "virt", "cvm"))
return log_line_invalid_attr(rule_line, key);
if (!is_match)
return log_line_invalid_op(rule_line, key);
r = rule_line_add_token(rule_line, TK_M_CONST, op, value, attr, is_case_insensitive, token_str);
} else if (streq(key, "TAG")) {
if (attr)
return log_line_invalid_attr(rule_line, key);
if (op == OP_ASSIGN_FINAL) {
log_line_warning(rule_line, "%s key takes '==', '!=', '=', or '+=' operator, assuming '='.", key);
op = OP_ASSIGN;
}
if (!is_match) {
check_value_format_and_warn(rule_line, key, value, true);
r = rule_line_add_token(rule_line, TK_A_TAG, op, value, NULL, /* is_case_insensitive= */ false, token_str);
} else
r = rule_line_add_token(rule_line, TK_M_TAG, op, value, NULL, is_case_insensitive, token_str);
} else if (streq(key, "SUBSYSTEM")) {
if (attr)
return log_line_invalid_attr(rule_line, key);
if (!is_match)
return log_line_invalid_op(rule_line, key);
if (STR_IN_SET(value, "bus", "class"))
log_line_warning(rule_line, "\"%s\" must be specified as \"subsystem\".", value);
r = rule_line_add_token(rule_line, TK_M_SUBSYSTEM, op, value, NULL, is_case_insensitive, token_str);
} else if (streq(key, "DRIVER")) {
if (attr)
return log_line_invalid_attr(rule_line, key);
if (!is_match)
return log_line_invalid_op(rule_line, key);
r = rule_line_add_token(rule_line, TK_M_DRIVER, op, value, NULL, is_case_insensitive, token_str);
} else if (streq(key, "ATTR")) {
r = check_attr_format_and_warn(rule_line, key, attr);
if (r < 0)
return r;
if (op == OP_REMOVE)
return log_line_invalid_op(rule_line, key);
if (IN_SET(op, OP_ADD, OP_ASSIGN_FINAL)) {
log_line_warning(rule_line, "%s key takes '==', '!=', or '=' operator, assuming '='.", key);
op = OP_ASSIGN;
}
if (!is_match) {
check_value_format_and_warn(rule_line, key, value, false);
r = rule_line_add_token(rule_line, TK_A_ATTR, op, value, attr, /* is_case_insensitive= */ false, token_str);
} else
r = rule_line_add_token(rule_line, TK_M_ATTR, op, value, attr, is_case_insensitive, token_str);
} else if (streq(key, "SYSCTL")) {
r = check_attr_format_and_warn(rule_line, key, attr);
if (r < 0)
return r;
if (op == OP_REMOVE)
return log_line_invalid_op(rule_line, key);
if (IN_SET(op, OP_ADD, OP_ASSIGN_FINAL)) {
log_line_warning(rule_line, "%s key takes '==', '!=', or '=' operator, assuming '='.", key);
op = OP_ASSIGN;
}
if (!is_match) {
check_value_format_and_warn(rule_line, key, value, false);
r = rule_line_add_token(rule_line, TK_A_SYSCTL, op, value, attr, /* is_case_insensitive= */ false, token_str);
} else
r = rule_line_add_token(rule_line, TK_M_SYSCTL, op, value, attr, is_case_insensitive, token_str);
} else if (streq(key, "KERNELS")) {
if (attr)
return log_line_invalid_attr(rule_line, key);
if (!is_match)
return log_line_invalid_op(rule_line, key);
r = rule_line_add_token(rule_line, TK_M_PARENTS_KERNEL, op, value, NULL, is_case_insensitive, token_str);
} else if (streq(key, "SUBSYSTEMS")) {
if (attr)
return log_line_invalid_attr(rule_line, key);
if (!is_match)
return log_line_invalid_op(rule_line, key);
r = rule_line_add_token(rule_line, TK_M_PARENTS_SUBSYSTEM, op, value, NULL, is_case_insensitive, token_str);
} else if (streq(key, "DRIVERS")) {
if (attr)
return log_line_invalid_attr(rule_line, key);
if (!is_match)
return log_line_invalid_op(rule_line, key);
r = rule_line_add_token(rule_line, TK_M_PARENTS_DRIVER, op, value, NULL, is_case_insensitive, token_str);
} else if (streq(key, "ATTRS")) {
r = check_attr_format_and_warn(rule_line, key, attr);
if (r < 0)
return r;
if (!is_match)
return log_line_invalid_op(rule_line, key);
if (startswith(attr, "device/"))
log_line_warning(rule_line, "'device' link may not be available in future kernels.");
if (strstr(attr, "../"))
log_line_warning(rule_line, "Direct reference to parent sysfs directory, may break in future kernels.");
r = rule_line_add_token(rule_line, TK_M_PARENTS_ATTR, op, value, attr, is_case_insensitive, token_str);
} else if (streq(key, "TAGS")) {
if (attr)
return log_line_invalid_attr(rule_line, key);
if (!is_match)
return log_line_invalid_op(rule_line, key);
r = rule_line_add_token(rule_line, TK_M_PARENTS_TAG, op, value, NULL, is_case_insensitive, token_str);
} else if (streq(key, "TEST")) {
mode_t mode = MODE_INVALID;
if (!isempty(attr)) {
r = parse_mode(attr, &mode);
if (r < 0)
return log_line_error_errno(rule_line, r, "Failed to parse mode '%s': %m", attr);
}
check_value_format_and_warn(rule_line, key, value, true);
if (!is_match)
return log_line_invalid_op(rule_line, key);
if (is_case_insensitive)
return log_line_invalid_prefix(rule_line, key);
r = rule_line_add_token(rule_line, TK_M_TEST, op, value, MODE_TO_PTR(mode), is_case_insensitive, token_str);
} else if (streq(key, "PROGRAM")) {
if (attr)
return log_line_invalid_attr(rule_line, key);
check_value_format_and_warn(rule_line, key, value, true);
if (op == OP_REMOVE)
return log_line_invalid_op(rule_line, key);
if (!is_match)
op = OP_MATCH;
if (is_case_insensitive)
return log_line_invalid_prefix(rule_line, key);
r = rule_line_add_token(rule_line, TK_M_PROGRAM, op, value, NULL, /* is_case_insensitive= */ false, token_str);
} else if (streq(key, "IMPORT")) {
if (isempty(attr))
return log_line_invalid_attr(rule_line, key);
check_value_format_and_warn(rule_line, key, value, true);
if (op == OP_REMOVE)
return log_line_invalid_op(rule_line, key);
if (!is_match)
op = OP_MATCH;
if (is_case_insensitive)
return log_line_invalid_prefix(rule_line, key);
if (streq(attr, "file"))
r = rule_line_add_token(rule_line, TK_M_IMPORT_FILE, op, value, NULL, /* is_case_insensitive= */ false, token_str);