HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/udev/udev-rules.c
Git blob: c7443a98981e096d10358ad4f663909ffd0ee64a
Lines 1001–2000 of 3,362
else if (streq(attr, "program")) {
UdevBuiltinCommand cmd;
cmd = udev_builtin_lookup(value);
if (cmd >= 0) {
log_line_debug(rule_line, "Found builtin command '%s' for %s, replacing attribute.", value, key);
r = rule_line_add_token(rule_line, TK_M_IMPORT_BUILTIN, op, value, UDEV_BUILTIN_CMD_TO_PTR(cmd), /* is_case_insensitive= */ false, token_str);
} else
r = rule_line_add_token(rule_line, TK_M_IMPORT_PROGRAM, op, value, NULL, /* is_case_insensitive= */ false, token_str);
} else if (streq(attr, "builtin")) {
UdevBuiltinCommand cmd;
cmd = udev_builtin_lookup(value);
if (cmd < 0)
return log_line_error_errno(rule_line, SYNTHETIC_ERRNO(EINVAL),
"Unknown builtin command: %s", value);
r = rule_line_add_token(rule_line, TK_M_IMPORT_BUILTIN, op, value, UDEV_BUILTIN_CMD_TO_PTR(cmd), /* is_case_insensitive= */ false, token_str);
} else if (streq(attr, "db"))
r = rule_line_add_token(rule_line, TK_M_IMPORT_DB, op, value, NULL, /* is_case_insensitive= */ false, token_str);
else if (streq(attr, "cmdline"))
r = rule_line_add_token(rule_line, TK_M_IMPORT_CMDLINE, op, value, NULL, /* is_case_insensitive= */ false, token_str);
else if (streq(attr, "parent"))
r = rule_line_add_token(rule_line, TK_M_IMPORT_PARENT, op, value, NULL, /* is_case_insensitive= */ false, token_str);
else
return log_line_invalid_attr(rule_line, key);
} else if (streq(key, "RESULT")) {
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_RESULT, op, value, NULL, is_case_insensitive, token_str);
} else if (streq(key, "OPTIONS")) {
char *tmp;
if (attr)
return log_line_invalid_attr(rule_line, key);
if (is_match || op == OP_REMOVE)
return log_line_invalid_op(rule_line, key);
if (op == OP_ADD)
op = OP_ASSIGN;
if (streq(value, "dump"))
r = rule_line_add_token(rule_line, TK_A_OPTIONS_DUMP, op, NULL, UINT_TO_PTR(SD_JSON_FORMAT_OFF), /* is_case_insensitive= */ false, token_str);
else if (streq(value, "dump-json"))
r = rule_line_add_token(rule_line, TK_A_OPTIONS_DUMP, op, NULL, UINT_TO_PTR(SD_JSON_FORMAT_NEWLINE), /* is_case_insensitive= */ false, token_str);
else if (streq(value, "string_escape=none"))
r = rule_line_add_token(rule_line, TK_A_OPTIONS_STRING_ESCAPE_NONE, op, NULL, NULL, /* is_case_insensitive= */ false, token_str);
else if (streq(value, "string_escape=replace"))
r = rule_line_add_token(rule_line, TK_A_OPTIONS_STRING_ESCAPE_REPLACE, op, NULL, NULL, /* is_case_insensitive= */ false, token_str);
else if (streq(value, "db_persist"))
r = rule_line_add_token(rule_line, TK_A_OPTIONS_DB_PERSIST, op, NULL, NULL, /* is_case_insensitive= */ false, token_str);
else if (streq(value, "watch"))
r = rule_line_add_token(rule_line, TK_A_OPTIONS_INOTIFY_WATCH, op, NULL, INT_TO_PTR(1), /* is_case_insensitive= */ false, token_str);
else if (streq(value, "nowatch"))
r = rule_line_add_token(rule_line, TK_A_OPTIONS_INOTIFY_WATCH, op, NULL, INT_TO_PTR(0), /* is_case_insensitive= */ false, token_str);
else if ((tmp = startswith(value, "static_node=")))
r = rule_line_add_token(rule_line, TK_A_OPTIONS_STATIC_NODE, op, tmp, NULL, /* is_case_insensitive= */ false, token_str);
else if ((tmp = startswith(value, "link_priority="))) {
int prio;
r = safe_atoi(tmp, &prio);
if (r < 0)
return log_line_error_errno(rule_line, r, "Failed to parse link priority '%s': %m", tmp);
r = rule_line_add_token(rule_line, TK_A_OPTIONS_DEVLINK_PRIORITY, op, NULL, INT_TO_PTR(prio), /* is_case_insensitive= */ false, token_str);
} else if ((tmp = startswith(value, "log_level="))) {
int level;
if (streq(tmp, "reset"))
level = -1;
else {
level = log_level_from_string(tmp);
if (level < 0)
return log_line_error_errno(rule_line, level, "Failed to parse log level '%s': %m", tmp);
}
r = rule_line_add_token(rule_line, TK_A_OPTIONS_LOG_LEVEL, op, NULL, INT_TO_PTR(level), /* is_case_insensitive= */ false, token_str);
} else {
log_line_warning(rule_line, "Invalid value for OPTIONS key, ignoring: '%s'", value);
return 0;
}
} else if (streq(key, "OWNER")) {
if (attr)
return log_line_invalid_attr(rule_line, key);
if (is_match || 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 (in_charset(value, DIGITS) ||
(resolve_name_timing == RESOLVE_NAME_EARLY &&
rule_get_substitution_type(value) == SUBST_TYPE_PLAIN)) {
uid_t uid = UID_INVALID; /* avoid false maybe-uninitialized warning */
r = rule_resolve_user(rule_line, value, &uid);
if (r < 0)
return r;
assert(uid_is_valid(uid));
r = rule_line_add_token(rule_line, TK_A_OWNER_ID, op, NULL, UID_TO_PTR(uid), /* is_case_insensitive= */ false, token_str);
} else if (resolve_name_timing != RESOLVE_NAME_NEVER) {
check_value_format_and_warn(rule_line, key, value, true);
r = rule_line_add_token(rule_line, TK_A_OWNER, op, value, NULL, /* is_case_insensitive= */ false, token_str);
} else {
log_line_debug(rule_line, "User name resolution is disabled, ignoring %s=\"%s\".", key, value);
return 0;
}
} else if (streq(key, "GROUP")) {
if (attr)
return log_line_invalid_attr(rule_line, key);
if (is_match || 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 (in_charset(value, DIGITS) ||
(resolve_name_timing == RESOLVE_NAME_EARLY &&
rule_get_substitution_type(value) == SUBST_TYPE_PLAIN)) {
gid_t gid = GID_INVALID; /* avoid false maybe-uninitialized warning */
r = rule_resolve_group(rule_line, value, &gid);
if (r < 0)
return r;
assert(gid_is_valid(gid));
r = rule_line_add_token(rule_line, TK_A_GROUP_ID, op, NULL, GID_TO_PTR(gid), /* is_case_insensitive= */ false, token_str);
} else if (resolve_name_timing != RESOLVE_NAME_NEVER) {
check_value_format_and_warn(rule_line, key, value, true);
r = rule_line_add_token(rule_line, TK_A_GROUP, op, value, NULL, /* is_case_insensitive= */ false, token_str);
} else {
log_line_debug(rule_line, "Resolving group name is disabled, ignoring GROUP=\"%s\".", value);
return 0;
}
} else if (streq(key, "MODE")) {
mode_t mode;
if (attr)
return log_line_invalid_attr(rule_line, key);
if (is_match || 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 (parse_mode(value, &mode) >= 0)
r = rule_line_add_token(rule_line, TK_A_MODE_ID, op, NULL, MODE_TO_PTR(mode), /* is_case_insensitive= */ false, token_str);
else {
check_value_format_and_warn(rule_line, key, value, true);
r = rule_line_add_token(rule_line, TK_A_MODE, op, value, NULL, /* is_case_insensitive= */ false, token_str);
}
} else if (streq(key, "SECLABEL")) {
if (isempty(attr))
return log_line_invalid_attr(rule_line, key);
check_value_format_and_warn(rule_line, key, value, true);
if (is_match || 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;
}
r = rule_line_add_token(rule_line, TK_A_SECLABEL, op, value, attr, /* is_case_insensitive= */ false, token_str);
} else if (streq(key, "RUN")) {
if (is_match || op == OP_REMOVE)
return log_line_invalid_op(rule_line, key);
check_value_format_and_warn(rule_line, key, value, true);
if (!attr || streq(attr, "program"))
r = rule_line_add_token(rule_line, TK_A_RUN_PROGRAM, op, value, NULL, /* is_case_insensitive= */ false, token_str);
else if (streq(attr, "builtin")) {
UdevBuiltinCommand cmd;
cmd = udev_builtin_lookup(value);
if (cmd < 0)
return log_line_error_errno(rule_line, SYNTHETIC_ERRNO(EINVAL),
"Unknown builtin command '%s', ignoring.", value);
r = rule_line_add_token(rule_line, TK_A_RUN_BUILTIN, op, value, UDEV_BUILTIN_CMD_TO_PTR(cmd), /* is_case_insensitive= */ false, token_str);
} else
return log_line_invalid_attr(rule_line, key);
} else if (streq(key, "GOTO")) {
if (attr)
return log_line_invalid_attr(rule_line, key);
if (op != OP_ASSIGN)
return log_line_invalid_op(rule_line, key);
if (FLAGS_SET(rule_line->type, LINE_HAS_GOTO)) {
log_line_warning(rule_line, "Contains multiple GOTO keys, ignoring GOTO=\"%s\".", value);
return 0;
}
rule_line->goto_label = value;
SET_FLAG(rule_line->type, LINE_HAS_GOTO, true);
return 1;
} else if (streq(key, "LABEL")) {
if (attr)
return log_line_invalid_attr(rule_line, key);
if (op != OP_ASSIGN)
return log_line_invalid_op(rule_line, key);
if (FLAGS_SET(rule_line->type, LINE_HAS_LABEL))
log_line_warning(rule_line, "Contains multiple LABEL keys, ignoring LABEL=\"%s\".",
rule_line->label);
rule_line->label = value;
SET_FLAG(rule_line->type, LINE_HAS_LABEL, true);
return 1;
} else
return log_line_error_errno(rule_line, SYNTHETIC_ERRNO(EINVAL), "Invalid key '%s'.", key);
if (r < 0)
return log_oom();
return 1;
}
static UdevRuleOperatorType parse_operator(const char *op) {
assert(op);
if (startswith(op, "=="))
return OP_MATCH;
if (startswith(op, "!="))
return OP_NOMATCH;
if (startswith(op, "+="))
return OP_ADD;
if (startswith(op, "-="))
return OP_REMOVE;
if (startswith(op, "="))
return OP_ASSIGN;
if (startswith(op, ":="))
return OP_ASSIGN_FINAL;
return _OP_TYPE_INVALID;
}
static void check_token_delimiters(UdevRuleLine *rule_line, const char *line) {
assert(rule_line);
size_t n_comma = 0;
bool ws_before_comma = false, ws_after_comma = false;
const char *p;
for (p = line; !isempty(p); ++p) {
if (*p == ',')
++n_comma;
else if (strchr(WHITESPACE, *p)) {
if (n_comma > 0)
ws_after_comma = true;
else
ws_before_comma = true;
} else
break;
}
if (line == rule_line->line) {
/* this is the first token of the rule */
if (n_comma > 0)
log_line_notice(rule_line, "style: stray leading comma.");
} else if (isempty(p)) {
/* there are no more tokens in the rule */
if (n_comma > 0)
log_line_notice(rule_line, "style: stray trailing comma.");
} else {
/* single comma is expected */
if (n_comma == 0)
log_line_notice(rule_line, "style: a comma between tokens is expected.");
else if (n_comma > 1)
log_line_notice(rule_line, "style: more than one comma between tokens.");
/* whitespace after comma is expected */
if (n_comma > 0) {
if (ws_before_comma)
log_line_notice(rule_line, "style: stray whitespace before comma.");
if (!ws_after_comma)
log_line_notice(rule_line, "style: whitespace after comma is expected.");
} else if (!ws_before_comma && !ws_after_comma)
log_line_notice(rule_line, "style: whitespace between tokens is expected.");
}
}
int udev_rule_parse_value(char *str, char **ret_value, char **ret_endpos, bool *ret_is_case_insensitive) {
char *i, *j;
bool is_escaped = false, is_case_insensitive = false;
assert(str);
assert(ret_value);
assert(ret_endpos);
assert(ret_is_case_insensitive);
/* check if string is prefixed with:
* - "e" for escaped
* - "i" for case insensitive match
*
* Note both e and i can be set but do not allow duplicates ("eei", "eii"). */
for (const char *k = str; *k != '"' && k < str + 2; k++)
if (*k == 'e' && !is_escaped)
is_escaped = true;
else if (*k == 'i' && !is_case_insensitive)
is_case_insensitive = true;
else
return -EINVAL;
/* value must be double quotated */
str += is_escaped + is_case_insensitive;
if (str[0] != '"')
return -EINVAL;
if (!is_escaped) {
/* unescape double quotation '\"'->'"' */
for (j = str, i = str + 1; *i != '"'; i++, j++) {
if (*i == '\0')
return -EINVAL;
if (i[0] == '\\' && i[1] == '"')
i++;
*j = *i;
}
j[0] = '\0';
/*
* The return value must be terminated by two subsequent NULs
* so it could be safely interpreted as nulstr.
*/
j[1] = '\0';
} else {
_cleanup_free_ char *unescaped = NULL;
ssize_t l;
/* find the end position of value */
for (i = str + 1; *i != '"'; i++) {
if (i[0] == '\\')
i++;
if (*i == '\0')
return -EINVAL;
}
i[0] = '\0';
l = cunescape_length(str + 1, i - (str + 1), 0, &unescaped);
if (l < 0)
return l;
assert(l <= i - (str + 1));
memcpy(str, unescaped, l + 1);
/*
* The return value must be terminated by two subsequent NULs
* so it could be safely interpreted as nulstr.
*/
str[l + 1] = '\0';
}
*ret_value = str;
*ret_endpos = i + 1;
*ret_is_case_insensitive = is_case_insensitive;
return 0;
}
static int parse_line(char **line, char **ret_key, char **ret_attr, UdevRuleOperatorType *ret_op, char **ret_value, bool *ret_is_case_insensitive) {
char *key_begin, *key_end, *attr, *tmp;
UdevRuleOperatorType op;
int r;
assert(line);
assert(*line);
assert(ret_key);
assert(ret_attr);
assert(ret_op);
assert(ret_value);
assert(ret_is_case_insensitive);
key_begin = skip_leading_chars(*line, WHITESPACE ",");
if (isempty(key_begin))
return 0;
for (key_end = key_begin; ; key_end++) {
if (key_end[0] == '\0')
return -EINVAL;
if (strchr(WHITESPACE "={", key_end[0]))
break;
if (strchr("+-!:", key_end[0]) && key_end[1] == '=')
break;
}
if (key_end[0] == '{') {
attr = key_end + 1;
tmp = strchr(attr, '}');
if (!tmp)
return -EINVAL;
*tmp++ = '\0';
} else {
attr = NULL;
tmp = key_end;
}
tmp = skip_leading_chars(tmp, NULL);
op = parse_operator(tmp);
if (op < 0)
return -EINVAL;
key_end[0] = '\0';
tmp += op == OP_ASSIGN ? 1 : 2;
tmp = skip_leading_chars(tmp, NULL);
r = udev_rule_parse_value(tmp, ret_value, line, ret_is_case_insensitive);
if (r < 0)
return r;
*ret_key = key_begin;
*ret_attr = attr;
*ret_op = op;
return 1;
}
static void check_tokens_order(UdevRuleLine *rule_line) {
bool has_result = false;
assert(rule_line);
LIST_FOREACH(tokens, t, rule_line->tokens)
if (t->type == TK_M_RESULT)
has_result = true;
else if (has_result && t->type == TK_M_PROGRAM) {
log_line_warning(rule_line, "Reordering RESULT check after PROGRAM assignment.");
break;
}
}
static void sort_tokens(UdevRuleLine *rule_line) {
assert(rule_line);
UdevRuleToken *old_tokens = TAKE_PTR(rule_line->tokens);
while (old_tokens) {
UdevRuleToken *min_token = NULL;
LIST_FOREACH(tokens, t, old_tokens)
if (!min_token || min_token->type > t->type)
min_token = t;
LIST_REMOVE(tokens, old_tokens, min_token);
LIST_APPEND(tokens, rule_line->tokens, min_token);
}
}
static int rule_add_line(UdevRuleFile *rule_file, const char *line, unsigned line_nr, bool extra_checks) {
_cleanup_(udev_rule_line_freep) UdevRuleLine *rule_line = NULL;
char *p;
int r;
assert(rule_file);
assert(line);
if (isempty(line))
return 0;
rule_line = new(UdevRuleLine, 1);
if (!rule_line)
return log_oom();
*rule_line = (UdevRuleLine) {
.line = strdup(line),
.line_for_logging = strdup(line),
.line_number = line_nr,
};
if (!rule_line->line || !rule_line->line_for_logging)
return log_oom();
rule_line->rule_file = rule_file;
LIST_APPEND(rule_lines, rule_file->rule_lines, rule_line);
for (p = rule_line->line; !isempty(p); ) {
char *key, *attr, *value;
UdevRuleOperatorType op;
bool is_case_insensitive;
if (extra_checks)
check_token_delimiters(rule_line, p);
r = parse_line(&p, &key, &attr, &op, &value, &is_case_insensitive);
if (r < 0)
return log_line_error_errno(rule_line, r, "Invalid key/value pair, ignoring.");
if (r == 0)
break;
char *token_str = rule_line->line_for_logging + (key - rule_line->line);
token_str[p - key] = '\0';
r = parse_token(rule_line, key, attr, op, value, is_case_insensitive, token_str);
if (r < 0)
return r;
}
if (rule_line->type == 0) {
log_line_warning(rule_line, "The line has no effect, ignoring.");
return 0;
}
if (extra_checks)
check_tokens_order(rule_line);
sort_tokens(rule_line);
TAKE_PTR(rule_line);
return 0;
}
static void rule_resolve_goto(UdevRuleFile *rule_file) {
assert(rule_file);
/* link GOTOs to LABEL rules in this file to be able to fast-forward */
LIST_FOREACH(rule_lines, line, rule_file->rule_lines) {
if (!FLAGS_SET(line->type, LINE_HAS_GOTO))
continue;
LIST_FOREACH(rule_lines, i, line->rule_lines_next)
if (streq_ptr(i->label, line->goto_label)) {
line->goto_line = i;
SET_FLAG(i->type, LINE_IS_REFERENCED, true);
break;
}
if (!line->goto_line) {
log_line_error(line, "GOTO=\"%s\" has no matching label, ignoring.",
line->goto_label);
SET_FLAG(line->type, LINE_HAS_GOTO, false);
line->goto_label = NULL;
if ((line->type & ~(LINE_HAS_LABEL|LINE_IS_REFERENCED)) == 0) {
log_line_warning(line, "The line has no effect any more, dropping.");
/* LINE_IS_REFERENCED implies LINE_HAS_LABEL */
if (line->type & LINE_HAS_LABEL)
udev_rule_line_clear_tokens(line);
else
udev_rule_line_free(line);
}
}
}
}
static bool token_data_is_string(UdevRuleTokenType type) {
return IN_SET(type, TK_M_ENV,
TK_M_CONST,
TK_M_ATTR,
TK_M_SYSCTL,
TK_M_PARENTS_ATTR,
TK_A_SECLABEL,
TK_A_ENV,
TK_A_ATTR,
TK_A_SYSCTL);
}
static bool token_type_and_data_eq(const UdevRuleToken *a, const UdevRuleToken *b) {
assert(a);
assert(b);
return a->type == b->type &&
(token_data_is_string(a->type) ? streq_ptr(a->data, b->data) : (a->data == b->data));
}
static bool nulstr_eq(const char *a, const char *b) {
NULSTR_FOREACH(i, a)
if (!nulstr_contains(b, i))
return false;
NULSTR_FOREACH(i, b)
if (!nulstr_contains(a, i))
return false;
return true;
}
static bool token_type_and_value_eq(const UdevRuleToken *a, const UdevRuleToken *b) {
assert(a);
assert(b);
if (a->type != b->type ||
a->match_type != b->match_type)
return false;
/* token value is ignored for certain match types */
if (IN_SET(a->match_type, MATCH_TYPE_EMPTY, MATCH_TYPE_SUBSYSTEM))
return true;
return type_has_nulstr_value(a->type) ? nulstr_eq(a->value, b->value) :
streq_ptr(a->value, b->value);
}
static bool conflicting_op(UdevRuleOperatorType a, UdevRuleOperatorType b) {
return (a == OP_MATCH && b == OP_NOMATCH) ||
(a == OP_NOMATCH && b == OP_MATCH);
}
/* test whether all fields besides UdevRuleOperatorType of two tokens match */
static bool tokens_eq(const UdevRuleToken *a, const UdevRuleToken *b) {
assert(a);
assert(b);
return a->attr_subst_type == b->attr_subst_type &&
token_type_and_value_eq(a, b) &&
token_type_and_data_eq(a, b);
}
static bool nulstr_tokens_conflict(const UdevRuleToken *a, const UdevRuleToken *b) {
assert(a);
assert(b);
if (!(a->type == b->type &&
type_has_nulstr_value(a->type) &&
a->op == b->op &&
a->op == OP_MATCH &&
a->match_type == b->match_type &&
a->attr_subst_type == b->attr_subst_type &&
token_type_and_data_eq(a, b)))
return false;
if (a->match_type == MATCH_TYPE_PLAIN) {
NULSTR_FOREACH(i, a->value)
if (nulstr_contains(b->value, i))
return false;
return true;
}
if (a->match_type == MATCH_TYPE_GLOB) {
NULSTR_FOREACH(i, a->value) {
size_t i_n = strcspn(i, GLOB_CHARS);
if (i_n == 0)
return false;
NULSTR_FOREACH(j, b->value) {
size_t j_n = strcspn(j, GLOB_CHARS);
if (j_n == 0 || strneq(i, j, MIN(i_n, j_n)))
return false;
}
}
return true;
}
return false;
}
static void udev_check_unused_labels(UdevRuleLine *line) {
assert(line);
if (FLAGS_SET(line->type, LINE_HAS_LABEL) &&
!FLAGS_SET(line->type, LINE_IS_REFERENCED))
log_line_notice(line, "style: LABEL=\"%s\" is unused.", line->label);
}
static void udev_check_conflicts_duplicates(UdevRuleLine *line) {
assert(line);
bool conflicts = false, duplicates = false;
LIST_FOREACH(tokens, token, line->tokens)
LIST_FOREACH(tokens, i, token->tokens_next) {
bool new_conflicts = false, new_duplicates = false;
if (tokens_eq(token, i)) {
if (!duplicates && token->op == i->op)
new_duplicates = true;
if (!conflicts && conflicting_op(token->op, i->op))
new_conflicts = true;
} else if (!conflicts && nulstr_tokens_conflict(token, i))
new_conflicts = true;
else
continue;
if (new_duplicates) {
duplicates = new_duplicates;
log_line_warning(line, "duplicate expressions.");
}
if (new_conflicts) {
conflicts = new_conflicts;
log_line_error(line, "conflicting match expressions, the line has no effect.");
}
if (conflicts && duplicates)
return;
}
}
static void udev_check_rule_line(UdevRuleLine *line) {
udev_check_unused_labels(line);
udev_check_conflicts_duplicates(line);
}
int udev_rules_parse_file(UdevRules *rules, const ConfFile *c, bool extra_checks, UdevRuleFile **ret) {
_cleanup_(udev_rule_file_freep) UdevRuleFile *rule_file = NULL;
_cleanup_free_ char *name = NULL;
_cleanup_fclose_ FILE *f = NULL;
int r;
assert(rules);
assert(c);
assert(c->fd >= 0);
assert(c->original_path);
f = fopen(FORMAT_PROC_FD_PATH(c->fd), "re");
if (!f) {
if (extra_checks)
return -errno;
return log_warning_errno(errno, "Failed to open %s, ignoring: %m", c->original_path);
}
r = hashmap_put_stats_by_path(&rules->stats_by_path, c->original_path, &c->st);
if (r < 0)
return log_warning_errno(r, "Failed to save stat for %s, ignoring: %m", c->original_path);
(void) stat_warn_permissions(c->original_path, &c->st);
log_debug("Reading rules file: %s", c->original_path);
name = strdup(c->original_path);
if (!name)
return log_oom();
rule_file = new(UdevRuleFile, 1);
if (!rule_file)
return log_oom();
*rule_file = (UdevRuleFile) {
.filename = TAKE_PTR(name),
.rules = rules,
};
LIST_APPEND(rule_files, rules->rule_files, rule_file);
_cleanup_free_ char *continuation = NULL;
unsigned line_nr = 0, current_line_nr = 0;
bool ignore_line = false;
for (;;) {
_cleanup_free_ char *buf = NULL;
size_t len;
char *line;
r = read_line(f, UDEV_LINE_SIZE, &buf);
if (r < 0)
return r;
if (r == 0)
break;
current_line_nr++;
if (!continuation)
line_nr = current_line_nr;
line = skip_leading_chars(buf, NULL);
/* Lines beginning with '#' are ignored regardless of line continuation. */
if (line[0] == '#')
continue;
len = strlen(line);
if (continuation && !ignore_line) {
if (strlen(continuation) + len >= UDEV_LINE_SIZE)
ignore_line = true;
if (!strextend(&continuation, line))
return log_oom();
if (!ignore_line) {
line = continuation;
len = strlen(line);
}
}
if (len > 0 && line[len - 1] == '\\') {
if (ignore_line)
continue;
line[len - 1] = '\0';
if (!continuation) {
continuation = strdup(line);
if (!continuation)
return log_oom();
}
continue;
}
if (ignore_line)
log_file_error(rule_file, line_nr, "Line is too long, ignored.");
else if (len > 0)
(void) rule_add_line(rule_file, line, line_nr, extra_checks);
continuation = mfree(continuation);
ignore_line = false;
}
if (continuation)
log_file_error(rule_file, line_nr,
"Unexpected EOF after line continuation, line ignored.");
rule_resolve_goto(rule_file);
if (extra_checks)
LIST_FOREACH(rule_lines, line, rule_file->rule_lines)
udev_check_rule_line(line);
if (ret)
*ret = rule_file;
TAKE_PTR(rule_file);
return 0;
}
unsigned udev_rule_file_get_issues(UdevRuleFile *rule_file) {
assert(rule_file);
return rule_file->issues;
}
UdevRules* udev_rules_new(ResolveNameTiming resolve_name_timing) {
assert(resolve_name_timing >= 0 && resolve_name_timing < _RESOLVE_NAME_TIMING_MAX);
UdevRules *rules = new(UdevRules, 1);
if (!rules)
return NULL;
*rules = (UdevRules) {
.resolve_name_timing = resolve_name_timing,
};
return rules;
}
int udev_rules_load(UdevRules **ret_rules, ResolveNameTiming resolve_name_timing, char * const *extra) {
_cleanup_(udev_rules_freep) UdevRules *rules = NULL;
_cleanup_strv_free_ char **directories = NULL;
int r;
assert(ret_rules);
rules = udev_rules_new(resolve_name_timing);
if (!rules)
return -ENOMEM;
if (!strv_isempty(extra)) {
directories = strv_copy(extra);
if (!directories)
return -ENOMEM;
}
r = strv_extend_strv(&directories, CONF_PATHS_STRV("udev/rules.d"), /* filter_duplicates= */ false);
if (r < 0)
return r;
ConfFile **files = NULL;
size_t n_files = 0;
CLEANUP_ARRAY(files, n_files, conf_file_free_array);
r = conf_files_list_strv_full(".rules", /* root= */ NULL, CONF_FILES_REGULAR | CONF_FILES_FILTER_MASKED,
(const char* const*) directories, &files, &n_files);
if (r < 0)
return log_debug_errno(r, "Failed to enumerate rules files: %m");
FOREACH_ARRAY(i, files, n_files) {
ConfFile *c = *i;
r = udev_rules_parse_file(rules, c, /* extra_checks= */ false, /* ret= */ NULL);
if (r < 0)
log_debug_errno(r, "Failed to read rules file '%s', ignoring: %m", c->original_path);
}
*ret_rules = TAKE_PTR(rules);
return 0;
}
bool udev_rules_should_reload(UdevRules *rules) {
_cleanup_hashmap_free_ Hashmap *stats_by_path = NULL;
int r;
if (!rules)
return true;
r = config_get_stats_by_path(".rules", NULL, 0, RULES_DIRS, /* check_dropins= */ false, &stats_by_path);
if (r < 0) {
log_warning_errno(r, "Failed to get stats of udev rules, ignoring: %m");
return true;
}
if (!stats_by_path_equal(rules->stats_by_path, stats_by_path)) {
log_debug("Udev rules need reloading");
return true;
}
return false;
}
static bool apply_format_full(
UdevEvent *event,
UdevRuleToken *token,
const char *format,
char *result,
size_t result_size,
bool replace_whitespace,
const char *what) {
assert(event);
assert(token);
assert(format);
assert(result);
assert(what);
bool truncated = false;
(void) udev_event_apply_format(event, format, result, result_size, replace_whitespace, &truncated);
if (truncated) {
log_event_truncated(event, token, what, format);
return false;
}
if (event->trace && !streq(format, result))
log_event_trace(event, token, "Format substitution: \"%s\" -> \"%s\"", format, result);
return true;
}
static bool apply_format_value(
UdevEvent *event,
UdevRuleToken *token,
char *result,
size_t result_size,
const char *what) {
return apply_format_full(event, token, token->value, result, result_size, /* replace_whitespace= */ false, what);
}
static bool apply_format_attr(
UdevEvent *event,
UdevRuleToken *token,
char *result,
size_t result_size,
const char *what) {
return apply_format_full(event, token, token->data, result, result_size, /* replace_whitespace= */ false, what);
}
static bool token_match_string(UdevEvent *event, UdevRuleToken *token, const char *str, bool log_result) {
const char *value;
bool match = false, case_insensitive;
assert(event);
assert(token);
assert(token->value);
assert(token->type < _TK_M_MAX);
str = strempty(str);
value = token->value;
case_insensitive = FLAGS_SET(token->match_type, MATCH_CASE_INSENSITIVE);
switch (token->match_type & _MATCH_TYPE_MASK) {
case MATCH_TYPE_EMPTY:
match = isempty(str);
break;
case MATCH_TYPE_SUBSYSTEM:
if (case_insensitive)
match = STRCASE_IN_SET(str, "subsystem", "class", "bus");
else
match = STR_IN_SET(str, "subsystem", "class", "bus");
break;
case MATCH_TYPE_PLAIN_WITH_EMPTY:
if (isempty(str)) {
match = true;
break;
}
_fallthrough_;
case MATCH_TYPE_PLAIN:
NULSTR_FOREACH(i, value)
if (case_insensitive ? strcaseeq(i, str) : streq(i, str)) {
match = true;
break;
}
break;
case MATCH_TYPE_GLOB_WITH_EMPTY:
if (isempty(str)) {
match = true;
break;
}
_fallthrough_;
case MATCH_TYPE_GLOB:
NULSTR_FOREACH(i, value)
if ((fnmatch(i, str, case_insensitive ? FNM_CASEFOLD : 0) == 0)) {
match = true;
break;
}
break;
default:
assert_not_reached();
}
bool result = token->op == (match ? OP_MATCH : OP_NOMATCH);
if (event->trace)
switch (token->match_type & _MATCH_TYPE_MASK) {
case MATCH_TYPE_EMPTY:
log_event_trace(event, token, "String \"%s\" is%s empty%s",
strempty(str), match ? "" : " not",
log_result ? result ? ": PASS" : ": FAIL" : ".");
break;
case MATCH_TYPE_SUBSYSTEM:
log_event_trace(event, token,
"String \"%s\" matches %s of \"subsystem\", \"class\", or \"bus\"%s",
strempty(str), match ? "one" : "neither",
log_result ? result ? ": PASS" : ": FAIL" : ".");