#include "alloc-util.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 "fs-util.h"
#include "glob-util.h"
+#include "libudev-device-internal.h"
#include "path-util.h"
#include "proc-cmdline.h"
#include "stat-util.h"
#include "string-util.h"
#include "strv.h"
#include "sysctl-util.h"
+#include "udev-builtin.h"
#include "udev.h"
#include "user-util.h"
#include "util.h"
#define PREALLOC_TOKEN 2048
struct uid_gid {
- unsigned int name_off;
+ unsigned name_off;
union {
uid_t uid;
gid_t gid;
};
struct udev_rules {
- struct udev *udev;
usec_t dirs_ts_usec;
int resolve_names;
/* every key in the rules file becomes a token */
struct token *tokens;
- unsigned int token_cur;
- unsigned int token_max;
+ unsigned token_cur;
+ unsigned token_max;
/* all key strings are copied and de-duplicated in a single continuous string buffer */
struct strbuf *strbuf;
/* during rule parsing, uid/gid lookup results are cached */
struct uid_gid *uids;
- unsigned int uids_cur;
- unsigned int uids_max;
+ unsigned uids_cur;
+ unsigned uids_max;
struct uid_gid *gids;
- unsigned int gids_cur;
- unsigned int gids_max;
+ unsigned gids_cur;
+ unsigned gids_max;
};
-static char *rules_str(struct udev_rules *rules, unsigned int off) {
+static char *rules_str(struct udev_rules *rules, unsigned off) {
return rules->strbuf->buf + off;
}
-static unsigned int rules_add_string(struct udev_rules *rules, const char *s) {
+static unsigned rules_add_string(struct udev_rules *rules, const char *s) {
return strbuf_add_string(rules->strbuf, s, strlen(s));
}
enum token_type type:8;
bool can_set_name:1;
bool has_static_node:1;
- unsigned int unused:6;
+ unsigned unused:6;
unsigned short token_count;
- unsigned int label_off;
+ unsigned label_off;
unsigned short filename_off;
unsigned short filename_line;
} rule;
enum string_glob_type glob:8;
enum string_subst_type subst:4;
enum string_subst_type attrsubst:4;
- unsigned int value_off;
+ unsigned value_off;
union {
- unsigned int attr_off;
- unsigned int rule_goto;
+ unsigned attr_off;
+ unsigned rule_goto;
mode_t mode;
uid_t uid;
gid_t gid;
struct udev_rules *rules;
struct token rule;
struct token token[MAX_TK];
- unsigned int token_cur;
+ unsigned token_cur;
};
#ifdef DEBUG
{
const char *tks_ptr = (char *)rules->tokens;
const char *tk_ptr = (char *)token;
- unsigned int idx = (tk_ptr - tks_ptr) / sizeof(struct token);
+ unsigned idx = (tk_ptr - tks_ptr) / sizeof(struct token);
log_debug("* RULE %s:%u, token: %u, count: %u, label: '%s'",
&rules->strbuf->buf[token->rule.filename_off], token->rule.filename_line,
}
static void dump_rules(struct udev_rules *rules) {
- unsigned int i;
+ unsigned i;
log_debug("dumping %u (%zu bytes) tokens, %zu (%zu bytes) strings",
rules->token_cur,
/* grow buffer if needed */
if (rules->token_cur+1 >= rules->token_max) {
struct token *tokens;
- unsigned int add;
+ unsigned add;
/* double the buffer size */
add = rules->token_max;
}
static uid_t add_uid(struct udev_rules *rules, const char *owner) {
- unsigned int i;
+ unsigned i;
uid_t uid = 0;
- unsigned int off;
+ unsigned off;
int r;
/* lookup, if we know it already */
return uid;
}
}
- r = get_user_creds(&owner, &uid, NULL, NULL, NULL);
+ r = get_user_creds(&owner, &uid, NULL, NULL, NULL, USER_CREDS_ALLOW_MISSING);
if (r < 0)
log_unknown_owner(r, "user", owner);
/* grow buffer if needed */
if (rules->uids_cur+1 >= rules->uids_max) {
struct uid_gid *uids;
- unsigned int add;
+ unsigned add;
/* double the buffer size */
add = rules->uids_max;
}
static gid_t add_gid(struct udev_rules *rules, const char *group) {
- unsigned int i;
+ unsigned i;
gid_t gid = 0;
- unsigned int off;
+ unsigned off;
int r;
/* lookup, if we know it already */
return gid;
}
}
- r = get_group_creds(&group, &gid);
+ r = get_group_creds(&group, &gid, USER_CREDS_ALLOW_MISSING);
if (r < 0)
log_unknown_owner(r, "group", group);
/* grow buffer if needed */
if (rules->gids_cur+1 >= rules->gids_max) {
struct uid_gid *gids;
- unsigned int add;
+ unsigned add;
/* double the buffer size */
add = rules->gids_max;
return gid;
}
-static int import_property_from_string(struct udev_device *dev, char *line) {
+static int import_property_from_string(sd_device *dev, char *line) {
char *key;
char *val;
size_t len;
/* comment or empty line */
if (IN_SET(key[0], '#', '\0'))
- return -1;
+ return 0;
/* split key/value */
val = strchr(key, '=');
- if (val == NULL)
- return -1;
+ if (!val)
+ return -EINVAL;
val[0] = '\0';
val++;
/* terminate key */
len = strlen(key);
if (len == 0)
- return -1;
+ return -EINVAL;
while (isspace(key[len-1]))
len--;
key[len] = '\0';
/* terminate value */
len = strlen(val);
if (len == 0)
- return -1;
+ return -EINVAL;
while (isspace(val[len-1]))
len--;
val[len] = '\0';
if (len == 0)
- return -1;
+ return -EINVAL;
/* unquote */
if (IN_SET(val[0], '"', '\'')) {
if (len == 1 || val[len-1] != val[0]) {
log_debug("inconsistent quoting: '%s', skip", line);
- return -1;
+ return -EINVAL;
}
val[len-1] = '\0';
val++;
}
- udev_device_add_property(dev, key, val);
-
- return 0;
+ return device_add_property(dev, key, val);
}
-static int import_file_into_properties(struct udev_device *dev, const char *filename) {
- FILE *f;
- char line[UTIL_LINE_SIZE];
+static int import_file_into_properties(sd_device *dev, const char *filename) {
+ _cleanup_fclose_ FILE *f = NULL;
+ int r;
f = fopen(filename, "re");
- if (f == NULL)
- return -1;
- while (fgets(line, sizeof(line), f) != NULL)
- import_property_from_string(dev, line);
- fclose(f);
+ if (!f)
+ return -errno;
+
+ for (;;) {
+ _cleanup_free_ char *line = NULL;
+
+ r = read_line(f, LONG_LINE_MAX, &line);
+ if (r < 0)
+ return r;
+ if (r == 0)
+ break;
+
+ (void) import_property_from_string(dev, line);
+ }
+
return 0;
}
pos[0] = '\0';
pos = &pos[1];
}
- import_property_from_string(event->dev, line);
+ (void) import_property_from_string(event->dev->device, line);
line = pos;
}
return 0;
}
-static int import_parent_into_properties(struct udev_device *dev, const char *filter) {
- struct udev_device *dev_parent;
- struct udev_list_entry *list_entry;
+static int import_parent_into_properties(sd_device *dev, const char *filter) {
+ const char *key, *val;
+ sd_device *parent;
+ int r;
assert(dev);
assert(filter);
- dev_parent = udev_device_get_parent(dev);
- if (dev_parent == NULL)
- return -1;
-
- udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(dev_parent)) {
- const char *key = udev_list_entry_get_name(list_entry);
- const char *val = udev_list_entry_get_value(list_entry);
+ r = sd_device_get_parent(dev, &parent);
+ if (r < 0)
+ return r;
+ FOREACH_DEVICE_PROPERTY(parent, key, val)
if (fnmatch(filter, key, 0) == 0)
- udev_device_add_property(dev, key, val);
- }
+ device_add_property(dev, key, val);
return 0;
}
}
}
-static int get_key(struct udev *udev, char **line, char **key, enum operation_type *op, char **value) {
+static int get_key(char **line, char **key, enum operation_type *op, char **value) {
char *linepos;
char *temp;
unsigned i, j;
}
/* extract possible KEY{attr} */
-static const char *get_key_attribute(struct udev *udev, char *str) {
+static const char *get_key_attribute(char *str) {
char *pos;
char *attr;
}
static int sort_token(struct udev_rules *rules, struct rule_tmp *rule_tmp) {
- unsigned int i;
- unsigned int start = 0;
- unsigned int end = rule_tmp->token_cur;
+ unsigned i;
+ unsigned start = 0;
+ unsigned end = rule_tmp->token_cur;
for (i = 0; i < rule_tmp->token_cur; i++) {
enum token_type next_val = TK_UNSET;
- unsigned int next_idx = 0;
- unsigned int j;
+ unsigned next_idx = 0;
+ unsigned j;
/* find smallest value */
for (j = start; j < end; j++) {
#define LOG_AND_RETURN(fmt, ...) { LOG_RULE_ERROR(fmt, __VA_ARGS__); return; }
static void add_rule(struct udev_rules *rules, char *line,
- const char *filename, unsigned int filename_off, unsigned int lineno) {
+ const char *filename, unsigned filename_off, unsigned lineno) {
char *linepos;
const char *attr;
struct rule_tmp rule_tmp = {
char *value;
enum operation_type op;
- if (get_key(rules->udev, &linepos, &key, &op, &value) != 0) {
+ if (get_key(&linepos, &key, &op, &value) != 0) {
/* Avoid erroring on trailing whitespace. This is probably rare
* so save the work for the error case instead of always trying
* to strip the trailing whitespace with strstrip(). */
rule_add_key(&rule_tmp, TK_M_DRIVER, op, value, NULL);
} else if (startswith(key, "ATTR{")) {
- attr = get_key_attribute(rules->udev,
- key + STRLEN("ATTR"));
+ attr = get_key_attribute(key + STRLEN("ATTR"));
if (attr == NULL)
LOG_AND_RETURN("error parsing %s attribute", "ATTR");
rule_add_key(&rule_tmp, TK_A_ATTR, op, value, attr);
} else if (startswith(key, "SYSCTL{")) {
- attr = get_key_attribute(rules->udev,
- key + STRLEN("SYSCTL"));
+ attr = get_key_attribute(key + STRLEN("SYSCTL"));
if (attr == NULL)
LOG_AND_RETURN("error parsing %s attribute", "ATTR");
rule_add_key(&rule_tmp, TK_A_SYSCTL, op, value, attr);
} else if (startswith(key, "SECLABEL{")) {
- attr = get_key_attribute(rules->udev,
- key + STRLEN("SECLABEL"));
+ attr = get_key_attribute(key + STRLEN("SECLABEL"));
if (attr == NULL)
LOG_AND_RETURN("error parsing %s attribute", "SECLABEL");
if (op > OP_MATCH_MAX)
LOG_AND_RETURN("invalid %s operation", "ATTRS");
- attr = get_key_attribute(rules->udev,
- key + STRLEN("ATTRS"));
+ attr = get_key_attribute(key + STRLEN("ATTRS"));
if (attr == NULL)
LOG_AND_RETURN("error parsing %s attribute", "ATTRS");
rule_add_key(&rule_tmp, TK_M_TAGS, op, value, NULL);
} else if (startswith(key, "ENV{")) {
- attr = get_key_attribute(rules->udev,
- key + STRLEN("ENV"));
+ attr = get_key_attribute(key + STRLEN("ENV"));
if (attr == NULL)
LOG_AND_RETURN("error parsing %s attribute", "ENV");
rule_add_key(&rule_tmp, TK_M_RESULT, op, value, NULL);
} else if (startswith(key, "IMPORT")) {
- attr = get_key_attribute(rules->udev,
- key + STRLEN("IMPORT"));
+ attr = get_key_attribute(key + STRLEN("IMPORT"));
if (attr == NULL) {
LOG_RULE_WARNING("ignoring IMPORT{} with missing type");
continue;
if (value[0] != '/') {
const enum udev_builtin_cmd cmd = udev_builtin_lookup(value);
- if (cmd < UDEV_BUILTIN_MAX) {
+ if (cmd >= 0) {
LOG_RULE_DEBUG("IMPORT found builtin '%s', replacing", value);
rule_add_key(&rule_tmp, TK_M_IMPORT_BUILTIN, op, value, &cmd);
continue;
} else if (streq(attr, "builtin")) {
const enum udev_builtin_cmd cmd = udev_builtin_lookup(value);
- if (cmd >= UDEV_BUILTIN_MAX)
+ if (cmd < 0)
LOG_RULE_WARNING("IMPORT{builtin} '%s' unknown", value);
else
rule_add_key(&rule_tmp, TK_M_IMPORT_BUILTIN, op, value, &cmd);
if (op > OP_MATCH_MAX)
LOG_AND_RETURN("invalid %s operation", "TEST");
- attr = get_key_attribute(rules->udev,
- key + STRLEN("TEST"));
+ attr = get_key_attribute(key + STRLEN("TEST"));
if (attr != NULL) {
mode = strtol(attr, NULL, 8);
rule_add_key(&rule_tmp, TK_M_TEST, op, value, &mode);
rule_add_key(&rule_tmp, TK_M_TEST, op, value, NULL);
} else if (startswith(key, "RUN")) {
- attr = get_key_attribute(rules->udev,
- key + STRLEN("RUN"));
+ attr = get_key_attribute(key + STRLEN("RUN"));
if (attr == NULL)
attr = "program";
if (op == OP_REMOVE)
if (streq(attr, "builtin")) {
const enum udev_builtin_cmd cmd = udev_builtin_lookup(value);
- if (cmd < UDEV_BUILTIN_MAX)
- rule_add_key(&rule_tmp, TK_A_RUN_BUILTIN, op, value, &cmd);
- else
+ if (cmd < 0)
LOG_RULE_ERROR("RUN{builtin}: '%s' unknown", value);
+ else
+ rule_add_key(&rule_tmp, TK_A_RUN_BUILTIN, op, value, &cmd);
} else if (streq(attr, "program")) {
- const enum udev_builtin_cmd cmd = UDEV_BUILTIN_MAX;
+ const enum udev_builtin_cmd cmd = _UDEV_BUILTIN_MAX;
rule_add_key(&rule_tmp, TK_A_RUN_PROGRAM, op, value, &cmd);
} else
rule_add_key(&rule_tmp, TK_A_DB_PERSIST, op, NULL, NULL);
pos = strstr(value, "nowatch");
- if (pos != NULL) {
- const int off = 0;
-
- rule_add_key(&rule_tmp, TK_A_INOTIFY_WATCH, op, NULL, &off);
+ if (pos) {
+ static const int zero = 0;
+ rule_add_key(&rule_tmp, TK_A_INOTIFY_WATCH, op, NULL, &zero);
} else {
+ static const int one = 1;
pos = strstr(value, "watch");
- if (pos != NULL) {
- const int on = 1;
-
- rule_add_key(&rule_tmp, TK_A_INOTIFY_WATCH, op, NULL, &on);
- }
+ if (pos)
+ rule_add_key(&rule_tmp, TK_A_INOTIFY_WATCH, op, NULL, &one);
}
pos = strstr(value, "static_node=");
static int parse_file(struct udev_rules *rules, const char *filename) {
_cleanup_fclose_ FILE *f = NULL;
- unsigned int first_token;
- unsigned int filename_off;
+ unsigned first_token;
+ unsigned filename_off;
char line[UTIL_LINE_SIZE];
int line_nr = 0;
- unsigned int i;
+ unsigned i;
f = fopen(filename, "re");
if (!f) {
if (errno == ENOENT)
return 0;
- else
- return -errno;
+
+ return -errno;
}
if (null_or_empty_fd(fileno(f))) {
for (i = first_token+1; i < rules->token_cur; i++) {
if (rules->tokens[i].type == TK_A_GOTO) {
char *label = rules_str(rules, rules->tokens[i].key.value_off);
- unsigned int j;
+ unsigned j;
for (j = i+1; j < rules->token_cur; j++) {
if (rules->tokens[j].type != TK_RULE)
return 0;
}
-struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names) {
+struct udev_rules *udev_rules_new(int resolve_names) {
struct udev_rules *rules;
- struct udev_list file_list;
struct token end_token;
char **files, **f;
int r;
- rules = new0(struct udev_rules, 1);
- if (rules == NULL)
+ rules = new(struct udev_rules, 1);
+ if (!rules)
return NULL;
- rules->udev = udev;
- rules->resolve_names = resolve_names;
- udev_list_init(udev, &file_list, true);
+
+ *rules = (struct udev_rules) {
+ .resolve_names = resolve_names,
+ };
/* init token array and string buffer */
rules->tokens = malloc_multiply(PREALLOC_TOKEN, sizeof(struct token));
return -1;
}
-static int match_attr(struct udev_rules *rules, struct udev_device *dev, struct udev_event *event, struct token *cur) {
- const char *name;
- char nbuf[UTIL_NAME_SIZE];
- const char *value;
- char vbuf[UTIL_NAME_SIZE];
+static int match_attr(struct udev_rules *rules, sd_device *dev, struct udev_event *event, struct token *cur) {
+ char nbuf[UTIL_NAME_SIZE], vbuf[UTIL_NAME_SIZE];
+ const char *name, *value;
size_t len;
name = rules_str(rules, cur->key.attr_off);
name = nbuf;
_fallthrough_;
case SB_NONE:
- value = udev_device_get_sysattr_value(dev, name);
- if (value == NULL)
+ if (sd_device_get_sysattr_value(dev, name, &value) < 0)
return -1;
break;
case SB_SUBSYS:
- if (util_resolve_subsys_kernel(event->udev, name, vbuf, sizeof(vbuf), 1) != 0)
+ if (util_resolve_subsys_kernel(name, vbuf, sizeof(vbuf), 1) != 0)
return -1;
value = vbuf;
break;
ESCAPE_REPLACE,
};
-void udev_rules_apply_to_event(struct udev_rules *rules,
- struct udev_event *event,
- usec_t timeout_usec,
- usec_t timeout_warn_usec,
- struct udev_list *properties_list) {
- struct token *cur;
- struct token *rule;
+int udev_rules_apply_to_event(
+ struct udev_rules *rules,
+ struct udev_event *event,
+ usec_t timeout_usec,
+ usec_t timeout_warn_usec,
+ Hashmap *properties_list) {
+ sd_device *dev = event->dev->device;
enum escape_type esc = ESCAPE_UNSET;
+ struct token *cur, *rule;
+ const char *action, *val;
bool can_set_name;
int r;
- if (rules->tokens == NULL)
- return;
+ if (!rules->tokens)
+ return 0;
- can_set_name = ((!streq(udev_device_get_action(event->dev), "remove")) &&
- (major(udev_device_get_devnum(event->dev)) > 0 ||
- udev_device_get_ifindex(event->dev) > 0));
+ r = sd_device_get_property_value(dev, "ACTION", &action);
+ if (r < 0)
+ return r;
+
+ can_set_name = (!streq(action, "remove") &&
+ (sd_device_get_devnum(dev, NULL) >= 0 ||
+ sd_device_get_ifindex(dev, NULL) >= 0));
/* loop through token list, match, run actions or forward to next rule */
cur = &rules->tokens[0];
esc = ESCAPE_UNSET;
break;
case TK_M_ACTION:
- if (match_key(rules, cur, udev_device_get_action(event->dev)) != 0)
+ if (match_key(rules, cur, action) != 0)
goto nomatch;
break;
case TK_M_DEVPATH:
- if (match_key(rules, cur, udev_device_get_devpath(event->dev)) != 0)
+ if (sd_device_get_devpath(dev, &val) < 0)
+ goto nomatch;
+ if (match_key(rules, cur, val) != 0)
goto nomatch;
break;
case TK_M_KERNEL:
- if (match_key(rules, cur, udev_device_get_sysname(event->dev)) != 0)
+ if (sd_device_get_sysname(dev, &val) < 0)
+ goto nomatch;
+ if (match_key(rules, cur, val) != 0)
goto nomatch;
break;
case TK_M_DEVLINK: {
- struct udev_list_entry *list_entry;
+ const char *devlink;
bool match = false;
- udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(event->dev)) {
- const char *devlink;
-
- devlink = udev_list_entry_get_name(list_entry) + STRLEN("/dev/");
- if (match_key(rules, cur, devlink) == 0) {
+ FOREACH_DEVICE_DEVLINK(dev, devlink)
+ if (match_key(rules, cur, devlink + STRLEN("/dev/")) == 0) {
match = true;
break;
}
- }
+
if (!match)
goto nomatch;
break;
break;
case TK_M_ENV: {
const char *key_name = rules_str(rules, cur->key.attr_off);
- const char *value;
-
- value = udev_device_get_property_value(event->dev, key_name);
- /* check global properties */
- if (!value && properties_list) {
- struct udev_list_entry *list_entry;
-
- list_entry = udev_list_get_entry(properties_list);
- list_entry = udev_list_entry_get_by_name(list_entry, key_name);
- if (list_entry != NULL)
- value = udev_list_entry_get_value(list_entry);
+ if (sd_device_get_property_value(dev, key_name, &val) < 0) {
+ /* check global properties */
+ if (properties_list)
+ val = hashmap_get(properties_list, key_name);
+ else
+ val = NULL;
}
- if (!value)
- value = "";
- if (match_key(rules, cur, value))
+ if (match_key(rules, cur, strempty(val)))
goto nomatch;
break;
}
case TK_M_TAG: {
- struct udev_list_entry *list_entry;
bool match = false;
+ const char *tag;
- udev_list_entry_foreach(list_entry, udev_device_get_tags_list_entry(event->dev)) {
- if (streq(rules_str(rules, cur->key.value_off), udev_list_entry_get_name(list_entry))) {
+ FOREACH_DEVICE_TAG(dev, tag)
+ if (streq(rules_str(rules, cur->key.value_off), tag)) {
match = true;
break;
}
- }
+
if ((!match && (cur->key.op != OP_NOMATCH)) ||
(match && (cur->key.op == OP_NOMATCH)))
goto nomatch;
break;
}
case TK_M_SUBSYSTEM:
- if (match_key(rules, cur, udev_device_get_subsystem(event->dev)) != 0)
+ if (sd_device_get_subsystem(dev, &val) < 0)
+ goto nomatch;
+ if (match_key(rules, cur, val) != 0)
goto nomatch;
break;
case TK_M_DRIVER:
- if (match_key(rules, cur, udev_device_get_driver(event->dev)) != 0)
+ if (sd_device_get_driver(dev, &val) < 0)
+ goto nomatch;
+ if (match_key(rules, cur, val) != 0)
goto nomatch;
break;
case TK_M_ATTR:
- if (match_attr(rules, event->dev, event, cur) != 0)
+ if (match_attr(rules, dev, event, cur) != 0)
goto nomatch;
break;
case TK_M_SYSCTL: {
next++;
/* loop over parents */
- event->dev_parent = event->dev;
+ event->dev_parent = dev;
for (;;) {
struct token *key;
dump_token(rules, key);
switch(key->type) {
case TK_M_KERNELS:
- if (match_key(rules, key, udev_device_get_sysname(event->dev_parent)) != 0)
+ if (sd_device_get_sysname(event->dev_parent, &val) < 0)
+ goto try_parent;
+ if (match_key(rules, key, val) != 0)
goto try_parent;
break;
case TK_M_SUBSYSTEMS:
- if (match_key(rules, key, udev_device_get_subsystem(event->dev_parent)) != 0)
+ if (sd_device_get_subsystem(event->dev_parent, &val) < 0)
+ goto try_parent;
+ if (match_key(rules, key, val) != 0)
goto try_parent;
break;
case TK_M_DRIVERS:
- if (match_key(rules, key, udev_device_get_driver(event->dev_parent)) != 0)
+ if (sd_device_get_driver(event->dev_parent, &val) < 0)
+ goto try_parent;
+ if (match_key(rules, key, val) != 0)
goto try_parent;
break;
case TK_M_ATTRS:
goto try_parent;
break;
case TK_M_TAGS: {
- bool match = udev_device_has_tag(event->dev_parent, rules_str(rules, cur->key.value_off));
+ bool match = sd_device_has_tag(event->dev_parent, rules_str(rules, cur->key.value_off));
if (match && key->key.op == OP_NOMATCH)
goto try_parent;
break;
try_parent:
- event->dev_parent = udev_device_get_parent(event->dev_parent);
- if (event->dev_parent == NULL)
+ if (sd_device_get_parent(event->dev_parent, &event->dev_parent) < 0) {
+ event->dev_parent = NULL;
goto nomatch;
+ }
}
/* move behind our sequence of parent match keys */
cur = next;
int match;
udev_event_apply_format(event, rules_str(rules, cur->key.value_off), filename, sizeof(filename), false);
- if (util_resolve_subsys_kernel(event->udev, filename, filename, sizeof(filename), 0) != 0) {
+ if (util_resolve_subsys_kernel(filename, filename, sizeof(filename), 0) != 0) {
if (filename[0] != '/') {
char tmp[UTIL_PATH_SIZE];
+ if (sd_device_get_syspath(dev, &val) < 0)
+ goto nomatch;
+
strscpy(tmp, sizeof(tmp), filename);
- strscpyl(filename, sizeof(filename),
- udev_device_get_syspath(event->dev), "/", tmp, NULL);
+ strscpyl(filename, sizeof(filename), val, "/", tmp, NULL);
}
}
attr_subst_subdir(filename, sizeof(filename));
break;
}
case TK_M_PROGRAM: {
- char program[UTIL_PATH_SIZE];
- char result[UTIL_LINE_SIZE];
+ char program[UTIL_PATH_SIZE], result[UTIL_LINE_SIZE];
event->program_result = mfree(event->program_result);
udev_event_apply_format(event, rules_str(rules, cur->key.value_off), program, sizeof(program), false);
char import[UTIL_PATH_SIZE];
udev_event_apply_format(event, rules_str(rules, cur->key.value_off), import, sizeof(import), false);
- if (import_file_into_properties(event->dev, import) != 0)
+ if (import_file_into_properties(dev, import) != 0)
if (cur->key.op != OP_NOMATCH)
goto nomatch;
break;
rules_str(rules, rule->rule.filename_off),
rule->rule.filename_line);
- if (udev_builtin_run(event->dev, cur->key.builtin_cmd, command, false) != 0) {
+ r = udev_builtin_run(dev, cur->key.builtin_cmd, command, false);
+ if (r < 0) {
/* remember failure */
- log_debug("IMPORT builtin '%s' returned non-zero",
- udev_builtin_name(cur->key.builtin_cmd));
+ log_debug_errno(r, "IMPORT builtin '%s' fails: %m",
+ udev_builtin_name(cur->key.builtin_cmd));
event->builtin_ret |= (1 << cur->key.builtin_cmd);
if (cur->key.op != OP_NOMATCH)
goto nomatch;
break;
}
case TK_M_IMPORT_DB: {
- const char *key = rules_str(rules, cur->key.value_off);
- const char *value;
+ const char *key;
- value = udev_device_get_property_value(event->dev_db, key);
- if (value != NULL)
- udev_device_add_property(event->dev, key, value);
- else {
- if (cur->key.op != OP_NOMATCH)
- goto nomatch;
- }
+ key = rules_str(rules, cur->key.value_off);
+ if (sd_device_get_property_value(event->dev_db_clone, key, &val) >= 0)
+ device_add_property(dev, key, val);
+ else if (cur->key.op != OP_NOMATCH)
+ goto nomatch;
break;
}
case TK_M_IMPORT_CMDLINE: {
const char *key;
key = rules_str(rules, cur->key.value_off);
-
r = proc_cmdline_get_key(key, PROC_CMDLINE_VALUE_OPTIONAL, &value);
if (r < 0)
log_debug_errno(r, "Failed to read %s from /proc/cmdline, ignoring: %m", key);
imported = true;
if (value)
- udev_device_add_property(event->dev, key, value);
+ device_add_property(dev, key, value);
else
/* we import simple flags as 'FLAG=1' */
- udev_device_add_property(event->dev, key, "1");
+ device_add_property(dev, key, "1");
}
if (!imported && cur->key.op != OP_NOMATCH)
char import[UTIL_PATH_SIZE];
udev_event_apply_format(event, rules_str(rules, cur->key.value_off), import, sizeof(import), false);
- if (import_parent_into_properties(event->dev, import) != 0)
+ if (import_parent_into_properties(dev, import) != 0)
if (cur->key.op != OP_NOMATCH)
goto nomatch;
break;
esc = ESCAPE_REPLACE;
break;
case TK_A_DB_PERSIST:
- udev_device_set_db_persist(event->dev);
+ device_set_db_persist(dev);
break;
case TK_A_INOTIFY_WATCH:
if (event->inotify_watch_final)
event->inotify_watch = cur->key.watch;
break;
case TK_A_DEVLINK_PRIO:
- udev_device_set_devlink_priority(event->dev, cur->key.devlink_prio);
+ device_set_devlink_priority(dev, cur->key.devlink_prio);
break;
case TK_A_OWNER: {
char owner[UTIL_NAME_SIZE];
event->owner_final = true;
udev_event_apply_format(event, rules_str(rules, cur->key.value_off), owner, sizeof(owner), false);
event->owner_set = true;
- r = get_user_creds(&ow, &event->uid, NULL, NULL, NULL);
+ r = get_user_creds(&ow, &event->uid, NULL, NULL, NULL, USER_CREDS_ALLOW_MISSING);
if (r < 0) {
log_unknown_owner(r, "user", owner);
event->uid = 0;
event->group_final = true;
udev_event_apply_format(event, rules_str(rules, cur->key.value_off), group, sizeof(group), false);
event->group_set = true;
- r = get_group_creds(&gr, &event->gid);
+ r = get_group_creds(&gr, &event->gid, USER_CREDS_ALLOW_MISSING);
if (r < 0) {
log_unknown_owner(r, "group", group);
event->gid = 0;
break;
}
case TK_A_MODE: {
- char mode_str[UTIL_NAME_SIZE];
+ char mode_str[UTIL_NAME_SIZE], *endptr;
mode_t mode;
- char *endptr;
if (event->mode_final)
break;
rule->rule.filename_line);
break;
case TK_A_SECLABEL: {
+ _cleanup_free_ char *name = NULL, *label = NULL;
char label_str[UTIL_LINE_SIZE] = {};
- const char *name, *label;
- name = rules_str(rules, cur->key.attr_off);
+ name = strdup(rules_str(rules, cur->key.attr_off));
+ if (!name)
+ return log_oom();
+
udev_event_apply_format(event, rules_str(rules, cur->key.value_off), label_str, sizeof(label_str), false);
- if (label_str[0] != '\0')
- label = label_str;
+ if (!isempty(label_str))
+ label = strdup(label_str);
else
- label = rules_str(rules, cur->key.value_off);
+ label = strdup(rules_str(rules, cur->key.value_off));
+ if (!label)
+ return log_oom();
if (IN_SET(cur->key.op, OP_ASSIGN, OP_ASSIGN_FINAL))
- udev_list_cleanup(&event->seclabel_list);
- udev_list_entry_add(&event->seclabel_list, name, label);
+ hashmap_clear_free_free(event->seclabel_list);
+
+ r = hashmap_ensure_allocated(&event->seclabel_list, NULL);
+ if (r < 0)
+ return log_oom();
+
+ r = hashmap_put(event->seclabel_list, name, label);
+ if (r < 0)
+ return log_oom();
+
+ name = label = NULL;
+
log_debug("SECLABEL{%s}='%s' %s:%u",
name, label,
rules_str(rules, rule->rule.filename_off),
break;
}
case TK_A_ENV: {
- const char *name = rules_str(rules, cur->key.attr_off);
- char *value = rules_str(rules, cur->key.value_off);
char value_new[UTIL_NAME_SIZE];
- const char *value_old = NULL;
+ const char *name, *value_old;
- if (value[0] == '\0') {
+ name = rules_str(rules, cur->key.attr_off);
+ val = rules_str(rules, cur->key.value_off);
+ if (val[0] == '\0') {
if (cur->key.op == OP_ADD)
break;
- udev_device_add_property(event->dev, name, NULL);
+ device_add_property(dev, name, NULL);
break;
}
- if (cur->key.op == OP_ADD)
- value_old = udev_device_get_property_value(event->dev, name);
- if (value_old) {
+ if (cur->key.op == OP_ADD &&
+ sd_device_get_property_value(dev, name, &value_old) >= 0) {
char temp[UTIL_NAME_SIZE];
/* append value separated by space */
- udev_event_apply_format(event, value, temp, sizeof(temp), false);
+ udev_event_apply_format(event, val, temp, sizeof(temp), false);
strscpyl(value_new, sizeof(value_new), value_old, " ", temp, NULL);
} else
- udev_event_apply_format(event, value, value_new, sizeof(value_new), false);
+ udev_event_apply_format(event, val, value_new, sizeof(value_new), false);
- udev_device_add_property(event->dev, name, value_new);
+ device_add_property(dev, name, value_new);
break;
}
case TK_A_TAG: {
udev_event_apply_format(event, rules_str(rules, cur->key.value_off), tag, sizeof(tag), false);
if (IN_SET(cur->key.op, OP_ASSIGN, OP_ASSIGN_FINAL))
- udev_device_cleanup_tags_list(event->dev);
+ device_cleanup_tags(dev);
for (p = tag; *p != '\0'; p++) {
if ((*p >= 'a' && *p <= 'z') ||
(*p >= 'A' && *p <= 'Z') ||
break;
}
if (cur->key.op == OP_REMOVE)
- udev_device_remove_tag(event->dev, tag);
+ device_remove_tag(dev, tag);
else
- udev_device_add_tag(event->dev, tag);
+ device_add_tag(dev, tag);
break;
}
case TK_A_NAME: {
- const char *name = rules_str(rules, cur->key.value_off);
-
char name_str[UTIL_PATH_SIZE];
+ const char *name;
int count;
+ name = rules_str(rules, cur->key.value_off);
if (event->name_final)
break;
if (cur->key.op == OP_ASSIGN_FINAL)
if (count > 0)
log_debug("%i character(s) replaced", count);
}
- if (major(udev_device_get_devnum(event->dev)) &&
- !streq(name_str, udev_device_get_devnode(event->dev) + STRLEN("/dev/"))) {
+ if (sd_device_get_devnum(dev, NULL) >= 0 &&
+ (sd_device_get_devname(dev, &val) < 0 ||
+ !streq(name_str, val + STRLEN("/dev/")))) {
log_error("NAME=\"%s\" ignored, kernel device nodes cannot be renamed; please fix it in %s:%u\n",
name,
rules_str(rules, rule->rule.filename_off),
rule->rule.filename_line);
break;
}
- if (free_and_strdup(&event->name, name_str) < 0) {
- log_oom();
- return;
- }
+ if (free_and_strdup(&event->name, name_str) < 0)
+ return log_oom();
+
log_debug("NAME '%s' %s:%u",
event->name,
rules_str(rules, rule->rule.filename_off),
break;
}
case TK_A_DEVLINK: {
- char temp[UTIL_PATH_SIZE];
- char filename[UTIL_PATH_SIZE];
- char *pos, *next;
+ char temp[UTIL_PATH_SIZE], filename[UTIL_PATH_SIZE], *pos, *next;
int count = 0;
if (event->devlink_final)
break;
- if (major(udev_device_get_devnum(event->dev)) == 0)
+ if (sd_device_get_devnum(dev, NULL) < 0)
break;
if (cur->key.op == OP_ASSIGN_FINAL)
event->devlink_final = true;
if (IN_SET(cur->key.op, OP_ASSIGN, OP_ASSIGN_FINAL))
- udev_device_cleanup_devlinks_list(event->dev);
+ device_cleanup_devlinks(dev);
/* allow multiple symlinks separated by spaces */
udev_event_apply_format(event, rules_str(rules, cur->key.value_off), temp, sizeof(temp), esc != ESCAPE_NONE);
while (isspace(pos[0]))
pos++;
next = strchr(pos, ' ');
- while (next != NULL) {
+ while (next) {
next[0] = '\0';
log_debug("LINK '%s' %s:%u", pos,
rules_str(rules, rule->rule.filename_off), rule->rule.filename_line);
strscpyl(filename, sizeof(filename), "/dev/", pos, NULL);
- udev_device_add_devlink(event->dev, filename);
+ device_add_devlink(dev, filename);
while (isspace(next[1]))
next++;
pos = &next[1];
log_debug("LINK '%s' %s:%u", pos,
rules_str(rules, rule->rule.filename_off), rule->rule.filename_line);
strscpyl(filename, sizeof(filename), "/dev/", pos, NULL);
- udev_device_add_devlink(event->dev, filename);
+ device_add_devlink(dev, filename);
}
break;
}
case TK_A_ATTR: {
- const char *key_name = rules_str(rules, cur->key.attr_off);
- char attr[UTIL_PATH_SIZE];
- char value[UTIL_NAME_SIZE];
+ char attr[UTIL_PATH_SIZE], value[UTIL_NAME_SIZE];
_cleanup_fclose_ FILE *f = NULL;
+ const char *key_name;
- if (util_resolve_subsys_kernel(event->udev, key_name, attr, sizeof(attr), 0) != 0)
- strscpyl(attr, sizeof(attr), udev_device_get_syspath(event->dev), "/", key_name, NULL);
+ key_name = rules_str(rules, cur->key.attr_off);
+ if (util_resolve_subsys_kernel(key_name, attr, sizeof(attr), 0) != 0 &&
+ sd_device_get_syspath(dev, &val) >= 0)
+ strscpyl(attr, sizeof(attr), val, "/", key_name, NULL);
attr_subst_subdir(attr, sizeof(attr));
udev_event_apply_format(event, rules_str(rules, cur->key.value_off), value, sizeof(value), false);
break;
}
case TK_A_SYSCTL: {
- char filename[UTIL_PATH_SIZE];
- char value[UTIL_NAME_SIZE];
+ char filename[UTIL_PATH_SIZE], value[UTIL_NAME_SIZE];
udev_event_apply_format(event, rules_str(rules, cur->key.attr_off), filename, sizeof(filename), false);
sysctl_normalize(filename);
}
case TK_A_RUN_BUILTIN:
case TK_A_RUN_PROGRAM: {
- struct udev_list_entry *entry;
+ _cleanup_free_ char *cmd = NULL;
+
+ if (IN_SET(cur->key.op, OP_ASSIGN, OP_ASSIGN_FINAL)) {
+ void *p;
+
+ while ((p = hashmap_steal_first_key(event->run_list)))
+ free(p);
+ }
+
+ r = hashmap_ensure_allocated(&event->run_list, NULL);
+ if (r < 0)
+ return log_oom();
+
+ cmd = strdup(rules_str(rules, cur->key.value_off));
+ if (!cmd)
+ return log_oom();
+
+ r = hashmap_put(event->run_list, cmd, INT_TO_PTR(cur->key.builtin_cmd));
+ if (r < 0)
+ return log_oom();
+
+ cmd = NULL;
- if (IN_SET(cur->key.op, OP_ASSIGN, OP_ASSIGN_FINAL))
- udev_list_cleanup(&event->run_list);
log_debug("RUN '%s' %s:%u",
rules_str(rules, cur->key.value_off),
rules_str(rules, rule->rule.filename_off),
rule->rule.filename_line);
- entry = udev_list_entry_add(&event->run_list, rules_str(rules, cur->key.value_off), NULL);
- udev_list_entry_set_num(entry, cur->key.builtin_cmd);
break;
}
case TK_A_GOTO:
cur = &rules->tokens[cur->key.rule_goto];
continue;
case TK_END:
- return;
+ return 0;
case TK_M_PARENTS_MIN:
case TK_M_PARENTS_MAX:
/* fast-forward to next rule */
cur = rule + rule->rule.token_count;
}
+
+ return 0;
}
int udev_rules_apply_static_dev_perms(struct udev_rules *rules) {
projects / thirdparty / systemd.git / blobdiff