static uid_t add_uid(struct udev_rules *rules, const char *owner) {
unsigned int i;
- uid_t uid;
+ uid_t uid = 0;
unsigned int off;
+ int r;
/* lookup, if we know it already */
for (i = 0; i < rules->uids_cur; i++) {
return uid;
}
}
- uid = util_lookup_user(rules->udev, owner);
+ r = get_user_creds(&owner, &uid, NULL, NULL, NULL);
+ if (r < 0) {
+ if (r == -ENOENT || r == -ESRCH)
+ log_error("specified user '%s' unknown", owner);
+ else
+ log_error_errno(r, "error resolving user '%s': %m", owner);
+ }
/* grow buffer if needed */
if (rules->uids_cur+1 >= rules->uids_max) {
static gid_t add_gid(struct udev_rules *rules, const char *group) {
unsigned int i;
- gid_t gid;
+ gid_t gid = 0;
unsigned int off;
+ int r;
/* lookup, if we know it already */
for (i = 0; i < rules->gids_cur; i++) {
return gid;
}
}
- gid = util_lookup_group(rules->udev, group);
+ r = get_group_creds(&group, &gid);
+ if (r < 0) {
+ if (r == -ENOENT || r == -ESRCH)
+ log_error("specified group '%s' unknown", group);
+ else
+ log_error_errno(r, "error resolving group '%s': %m", group);
+ }
/* grow buffer if needed */
if (rules->gids_cur+1 >= rules->gids_max) {
const char *filename, unsigned int filename_off, unsigned int lineno) {
char *linepos;
const char *attr;
- struct rule_tmp rule_tmp;
+ struct rule_tmp rule_tmp = {
+ .rules = rules,
+ .rule.type = TK_RULE,
+ };
- memzero(&rule_tmp, sizeof(struct rule_tmp));
- rule_tmp.rules = rules;
- rule_tmp.rule.type = TK_RULE;
/* the offset in the rule is limited to unsigned short */
if (filename_off < USHRT_MAX)
rule_tmp.rule.rule.filename_off = filename_off;
/* If we aren't at the end of the line, this is a parsing error.
* Make a best effort to describe where the problem is. */
- if (*linepos != '\n') {
- char buf[2] = {linepos[1]};
+ if (!strchr(NEWLINE, *linepos)) {
+ char buf[2] = {*linepos};
_cleanup_free_ char *tmp;
tmp = cescape(buf);
- log_error("invalid key/value pair in file %s on line %u,"
- "starting at character %tu ('%s')\n",
+ log_error("invalid key/value pair in file %s on line %u, starting at character %tu ('%s')",
filename, lineno, linepos - line + 1, tmp);
- if (linepos[1] == '#')
+ if (*linepos == '#')
log_error("hint: comments can only start at beginning of line");
}
break;
}
static int parse_file(struct udev_rules *rules, const char *filename) {
- FILE *f;
+ _cleanup_fclose_ FILE *f = NULL;
unsigned int first_token;
unsigned int filename_off;
char line[UTIL_LINE_SIZE];
}
add_rule(rules, key, filename, filename_off, line_nr);
}
- fclose(f);
/* link GOTOs to LABEL rules in this file to be able to fast-forward */
for (i = first_token+1; i < rules->token_cur; i++) {
r = conf_files_list_strv(&files, ".rules", NULL, rules_dirs);
if (r < 0) {
- log_error("failed to enumerate rules files: %s", strerror(-r));
+ log_error_errno(r, "failed to enumerate rules files: %m");
return udev_rules_unref(rules);
}
struct udev_event *event,
usec_t timeout_usec,
usec_t timeout_warn_usec,
+ struct udev_list *properties_list,
const sigset_t *sigmask) {
struct token *cur;
struct token *rule;
const char *value;
value = udev_device_get_property_value(event->dev, key_name);
- if (value == NULL)
+
+ /* 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 (!value)
value = "";
if (match_key(rules, cur, value))
goto nomatch;
break;
case TK_A_OWNER: {
char owner[UTIL_NAME_SIZE];
+ const char *ow = owner;
+ int r;
if (event->owner_final)
break;
event->owner_final = true;
udev_event_apply_format(event, rules_str(rules, cur->key.value_off), owner, sizeof(owner));
event->owner_set = true;
- event->uid = util_lookup_user(event->udev, owner);
+ r = get_user_creds(&ow, &event->uid, NULL, NULL, NULL);
+ if (r < 0) {
+ if (r == -ENOENT || r == -ESRCH)
+ log_error("specified user '%s' unknown", owner);
+ else
+ log_error_errno(r, "error resolving user '%s': %m", owner);
+
+ event->uid = 0;
+ }
log_debug("OWNER %u %s:%u",
event->uid,
rules_str(rules, rule->rule.filename_off),
}
case TK_A_GROUP: {
char group[UTIL_NAME_SIZE];
+ const char *gr = group;
+ int r;
if (event->group_final)
break;
event->group_final = true;
udev_event_apply_format(event, rules_str(rules, cur->key.value_off), group, sizeof(group));
event->group_set = true;
- event->gid = util_lookup_group(event->udev, group);
+ r = get_group_creds(&gr, &event->gid);
+ if (r < 0) {
+ if (r == -ENOENT || r == -ESRCH)
+ log_error("specified group '%s' unknown", group);
+ else
+ log_error_errno(r, "error resolving group '%s': %m", group);
+
+ event->gid = 0;
+ }
log_debug("GROUP %u %s:%u",
event->gid,
rules_str(rules, rule->rule.filename_off),
f = fopen(attr, "we");
if (f != NULL) {
if (fprintf(f, "%s", value) <= 0)
- log_error("error writing ATTR{%s}: %m", attr);
+ log_error_errno(errno, "error writing ATTR{%s}: %m", attr);
fclose(f);
} else {
- log_error("error opening ATTR{%s} for writing: %m", attr);
+ log_error_errno(errno, "error opening ATTR{%s} for writing: %m", attr);
}
break;
}
strscpyl(tags_dir, sizeof(tags_dir), "/run/udev/static_node-tags/", *t, "/", NULL);
r = mkdir_p(tags_dir, 0755);
- if (r < 0) {
- log_error("failed to create %s: %s", tags_dir, strerror(-r));
- return r;
- }
+ if (r < 0)
+ return log_error_errno(r, "failed to create %s: %m", tags_dir);
unescaped_filename = xescape(rules_str(rules, cur->key.value_off), "/.");
strscpyl(tag_symlink, sizeof(tag_symlink), tags_dir, unescaped_filename, NULL);
r = symlink(device_node, tag_symlink);
- if (r < 0 && errno != EEXIST) {
- log_error("failed to create symlink %s -> %s: %m", tag_symlink, device_node);
- return -errno;
- } else
+ if (r < 0 && errno != EEXIST)
+ return log_error_errno(errno, "failed to create symlink %s -> %s: %m",
+ tag_symlink, device_node);
+ else
r = 0;
}
}