return strbuf_add_string(rules->strbuf, s, strlen(s));
}
-/* KEY=="", KEY!="", KEY+="", KEY="", KEY:="" */
+/* KEY=="", KEY!="", KEY+="", KEY-="", KEY="", KEY:="" */
enum operation_type {
OP_UNSET,
OP_MATCH_MAX,
OP_ADD,
+ OP_REMOVE,
OP_ASSIGN,
OP_ASSIGN_FINAL,
};
[OP_MATCH_MAX] = "MATCH_MAX",
[OP_ADD] = "add",
+ [OP_REMOVE] = "remove",
[OP_ASSIGN] = "assign",
[OP_ASSIGN_FINAL] = "assign-final",
} ;
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\n", owner);
+ else
+ log_error("error resolving user '%s': %s\n", owner, strerror(-r));
+ }
/* 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\n", group);
+ else
+ log_error("error resolving group '%s': %s\n", group, strerror(-r));
+ }
/* grow buffer if needed */
if (rules->gids_cur+1 >= rules->gids_max) {
static int import_program_into_properties(struct udev_event *event,
usec_t timeout_usec,
+ usec_t timeout_warn_usec,
const char *program, const sigset_t *sigmask) {
struct udev_device *dev = event->dev;
char **envp;
int err;
envp = udev_device_get_properties_envp(dev);
- err = udev_event_spawn(event, timeout_usec, program, envp, sigmask, result, sizeof(result));
+ err = udev_event_spawn(event, timeout_usec, timeout_warn_usec, program, envp, sigmask, result, sizeof(result));
if (err < 0)
return err;
break;
if (linepos[0] == '=')
break;
- if ((linepos[0] == '+') || (linepos[0] == '!') || (linepos[0] == ':'))
+ if ((linepos[0] == '+') || (linepos[0] == '-') || (linepos[0] == '!') || (linepos[0] == ':'))
if (linepos[1] == '=')
break;
}
} else if (linepos[0] == '+' && linepos[1] == '=') {
*op = OP_ADD;
linepos += 2;
+ } else if (linepos[0] == '-' && linepos[1] == '=') {
+ *op = OP_REMOVE;
+ linepos += 2;
} else if (linepos[0] == '=') {
*op = OP_ASSIGN;
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')\n",
filename, lineno, linepos - line + 1, tmp);
if (linepos[1] == '#')
log_error("hint: comments can only start at beginning of line");
log_error("error parsing ATTR attribute");
goto invalid;
}
+ if (op == OP_REMOVE) {
+ log_error("invalid ATTR operation");
+ goto invalid;
+ }
if (op < OP_MATCH_MAX) {
rule_add_key(&rule_tmp, TK_M_ATTR, op, value, attr);
} else {
log_error("error parsing SECLABEL attribute");
goto invalid;
}
+ if (op == OP_REMOVE) {
+ log_error("invalid SECLABEL operation");
+ goto invalid;
+ }
rule_add_key(&rule_tmp, TK_A_SECLABEL, op, value, attr);
continue;
log_error("error parsing ENV attribute");
goto invalid;
}
+ if (op == OP_REMOVE) {
+ log_error("invalid ENV operation");
+ goto invalid;
+ }
if (op < OP_MATCH_MAX) {
if (rule_add_key(&rule_tmp, TK_M_ENV, op, value, attr) != 0)
goto invalid;
}
if (streq(key, "PROGRAM")) {
+ if (op == OP_REMOVE) {
+ log_error("invalid PROGRAM operation");
+ goto invalid;
+ }
rule_add_key(&rule_tmp, TK_M_PROGRAM, op, value, NULL);
continue;
}
log_error("IMPORT{} type missing, ignoring IMPORT %s:%u", filename, lineno);
continue;
}
+ if (op == OP_REMOVE) {
+ log_error("invalid IMPORT operation");
+ goto invalid;
+ }
if (streq(attr, "program")) {
/* find known built-in command */
if (value[0] != '/') {
attr = get_key_attribute(rules->udev, key + strlen("RUN"));
if (attr == NULL)
attr = "program";
+ if (op == OP_REMOVE) {
+ log_error("invalid RUN operation");
+ goto invalid;
+ }
if (streq(attr, "builtin")) {
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
- log_error("IMPORT{builtin}: '%s' unknown %s:%u", value, filename, lineno);
+ log_error("RUN{builtin}: '%s' unknown %s:%u", value, filename, lineno);
} else if (streq(attr, "program")) {
enum udev_builtin_cmd cmd = UDEV_BUILTIN_MAX;
}
if (streq(key, "WAIT_FOR") || streq(key, "WAIT_FOR_SYSFS")) {
+ if (op == OP_REMOVE) {
+ log_error("invalid WAIT_FOR/WAIT_FOR_SYSFS operation");
+ goto invalid;
+ }
rule_add_key(&rule_tmp, TK_M_WAITFOR, 0, value, NULL);
continue;
}
if (streq(key, "LABEL")) {
+ if (op == OP_REMOVE) {
+ log_error("invalid LABEL operation");
+ goto invalid;
+ }
rule_tmp.rule.rule.label_off = rules_add_string(rules, value);
continue;
}
if (streq(key, "GOTO")) {
+ if (op == OP_REMOVE) {
+ log_error("invalid GOTO operation");
+ goto invalid;
+ }
rule_add_key(&rule_tmp, TK_A_GOTO, 0, value, NULL);
continue;
}
if (startswith(key, "NAME")) {
+ if (op == OP_REMOVE) {
+ log_error("invalid NAME operation");
+ goto invalid;
+ }
if (op < OP_MATCH_MAX) {
rule_add_key(&rule_tmp, TK_M_NAME, op, value, NULL);
} else {
}
if (streq(key, "SYMLINK")) {
+ if (op == OP_REMOVE) {
+ log_error("invalid SYMLINK operation");
+ goto invalid;
+ }
if (op < OP_MATCH_MAX)
rule_add_key(&rule_tmp, TK_M_DEVLINK, op, value, NULL);
else
uid_t uid;
char *endptr;
+ if (op == OP_REMOVE) {
+ log_error("invalid OWNER operation");
+ goto invalid;
+ }
+
uid = strtoul(value, &endptr, 10);
if (endptr[0] == '\0') {
rule_add_key(&rule_tmp, TK_A_OWNER_ID, op, NULL, &uid);
gid_t gid;
char *endptr;
+ if (op == OP_REMOVE) {
+ log_error("invalid GROUP operation");
+ goto invalid;
+ }
+
gid = strtoul(value, &endptr, 10);
if (endptr[0] == '\0') {
rule_add_key(&rule_tmp, TK_A_GROUP_ID, op, NULL, &gid);
mode_t mode;
char *endptr;
+ if (op == OP_REMOVE) {
+ log_error("invalid MODE operation");
+ goto invalid;
+ }
+
mode = strtol(value, &endptr, 8);
if (endptr[0] == '\0')
rule_add_key(&rule_tmp, TK_A_MODE_ID, op, NULL, &mode);
if (streq(key, "OPTIONS")) {
const char *pos;
+ if (op == OP_REMOVE) {
+ log_error("invalid OPTIONS operation");
+ goto invalid;
+ }
+
pos = strstr(value, "link_priority=");
if (pos != NULL) {
int prio = atoi(&pos[strlen("link_priority=")]);
}
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++) {
int 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,
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;
rules_str(rules, rule->rule.filename_off),
rule->rule.filename_line);
- if (udev_event_spawn(event, timeout_usec, program, envp, sigmask, result, sizeof(result)) < 0) {
+ if (udev_event_spawn(event, timeout_usec, timeout_warn_usec, program, envp, sigmask, result, sizeof(result)) < 0) {
if (cur->key.op != OP_NOMATCH)
goto nomatch;
} else {
rules_str(rules, rule->rule.filename_off),
rule->rule.filename_line);
- if (import_program_into_properties(event, timeout_usec, import, sigmask) != 0)
+ if (import_program_into_properties(event, timeout_usec, timeout_warn_usec, import, sigmask) != 0)
if (cur->key.op != OP_NOMATCH)
goto nomatch;
break;
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\n", owner);
+ else
+ log_error("error resolving user '%s': %s\n", owner, strerror(-r));
+
+ 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\n", group);
+ else
+ log_error("error resolving group '%s': %s\n", group, strerror(-r));
+
+ event->gid = 0;
+ }
log_debug("GROUP %u %s:%u",
event->gid,
rules_str(rules, rule->rule.filename_off),
log_error("ignoring invalid tag name '%s'", tag);
break;
}
- udev_device_add_tag(event->dev, tag);
+ if (cur->key.op == OP_REMOVE)
+ udev_device_remove_tag(event->dev, tag);
+ else
+ udev_device_add_tag(event->dev, tag);
break;
}
case TK_A_NAME: {
~ianmdlvl / elogind.git / blobdiff