#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"
#define PREALLOC_TOKEN 2048
struct uid_gid {
- unsigned int name_off;
+ unsigned name_off;
union {
uid_t uid;
gid_t gid;
/* 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 */
/* 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 */
/* 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 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 = {
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 (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)
- rule_add_key(&rule_tmp, TK_A_INOTIFY_WATCH, op, NULL, &const_int_zero);
- else {
+ 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)
- rule_add_key(&rule_tmp, TK_A_INOTIFY_WATCH, op, NULL, &const_int_one);
+ 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)
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->resolve_names = resolve_names;
- udev_list_init(NULL, &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:
usec_t timeout_usec,
usec_t timeout_warn_usec,
Hashmap *properties_list) {
- struct token *cur;
- struct token *rule;
+ 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)
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)
- value = hashmap_get(properties_list, key_name);
+ 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 (match_key(rules, cur, strempty(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;
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];
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;
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),
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(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);
projects / thirdparty / systemd.git / blobdiff