#include <ctype.h>

#include "alloc-util.h"

#include "architecture.h"

#include "conf-files.h"

#include "def.h"

#include "device-private.h"

#include "device-util.h"

#include "dirent-util.h"

#include "escape.h"

#include "fd-util.h"

#include "fileio.h"

#include "format-util.h"

#include "fs-util.h"

#include "glob-util.h"

#include "list.h"

#include "mkdir.h"

#include "netif-naming-scheme.h"

#include "nulstr-util.h"

#include "parse-util.h"

#include "path-util.h"

#include "proc-cmdline.h"

#include "stat-util.h"

#include "strv.h"

#include "strxcpyx.h"

#include "sysctl-util.h"

#include "syslog-util.h"

#include "udev-builtin.h"

#include "udev-event.h"

#include "udev-netlink.h"

#include "udev-rules.h"

#include "udev-util.h"

#include "user-util.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_INVALID = -EINVAL,

} UdevRuleMatchType;

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_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 */

} UdevRuleLineType;

typedef struct UdevRuleFile UdevRuleFile;

typedef struct UdevRuleLine UdevRuleLine;

typedef struct UdevRuleToken UdevRuleToken;

struct UdevRuleToken {

};

struct UdevRuleLine {

};

struct UdevRuleFile {

};

struct UdevRules {

};

#define log_rule_full_errno_zerook(device, rules, level, error, fmt, ...) \

({ \

UdevRules *_r = (rules); \

UdevRuleFile *_f = _r ? _r->current_file : NULL; \

UdevRuleLine *_l = _f ? _f->current_line : NULL; \

const char *_n = _f ? _f->filename : NULL; \

\

log_device_full_errno_zerook( \

device, level, error, "%s:%u " fmt, \

strna(_n), _l ? _l->line_number : 0, \

##__VA_ARGS__); \

})

#define log_rule_full_errno(device, rules, level, error, fmt, ...) \

({ \

int _error = (error); \

ASSERT_NON_ZERO(_error); \

log_rule_full_errno_zerook( \

device, rules, level, _error, fmt, ##__VA_ARGS__); \

})

#define log_rule_full(device, rules, level, ...) (void) log_rule_full_errno_zerook(device, rules, level, 0, __VA_ARGS__)

#define log_rule_debug(device, rules, ...) log_rule_full(device, rules, LOG_DEBUG, __VA_ARGS__)

#define log_rule_info(device, rules, ...) log_rule_full(device, rules, LOG_INFO, __VA_ARGS__)

#define log_rule_notice(device, rules, ...) log_rule_full(device, rules, LOG_NOTICE, __VA_ARGS__)

#define log_rule_warning(device, rules, ...) log_rule_full(device, rules, LOG_WARNING, __VA_ARGS__)

#define log_rule_error(device, rules, ...) log_rule_full(device, rules, LOG_ERR, __VA_ARGS__)

#define log_rule_debug_errno(device, rules, error, ...) log_rule_full_errno(device, rules, LOG_DEBUG, error, __VA_ARGS__)

#define log_rule_info_errno(device, rules, error, ...) log_rule_full_errno(device, rules, LOG_INFO, error, __VA_ARGS__)

#define log_rule_notice_errno(device, rules, error, ...) log_rule_full_errno(device, rules, LOG_NOTICE, error, __VA_ARGS__)

#define log_rule_warning_errno(device, rules, error, ...) log_rule_full_errno(device, rules, LOG_WARNING, error, __VA_ARGS__)

#define log_rule_error_errno(device, rules, error, ...) log_rule_full_errno(device, rules, LOG_ERR, error, __VA_ARGS__)

#define log_token_full_errno_zerook(rules, level, error, ...) log_rule_full_errno_zerook(NULL, rules, level, error, __VA_ARGS__)

#define log_token_full_errno(rules, level, error, ...) log_rule_full_errno(NULL, rules, level, error, __VA_ARGS__)

#define log_token_full(rules, level, ...) (void) log_token_full_errno_zerook(rules, level, 0, __VA_ARGS__)

#define log_token_debug(rules, ...) log_token_full(rules, LOG_DEBUG, __VA_ARGS__)

#define log_token_info(rules, ...) log_token_full(rules, LOG_INFO, __VA_ARGS__)

#define log_token_notice(rules, ...) log_token_full(rules, LOG_NOTICE, __VA_ARGS__)

#define log_token_warning(rules, ...) log_token_full(rules, LOG_WARNING, __VA_ARGS__)

#define log_token_error(rules, ...) log_token_full(rules, LOG_ERR, __VA_ARGS__)

#define log_token_debug_errno(rules, error, ...) log_token_full_errno(rules, LOG_DEBUG, error, __VA_ARGS__)

#define log_token_info_errno(rules, error, ...) log_token_full_errno(rules, LOG_INFO, error, __VA_ARGS__)

#define log_token_notice_errno(rules, error, ...) log_token_full_errno(rules, LOG_NOTICE, error, __VA_ARGS__)

#define log_token_warning_errno(rules, error, ...) log_token_full_errno(rules, LOG_WARNING, error, __VA_ARGS__)

#define log_token_error_errno(rules, error, ...) log_token_full_errno(rules, LOG_ERR, error, __VA_ARGS__)

#define _log_token_invalid(rules, key, type) \

log_token_error_errno(rules, SYNTHETIC_ERRNO(EINVAL), \

"Invalid %s for %s.", type, key)

#define log_token_invalid_op(rules, key) _log_token_invalid(rules, key, "operator")

#define log_token_invalid_attr(rules, key) _log_token_invalid(rules, key, "attribute")

#define log_token_invalid_attr_format(rules, key, attr, offset, hint) \

log_token_error_errno(rules, SYNTHETIC_ERRNO(EINVAL), \

"Invalid attribute \"%s\" for %s (char %zu: %s), ignoring.", \

attr, key, offset, hint)

#define log_token_invalid_value(rules, key, value, offset, hint) \

log_token_error_errno(rules, SYNTHETIC_ERRNO(EINVAL), \

"Invalid value \"%s\" for %s (char %zu: %s), ignoring.", \

value, key, offset, hint)

static void log_unknown_owner(sd_device *dev, UdevRules *rules, int error, const char *entity, const char *name) {

if (IN_SET(abs(error), ENOENT, ESRCH))

log_rule_error(dev, rules, "Unknown %s '%s', ignoring", entity, name);

else

log_rule_error_errno(dev, rules, error, "Failed to resolve %s '%s', ignoring: %m", entity, name);

}

static void udev_rule_token_free(UdevRuleToken *token) {

free(token);

}

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);

rule_line->tokens = NULL;

}

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) {

if (rule_line->rule_file->current_line == rule_line)

rule_line->rule_file->current_line = rule_line->rule_lines_prev;

LIST_REMOVE(rule_lines, rule_line->rule_file->rule_lines, rule_line);

}

free(rule_line->line);

return mfree(rule_line);

}

DEFINE_TRIVIAL_CLEANUP_FUNC(UdevRuleLine*, udev_rule_line_free);

static void udev_rule_file_free(UdevRuleFile *rule_file) {

if (!rule_file)

return;

LIST_FOREACH(rule_lines, i, rule_file->rule_lines)

udev_rule_line_free(i);

free(rule_file->filename);

free(rule_file);

}

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_free_key(rules->known_users);

hashmap_free_free_key(rules->known_groups);

return mfree(rules);

}

static int rule_resolve_user(UdevRules *rules, const char *name, uid_t *ret) {

_cleanup_free_ char *n = NULL;

uid_t uid;

void *val;

int r;

assert(rules);

assert(name);

val = hashmap_get(rules->known_users, name);

if (val) {

*ret = PTR_TO_UID(val);

return 0;

}

r = get_user_creds(&name, &uid, NULL, NULL, NULL, USER_CREDS_ALLOW_MISSING);

if (r < 0) {

log_unknown_owner(NULL, rules, r, "user", name);

*ret = UID_INVALID;

return 0;

}

n = strdup(name);

if (!n)

return -ENOMEM;

r = hashmap_ensure_put(&rules->known_users, &string_hash_ops, n, UID_TO_PTR(uid));

if (r < 0)

return r;

TAKE_PTR(n);

*ret = uid;

return 0;

}

static int rule_resolve_group(UdevRules *rules, const char *name, gid_t *ret) {

_cleanup_free_ char *n = NULL;

gid_t gid;

void *val;

int r;

assert(rules);

assert(name);

val = hashmap_get(rules->known_groups, name);

if (val) {

*ret = PTR_TO_GID(val);

return 0;

}

r = get_group_creds(&name, &gid, USER_CREDS_ALLOW_MISSING);

if (r < 0) {

log_unknown_owner(NULL, rules, r, "group", name);

*ret = GID_INVALID;

return 0;

}

n = strdup(name);

if (!n)

return -ENOMEM;

r = hashmap_ensure_put(&rules->known_groups, &string_hash_ops, n, GID_TO_PTR(gid));

if (r < 0)

return r;

TAKE_PTR(n);

*ret = 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 void rule_line_append_token(UdevRuleLine *rule_line, UdevRuleToken *token) {

assert(rule_line);

assert(token);

if (rule_line->current_token)

LIST_APPEND(tokens, rule_line->current_token, token);

else

LIST_APPEND(tokens, rule_line->tokens, token);

rule_line->current_token = token;

}

static int rule_line_add_token(UdevRuleLine *rule_line, UdevRuleTokenType type, UdevRuleOperatorType op, char *value, void *data) {

UdevRuleToken *token;

UdevRuleMatchType match_type = _MATCH_TYPE_INVALID;

UdevRuleSubstituteType subst_type = _SUBST_TYPE_INVALID;

bool remove_trailing_whitespace = false;

size_t len;

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 < TK_M_TEST || type == TK_M_RESULT) {

/* 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)) {

assert(value);

assert(data);

len = strlen(value);

if (len > 0 && !isspace(value[len - 1]))

remove_trailing_whitespace = true;

subst_type = rule_get_substitution_type(data);

}

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,

.attr_match_remove_trailing_whitespace = remove_trailing_whitespace,

};

rule_line_append_token(rule_line, 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);

return 0;

}

static void check_value_format_and_warn(UdevRules *rules, const char *key, const char *value, bool nonempty) {

size_t offset;

const char *hint;

if (nonempty && isempty(value))

log_token_invalid_value(rules, key, value, (size_t) 0, "empty value");

else if (udev_check_format(value, &offset, &hint) < 0)

log_token_invalid_value(rules, key, value, offset + 1, hint);

}

static int check_attr_format_and_warn(UdevRules *rules, const char *key, const char *value) {

size_t offset;

const char *hint;

if (isempty(value))

return log_token_invalid_attr(rules, key);

if (udev_check_format(value, &offset, &hint) < 0)

log_token_invalid_attr_format(rules, key, value, offset + 1, hint);

return 0;

}

static int parse_token(UdevRules *rules, const char *key, char *attr, UdevRuleOperatorType op, char *value) {

bool is_match = IN_SET(op, OP_MATCH, OP_NOMATCH);

UdevRuleLine *rule_line;

int r;

assert(rules);

assert(rules->current_file);

assert(rules->current_file->current_line);

assert(key);

assert(value);

rule_line = rules->current_file->current_line;

if (streq(key, "ACTION")) {

if (attr)

return log_token_invalid_attr(rules, key);

if (!is_match)

return log_token_invalid_op(rules, key);

r = rule_line_add_token(rule_line, TK_M_ACTION, op, value, NULL);

} else if (streq(key, "DEVPATH")) {

if (attr)

return log_token_invalid_attr(rules, key);

if (!is_match)

return log_token_invalid_op(rules, key);

r = rule_line_add_token(rule_line, TK_M_DEVPATH, op, value, NULL);

} else if (streq(key, "KERNEL")) {

if (attr)

return log_token_invalid_attr(rules, key);

if (!is_match)

return log_token_invalid_op(rules, key);

r = rule_line_add_token(rule_line, TK_M_KERNEL, op, value, NULL);

} else if (streq(key, "SYMLINK")) {

if (attr)

return log_token_invalid_attr(rules, key);

if (op == OP_REMOVE)

return log_token_invalid_op(rules, key);

if (!is_match) {

check_value_format_and_warn(rules, key, value, false);

r = rule_line_add_token(rule_line, TK_A_DEVLINK, op, value, NULL);

} else

r = rule_line_add_token(rule_line, TK_M_DEVLINK, op, value, NULL);

} else if (streq(key, "NAME")) {

if (attr)

return log_token_invalid_attr(rules, key);

if (op == OP_REMOVE)

return log_token_invalid_op(rules, key);

if (op == OP_ADD) {

log_token_warning(rules, "%s key takes '==', '!=', '=', or ':=' operator, assuming '='.", key);

op = OP_ASSIGN;

}

if (!is_match) {

if (streq(value, "%k"))

return log_token_error_errno(rules, SYNTHETIC_ERRNO(EINVAL),

"Ignoring NAME=\"%%k\", as it will take no effect.");

if (isempty(value))

return log_token_error_errno(rules, SYNTHETIC_ERRNO(EINVAL),

"Ignoring NAME=\"\", as udev will not delete any network interfaces.");

check_value_format_and_warn(rules, key, value, false);

r = rule_line_add_token(rule_line, TK_A_NAME, op, value, NULL);

} else

r = rule_line_add_token(rule_line, TK_M_NAME, op, value, NULL);

} else if (streq(key, "ENV")) {

if (isempty(attr))

return log_token_invalid_attr(rules, key);

if (op == OP_REMOVE)

return log_token_invalid_op(rules, key);

if (op == OP_ASSIGN_FINAL) {

log_token_warning(rules, "%s key takes '==', '!=', '=', or '+=' operator, assuming '='.", key);

op = OP_ASSIGN;

}

if (!is_match) {

if (STR_IN_SET(attr,

"ACTION", "DEVLINKS", "DEVNAME", "DEVPATH", "DEVTYPE", "DRIVER",

"IFINDEX", "MAJOR", "MINOR", "SEQNUM", "SUBSYSTEM", "TAGS"))

return log_token_error_errno(rules, SYNTHETIC_ERRNO(EINVAL),

"Invalid ENV attribute. '%s' cannot be set.", attr);

check_value_format_and_warn(rules, key, value, false);

r = rule_line_add_token(rule_line, TK_A_ENV, op, value, attr);

} else

r = rule_line_add_token(rule_line, TK_M_ENV, op, value, attr);

} else if (streq(key, "CONST")) {

if (isempty(attr) || !STR_IN_SET(attr, "arch", "virt"))

return log_token_invalid_attr(rules, key);

if (!is_match)

return log_token_invalid_op(rules, key);

r = rule_line_add_token(rule_line, TK_M_CONST, op, value, attr);

} else if (streq(key, "TAG")) {

if (attr)

return log_token_invalid_attr(rules, key);

if (op == OP_ASSIGN_FINAL) {

log_token_warning(rules, "%s key takes '==', '!=', '=', or '+=' operator, assuming '='.", key);

op = OP_ASSIGN;

}

if (!is_match) {

check_value_format_and_warn(rules, key, value, true);

r = rule_line_add_token(rule_line, TK_A_TAG, op, value, NULL);

} else

r = rule_line_add_token(rule_line, TK_M_TAG, op, value, NULL);

} else if (streq(key, "SUBSYSTEM")) {

if (attr)

return log_token_invalid_attr(rules, key);

if (!is_match)

return log_token_invalid_op(rules, key);

if (STR_IN_SET(value, "bus", "class"))

log_token_warning(rules, "\"%s\" must be specified as \"subsystem\".", value);

r = rule_line_add_token(rule_line, TK_M_SUBSYSTEM, op, value, NULL);

} else if (streq(key, "DRIVER")) {

if (attr)

return log_token_invalid_attr(rules, key);

if (!is_match)

return log_token_invalid_op(rules, key);

r = rule_line_add_token(rule_line, TK_M_DRIVER, op, value, NULL);

} else if (streq(key, "ATTR")) {

r = check_attr_format_and_warn(rules, key, attr);

if (r < 0)

return r;

if (op == OP_REMOVE)

return log_token_invalid_op(rules, key);

if (IN_SET(op, OP_ADD, OP_ASSIGN_FINAL)) {

log_token_warning(rules, "%s key takes '==', '!=', or '=' operator, assuming '='.", key);

op = OP_ASSIGN;

}

if (!is_match) {

check_value_format_and_warn(rules, key, value, false);

r = rule_line_add_token(rule_line, TK_A_ATTR, op, value, attr);

} else

r = rule_line_add_token(rule_line, TK_M_ATTR, op, value, attr);

} else if (streq(key, "SYSCTL")) {

r = check_attr_format_and_warn(rules, key, attr);

if (r < 0)

return r;

if (op == OP_REMOVE)

return log_token_invalid_op(rules, key);

if (IN_SET(op, OP_ADD, OP_ASSIGN_FINAL)) {

log_token_warning(rules, "%s key takes '==', '!=', or '=' operator, assuming '='.", key);

op = OP_ASSIGN;

}

if (!is_match) {

check_value_format_and_warn(rules, key, value, false);

r = rule_line_add_token(rule_line, TK_A_SYSCTL, op, value, attr);

} else

r = rule_line_add_token(rule_line, TK_M_SYSCTL, op, value, attr);

} else if (streq(key, "KERNELS")) {

if (attr)

return log_token_invalid_attr(rules, key);

if (!is_match)

return log_token_invalid_op(rules, key);

r = rule_line_add_token(rule_line, TK_M_PARENTS_KERNEL, op, value, NULL);

} else if (streq(key, "SUBSYSTEMS")) {

if (attr)

return log_token_invalid_attr(rules, key);

if (!is_match)

return log_token_invalid_op(rules, key);

r = rule_line_add_token(rule_line, TK_M_PARENTS_SUBSYSTEM, op, value, NULL);

} else if (streq(key, "DRIVERS")) {

if (attr)

return log_token_invalid_attr(rules, key);

if (!is_match)

return log_token_invalid_op(rules, key);

r = rule_line_add_token(rule_line, TK_M_PARENTS_DRIVER, op, value, NULL);

} else if (streq(key, "ATTRS")) {

r = check_attr_format_and_warn(rules, key, attr);

if (r < 0)

return r;

if (!is_match)

return log_token_invalid_op(rules, key);

if (startswith(attr, "device/"))

log_token_warning(rules, "'device' link may not be available in future kernels.");

if (strstr(attr, "../"))

log_token_warning(rules, "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);

} else if (streq(key, "TAGS")) {

if (attr)

return log_token_invalid_attr(rules, key);

if (!is_match)

return log_token_invalid_op(rules, key);

r = rule_line_add_token(rule_line, TK_M_PARENTS_TAG, op, value, NULL);

} else if (streq(key, "TEST")) {

mode_t mode = MODE_INVALID;

if (!isempty(attr)) {

r = parse_mode(attr, &mode);

if (r < 0)

return log_token_error_errno(rules, r, "Failed to parse mode '%s': %m", attr);

}

check_value_format_and_warn(rules, key, value, true);

if (!is_match)

return log_token_invalid_op(rules, key);

r = rule_line_add_token(rule_line, TK_M_TEST, op, value, MODE_TO_PTR(mode));

} else if (streq(key, "PROGRAM")) {

if (attr)

return log_token_invalid_attr(rules, key);

check_value_format_and_warn(rules, key, value, true);

if (op == OP_REMOVE)

return log_token_invalid_op(rules, key);

if (!is_match)

op = OP_MATCH;

r = rule_line_add_token(rule_line, TK_M_PROGRAM, op, value, NULL);

} else if (streq(key, "IMPORT")) {

if (isempty(attr))

return log_token_invalid_attr(rules, key);

check_value_format_and_warn(rules, key, value, true);

if (op == OP_REMOVE)

return log_token_invalid_op(rules, key);

if (!is_match)

op = OP_MATCH;

if (streq(attr, "file"))

r = rule_line_add_token(rule_line, TK_M_IMPORT_FILE, op, value, NULL);

else if (streq(attr, "program")) {

UdevBuiltinCommand cmd;

cmd = udev_builtin_lookup(value);

if (cmd >= 0) {

log_token_debug(rules,"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));

} else

r = rule_line_add_token(rule_line, TK_M_IMPORT_PROGRAM, op, value, NULL);

} else if (streq(attr, "builtin")) {

UdevBuiltinCommand cmd;

cmd = udev_builtin_lookup(value);

if (cmd < 0)

return log_token_error_errno(rules, 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));

} else if (streq(attr, "db"))

r = rule_line_add_token(rule_line, TK_M_IMPORT_DB, op, value, NULL);

else if (streq(attr, "cmdline"))

r = rule_line_add_token(rule_line, TK_M_IMPORT_CMDLINE, op, value, NULL);

else if (streq(attr, "parent"))

r = rule_line_add_token(rule_line, TK_M_IMPORT_PARENT, op, value, NULL);

else

return log_token_invalid_attr(rules, key);

} else if (streq(key, "RESULT")) {

if (attr)

return log_token_invalid_attr(rules, key);

if (!is_match)

return log_token_invalid_op(rules, key);

r = rule_line_add_token(rule_line, TK_M_RESULT, op, value, NULL);

} else if (streq(key, "OPTIONS")) {

char *tmp;

if (attr)

return log_token_invalid_attr(rules, key);

if (is_match || op == OP_REMOVE)

return log_token_invalid_op(rules, key);

if (op == OP_ADD)

op = OP_ASSIGN;

if (streq(value, "string_escape=none"))

r = rule_line_add_token(rule_line, TK_A_OPTIONS_STRING_ESCAPE_NONE, op, NULL, NULL);

else if (streq(value, "string_escape=replace"))

r = rule_line_add_token(rule_line, TK_A_OPTIONS_STRING_ESCAPE_REPLACE, op, NULL, NULL);

else if (streq(value, "db_persist"))

r = rule_line_add_token(rule_line, TK_A_OPTIONS_DB_PERSIST, op, NULL, NULL);

else if (streq(value, "watch"))

r = rule_line_add_token(rule_line, TK_A_OPTIONS_INOTIFY_WATCH, op, NULL, INT_TO_PTR(1));

else if (streq(value, "nowatch"))

r = rule_line_add_token(rule_line, TK_A_OPTIONS_INOTIFY_WATCH, op, NULL, INT_TO_PTR(0));

else if ((tmp = startswith(value, "static_node=")))

r = rule_line_add_token(rule_line, TK_A_OPTIONS_STATIC_NODE, op, tmp, NULL);

else if ((tmp = startswith(value, "link_priority="))) {

int prio;

r = safe_atoi(tmp, &prio);

if (r < 0)

return log_token_error_errno(rules, 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));

} 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_token_error_errno(rules, 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));

} else {

log_token_warning(rules, "Invalid value for OPTIONS key, ignoring: '%s'", value);

return 0;

}

} else if (streq(key, "OWNER")) {

uid_t uid;

if (attr)

return log_token_invalid_attr(rules, key);

if (is_match || op == OP_REMOVE)

return log_token_invalid_op(rules, key);

if (op == OP_ADD) {

log_token_warning(rules, "%s key takes '=' or ':=' operator, assuming '='.", key);

op = OP_ASSIGN;

}

if (parse_uid(value, &uid) >= 0)

r = rule_line_add_token(rule_line, TK_A_OWNER_ID, op, NULL, UID_TO_PTR(uid));

else if (rules->resolve_name_timing == RESOLVE_NAME_EARLY &&

rule_get_substitution_type(value) == SUBST_TYPE_PLAIN) {

r = rule_resolve_user(rules, value, &uid);

if (r < 0)

return log_token_error_errno(rules, r, "Failed to resolve user name '%s': %m", value);

r = rule_line_add_token(rule_line, TK_A_OWNER_ID, op, NULL, UID_TO_PTR(uid));

} else if (rules->resolve_name_timing != RESOLVE_NAME_NEVER) {

check_value_format_and_warn(rules, key, value, true);

r = rule_line_add_token(rule_line, TK_A_OWNER, op, value, NULL);

} else {

log_token_debug(rules, "User name resolution is disabled, ignoring %s=%s", key, value);

return 0;

}

} else if (streq(key, "GROUP")) {

gid_t gid;

if (attr)

return log_token_invalid_attr(rules, key);

if (is_match || op == OP_REMOVE)

return log_token_invalid_op(rules, key);

if (op == OP_ADD) {

log_token_warning(rules, "%s key takes '=' or ':=' operator, assuming '='.", key);

op = OP_ASSIGN;

}

if (parse_gid(value, &gid) >= 0)

r = rule_line_add_token(rule_line, TK_A_GROUP_ID, op, NULL, GID_TO_PTR(gid));

else if (rules->resolve_name_timing == RESOLVE_NAME_EARLY &&

rule_get_substitution_type(value) == SUBST_TYPE_PLAIN) {

r = rule_resolve_group(rules, value, &gid);

if (r < 0)

return log_token_error_errno(rules, r, "Failed to resolve group name '%s': %m", value);

r = rule_line_add_token(rule_line, TK_A_GROUP_ID, op, NULL, GID_TO_PTR(gid));

} else if (rules->resolve_name_timing != RESOLVE_NAME_NEVER) {

check_value_format_and_warn(rules, key, value, true);

r = rule_line_add_token(rule_line, TK_A_GROUP, op, value, NULL);

} else {

log_token_debug(rules, "Resolving group name is disabled, ignoring GROUP=\"%s\"", value);

return 0;

}

} else if (streq(key, "MODE")) {

mode_t mode;

if (attr)

return log_token_invalid_attr(rules, key);

if (is_match || op == OP_REMOVE)

return log_token_invalid_op(rules, key);

if (op == OP_ADD) {

log_token_warning(rules, "%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));

else {

check_value_format_and_warn(rules, key, value, true);

r = rule_line_add_token(rule_line, TK_A_MODE, op, value, NULL);

}

} else if (streq(key, "SECLABEL")) {

if (isempty(attr))

return log_token_invalid_attr(rules, key);

check_value_format_and_warn(rules, key, value, true);

if (is_match || op == OP_REMOVE)

return log_token_invalid_op(rules, key);

if (op == OP_ASSIGN_FINAL) {

log_token_warning(rules, "%s key takes '=' or '+=' operator, assuming '='.", key);

op = OP_ASSIGN;

}

r = rule_line_add_token(rule_line, TK_A_SECLABEL, op, value, attr);

} else if (streq(key, "RUN")) {

if (is_match || op == OP_REMOVE)

return log_token_invalid_op(rules, key);

check_value_format_and_warn(rules, key, value, true);

if (!attr || streq(attr, "program"))

r = rule_line_add_token(rule_line, TK_A_RUN_PROGRAM, op, value, NULL);

else if (streq(attr, "builtin")) {

UdevBuiltinCommand cmd;

cmd = udev_builtin_lookup(value);

if (cmd < 0)

return log_token_error_errno(rules, 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));

} else

return log_token_invalid_attr(rules, key);

} else if (streq(key, "GOTO")) {

if (attr)

return log_token_invalid_attr(rules, key);

if (op != OP_ASSIGN)

return log_token_invalid_op(rules, key);

if (FLAGS_SET(rule_line->type, LINE_HAS_GOTO)) {

log_token_warning(rules, "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_token_invalid_attr(rules, key);

if (op != OP_ASSIGN)

return log_token_invalid_op(rules, key);

rule_line->label = value;

SET_FLAG(rule_line->type, LINE_HAS_LABEL, true);

return 1;

} else

return log_token_error_errno(rules, 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;