X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=udev%2Fudev_rules_parse.c;h=5a9552ffde9202af968434de95ace4d984ae6d6d;hp=705b3feb04ac436b57b9525feebedbec52a7bf7f;hb=d98bffa802b214452d34109967423f1d60df89af;hpb=b7ec267e176021803e27941ae8a2860facff692b diff --git a/udev/udev_rules_parse.c b/udev/udev_rules_parse.c index 705b3feb0..5a9552ffd 100644 --- a/udev/udev_rules_parse.c +++ b/udev/udev_rules_parse.c @@ -1,24 +1,21 @@ /* * Copyright (C) 2003,2004 Greg Kroah-Hartman - * Copyright (C) 2003-2006 Kay Sievers + * Copyright (C) 2003-2008 Kay Sievers * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License as published by the - * Free Software Foundation version 2 of the License. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License along - * with this program; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . */ -#include "config.h" - #include #include #include @@ -30,60 +27,74 @@ #include "udev.h" #include "udev_rules.h" -#include "udev_selinux.h" -void udev_rules_iter_init(struct udev_rules *rules) +void udev_rules_iter_init(struct udev_rules_iter *iter, struct udev_rules *rules) { - dbg("bufsize=%zi\n", rules->bufsize); - rules->current = 0; + dbg(rules->udev, "bufsize=%zi\n", rules->bufsize); + iter->rules = rules; + iter->current = 0; } -struct udev_rule *udev_rules_iter_next(struct udev_rules *rules) +struct udev_rule *udev_rules_iter_next(struct udev_rules_iter *iter) { - static struct udev_rule *rule; + struct udev_rules *rules; + struct udev_rule *rule; + rules = iter->rules; if (!rules) return NULL; - dbg("current=%zi\n", rules->current); - if (rules->current >= rules->bufsize) { - dbg("no more rules\n"); + dbg(rules->udev, "current=%zi\n", iter->current); + if (iter->current >= rules->bufsize) { + dbg(rules->udev, "no more rules\n"); return NULL; } /* get next rule */ - rule = (struct udev_rule *) (rules->buf + rules->current); - rules->current += sizeof(struct udev_rule) + rule->bufsize; + rule = (struct udev_rule *) (rules->buf + iter->current); + iter->current += sizeof(struct udev_rule) + rule->bufsize; return rule; } -struct udev_rule *udev_rules_iter_label(struct udev_rules *rules, const char *label) +struct udev_rule *udev_rules_iter_goto(struct udev_rules_iter *iter, size_t rule_off) { - static struct udev_rule *rule; - size_t start = rules->current; + struct udev_rules *rules = iter->rules; + struct udev_rule *rule; + + dbg(rules->udev, "current=%zi\n", iter->current); + iter->current = rule_off; + rule = (struct udev_rule *) (rules->buf + iter->current); + + return rule; +} + +static size_t find_label(const struct udev_rules_iter *iter, const char *label) +{ + struct udev_rule *rule; + struct udev_rules *rules = iter->rules; + size_t current = iter->current; next: - dbg("current=%zi\n", rules->current); - if (rules->current >= rules->bufsize) { - err("LABEL='%s' not found, GOTO will be ignored\n", label); - rules->current = start; - return NULL; + dbg(rules->udev, "current=%zi\n", current); + if (current >= rules->bufsize) { + err(rules->udev, "LABEL='%s' not found, GOTO will be ignored\n", label); + return iter->current; } - rule = (struct udev_rule *) (rules->buf + rules->current); + rule = (struct udev_rule *) (rules->buf + current); if (strcmp(&rule->buf[rule->label.val_off], label) != 0) { - dbg("moving forward, looking for label '%s'\n", label); - rules->current += sizeof(struct udev_rule) + rule->bufsize; + dbg(rules->udev, "moving forward, looking for label '%s'\n", label); + current += sizeof(struct udev_rule) + rule->bufsize; goto next; } - dbg("found label '%s'\n", label); - return rule; + dbg(rules->udev, "found label '%s'\n", label); + return current; } -static int get_key(char **line, char **key, enum key_operation *operation, char **value) +static int get_key(struct udev_rules *rules, char **line, char **key, enum key_operation *operation, char **value) { char *linepos; char *temp; @@ -127,29 +138,29 @@ static int get_key(char **line, char **key, enum key_operation *operation, char if (linepos[0] == '=' && linepos[1] == '=') { *operation = KEY_OP_MATCH; linepos += 2; - dbg("operator=match\n"); + dbg(rules->udev, "operator=match\n"); } else if (linepos[0] == '!' && linepos[1] == '=') { *operation = KEY_OP_NOMATCH; linepos += 2; - dbg("operator=nomatch\n"); + dbg(rules->udev, "operator=nomatch\n"); } else if (linepos[0] == '+' && linepos[1] == '=') { *operation = KEY_OP_ADD; linepos += 2; - dbg("operator=add\n"); + dbg(rules->udev, "operator=add\n"); } else if (linepos[0] == '=') { *operation = KEY_OP_ASSIGN; linepos++; - dbg("operator=assign\n"); + dbg(rules->udev, "operator=assign\n"); } else if (linepos[0] == ':' && linepos[1] == '=') { *operation = KEY_OP_ASSIGN_FINAL; linepos += 2; - dbg("operator=assign_final\n"); + dbg(rules->udev, "operator=assign_final\n"); } else return -1; /* terminate key */ temp[0] = '\0'; - dbg("key='%s'\n", *key); + dbg(rules->udev, "key='%s'\n", *key); /* skip whitespace after operator */ while (isspace(linepos[0])) @@ -169,7 +180,7 @@ static int get_key(char **line, char **key, enum key_operation *operation, char return -1; temp[0] = '\0'; temp++; - dbg("value='%s'\n", *value); + dbg(rules->udev, "value='%s'\n", *value); /* move line to next key */ *line = temp; @@ -178,7 +189,7 @@ static int get_key(char **line, char **key, enum key_operation *operation, char } /* extract possible KEY{attr} */ -static char *get_key_attribute(char *str) +static char *get_key_attribute(struct udev_rules *rules, char *str) { char *pos; char *attr; @@ -188,11 +199,11 @@ static char *get_key_attribute(char *str) attr++; pos = strchr(attr, '}'); if (pos == NULL) { - err("missing closing brace for format\n"); + err(rules->udev, "missing closing brace for format\n"); return NULL; } pos[0] = '\0'; - dbg("attribute='%s'\n", attr); + dbg(rules->udev, "attribute='%s'\n", attr); return attr; } @@ -202,24 +213,24 @@ static char *get_key_attribute(char *str) static int add_rule_key(struct udev_rule *rule, struct key *key, enum key_operation operation, const char *value) { - size_t val_len = strnlen(value, PATH_SIZE); + size_t val_len = strnlen(value, UTIL_PATH_SIZE); key->operation = operation; key->val_off = rule->bufsize; - strlcpy(rule->buf + rule->bufsize, value, val_len+1); + util_strlcpy(rule->buf + rule->bufsize, value, val_len+1); rule->bufsize += val_len+1; return 0; } -static int add_rule_key_pair(struct udev_rule *rule, struct key_pairs *pairs, +static int add_rule_key_pair(struct udev_rules *rules, struct udev_rule *rule, struct key_pairs *pairs, enum key_operation operation, const char *key, const char *value) { - size_t key_len = strnlen(key, PATH_SIZE); + size_t key_len = strnlen(key, UTIL_PATH_SIZE); if (pairs->count >= PAIRS_MAX) { - err("skip, too many keys of the same type in a single rule\n"); + err(rules->udev, "skip, too many keys of the same type in a single rule\n"); return -1; } @@ -227,7 +238,7 @@ static int add_rule_key_pair(struct udev_rule *rule, struct key_pairs *pairs, /* add the key-name of the pair */ pairs->keys[pairs->count].key_name_off = rule->bufsize; - strlcpy(rule->buf + rule->bufsize, key, key_len+1); + util_strlcpy(rule->buf + rule->bufsize, key, key_len+1); rule->bufsize += key_len+1; pairs->count++; @@ -237,7 +248,7 @@ static int add_rule_key_pair(struct udev_rule *rule, struct key_pairs *pairs, static int add_to_rules(struct udev_rules *rules, char *line, const char *filename, unsigned int lineno) { - char buf[sizeof(struct udev_rule) + LINE_SIZE]; + char buf[sizeof(struct udev_rule) + UTIL_LINE_SIZE]; struct udev_rule *rule; size_t rule_size; int valid; @@ -259,14 +270,14 @@ static int add_to_rules(struct udev_rules *rules, char *line, const char *filena char *value; enum key_operation operation = KEY_OP_UNSET; - retval = get_key(&linepos, &key, &operation, &value); + retval = get_key(rules, &linepos, &key, &operation, &value); if (retval) break; if (strcasecmp(key, "ACTION") == 0) { if (operation != KEY_OP_MATCH && operation != KEY_OP_NOMATCH) { - err("invalid ACTION operation\n"); + err(rules->udev, "invalid ACTION operation\n"); goto invalid; } add_rule_key(rule, &rule->action, operation, value); @@ -277,7 +288,7 @@ static int add_to_rules(struct udev_rules *rules, char *line, const char *filena if (strcasecmp(key, "DEVPATH") == 0) { if (operation != KEY_OP_MATCH && operation != KEY_OP_NOMATCH) { - err("invalid DEVPATH operation\n"); + err(rules->udev, "invalid DEVPATH operation\n"); goto invalid; } add_rule_key(rule, &rule->devpath, operation, value); @@ -288,7 +299,7 @@ static int add_to_rules(struct udev_rules *rules, char *line, const char *filena if (strcasecmp(key, "KERNEL") == 0) { if (operation != KEY_OP_MATCH && operation != KEY_OP_NOMATCH) { - err("invalid KERNEL operation\n"); + err(rules->udev, "invalid KERNEL operation\n"); goto invalid; } add_rule_key(rule, &rule->kernel, operation, value); @@ -299,7 +310,7 @@ static int add_to_rules(struct udev_rules *rules, char *line, const char *filena if (strcasecmp(key, "SUBSYSTEM") == 0) { if (operation != KEY_OP_MATCH && operation != KEY_OP_NOMATCH) { - err("invalid SUBSYSTEM operation\n"); + err(rules->udev, "invalid SUBSYSTEM operation\n"); goto invalid; } /* bus, class, subsystem events should all be the same */ @@ -307,7 +318,7 @@ static int add_to_rules(struct udev_rules *rules, char *line, const char *filena strcmp(value, "bus") == 0 || strcmp(value, "class") == 0) { if (strcmp(value, "bus") == 0 || strcmp(value, "class") == 0) - err("'%s' must be specified as 'subsystem' \n" + err(rules->udev, "'%s' must be specified as 'subsystem' \n" "please fix it in %s:%u", value, filename, lineno); add_rule_key(rule, &rule->subsystem, operation, "subsystem|class|bus"); } else @@ -319,7 +330,7 @@ static int add_to_rules(struct udev_rules *rules, char *line, const char *filena if (strcasecmp(key, "DRIVER") == 0) { if (operation != KEY_OP_MATCH && operation != KEY_OP_NOMATCH) { - err("invalid DRIVER operation\n"); + err(rules->udev, "invalid DRIVER operation\n"); goto invalid; } add_rule_key(rule, &rule->driver, operation, value); @@ -328,12 +339,12 @@ static int add_to_rules(struct udev_rules *rules, char *line, const char *filena } if (strncasecmp(key, "ATTR{", sizeof("ATTR{")-1) == 0) { - attr = get_key_attribute(key + sizeof("ATTR")-1); + attr = get_key_attribute(rules, key + sizeof("ATTR")-1); if (attr == NULL) { - err("error parsing ATTR attribute\n"); + err(rules->udev, "error parsing ATTR attribute\n"); goto invalid; } - if (add_rule_key_pair(rule, &rule->attr, operation, attr, value) != 0) + if (add_rule_key_pair(rules, rule, &rule->attr, operation, attr, value) != 0) goto invalid; valid = 1; continue; @@ -343,7 +354,7 @@ static int add_to_rules(struct udev_rules *rules, char *line, const char *filena strcasecmp(key, "ID") == 0) { if (operation != KEY_OP_MATCH && operation != KEY_OP_NOMATCH) { - err("invalid KERNELS operation\n"); + err(rules->udev, "invalid KERNELS operation\n"); goto invalid; } add_rule_key(rule, &rule->kernels, operation, value); @@ -355,7 +366,7 @@ static int add_to_rules(struct udev_rules *rules, char *line, const char *filena strcasecmp(key, "BUS") == 0) { if (operation != KEY_OP_MATCH && operation != KEY_OP_NOMATCH) { - err("invalid SUBSYSTEMS operation\n"); + err(rules->udev, "invalid SUBSYSTEMS operation\n"); goto invalid; } add_rule_key(rule, &rule->subsystems, operation, value); @@ -366,7 +377,7 @@ static int add_to_rules(struct udev_rules *rules, char *line, const char *filena if (strcasecmp(key, "DRIVERS") == 0) { if (operation != KEY_OP_MATCH && operation != KEY_OP_NOMATCH) { - err("invalid DRIVERS operation\n"); + err(rules->udev, "invalid DRIVERS operation\n"); goto invalid; } add_rule_key(rule, &rule->drivers, operation, value); @@ -378,35 +389,35 @@ static int add_to_rules(struct udev_rules *rules, char *line, const char *filena strncasecmp(key, "SYSFS{", sizeof("SYSFS{")-1) == 0) { if (operation != KEY_OP_MATCH && operation != KEY_OP_NOMATCH) { - err("invalid ATTRS operation\n"); + err(rules->udev, "invalid ATTRS operation\n"); goto invalid; } - attr = get_key_attribute(key + sizeof("ATTRS")-1); + attr = get_key_attribute(rules, key + sizeof("ATTRS")-1); if (attr == NULL) { - err("error parsing ATTRS attribute\n"); + err(rules->udev, "error parsing ATTRS attribute\n"); goto invalid; } if (strncmp(attr, "device/", 7) == 0) - err("the 'device' link is deprecated and will be removed from a future kernel, \n" + err(rules->udev, "the 'device' link is deprecated and will be removed from a future kernel, \n" "please fix it in %s:%u", filename, lineno); else if (strstr(attr, "../") != NULL) - err("do not reference parent sysfs directories directly, that may break with a future kernel, \n" + err(rules->udev, "do not reference parent sysfs directories directly, that may break with a future kernel, \n" "please fix it in %s:%u", filename, lineno); - if (add_rule_key_pair(rule, &rule->attrs, operation, attr, value) != 0) + if (add_rule_key_pair(rules, rule, &rule->attrs, operation, attr, value) != 0) goto invalid; valid = 1; continue; } if (strncasecmp(key, "ENV{", sizeof("ENV{")-1) == 0) { - attr = get_key_attribute(key + sizeof("ENV")-1); + attr = get_key_attribute(rules, key + sizeof("ENV")-1); if (attr == NULL) { - err("error parsing ENV attribute\n"); + err(rules->udev, "error parsing ENV attribute\n"); goto invalid; } if (strncmp(attr, "PHYSDEV", 7) == 0) physdev = 1; - if (add_rule_key_pair(rule, &rule->env, operation, attr, value) != 0) + if (add_rule_key_pair(rules, rule, &rule->env, operation, attr, value) != 0) goto invalid; valid = 1; continue; @@ -421,7 +432,7 @@ static int add_to_rules(struct udev_rules *rules, char *line, const char *filena if (strcasecmp(key, "RESULT") == 0) { if (operation != KEY_OP_MATCH && operation != KEY_OP_NOMATCH) { - err("invalid RESULT operation\n"); + err(rules->udev, "invalid RESULT operation\n"); goto invalid; } add_rule_key(rule, &rule->result, operation, value); @@ -430,42 +441,42 @@ static int add_to_rules(struct udev_rules *rules, char *line, const char *filena } if (strncasecmp(key, "IMPORT", sizeof("IMPORT")-1) == 0) { - attr = get_key_attribute(key + sizeof("IMPORT")-1); + attr = get_key_attribute(rules, key + sizeof("IMPORT")-1); if (attr != NULL && strstr(attr, "program")) { - dbg("IMPORT will be executed\n"); + dbg(rules->udev, "IMPORT will be executed\n"); rule->import_type = IMPORT_PROGRAM; } else if (attr != NULL && strstr(attr, "file")) { - dbg("IMPORT will be included as file\n"); + dbg(rules->udev, "IMPORT will be included as file\n"); rule->import_type = IMPORT_FILE; } else if (attr != NULL && strstr(attr, "parent")) { - dbg("IMPORT will include the parent values\n"); + dbg(rules->udev, "IMPORT will include the parent values\n"); rule->import_type = IMPORT_PARENT; } else { /* figure it out if it is executable */ - char file[PATH_SIZE]; + char file[UTIL_PATH_SIZE]; char *pos; struct stat statbuf; - strlcpy(file, value, sizeof(file)); + util_strlcpy(file, value, sizeof(file)); pos = strchr(file, ' '); if (pos) pos[0] = '\0'; /* allow programs in /lib/udev called without the path */ if (strchr(file, '/') == NULL) { - strlcpy(file, UDEV_PREFIX "/lib/udev/", sizeof(file)); - strlcat(file, value, sizeof(file)); + util_strlcpy(file, UDEV_PREFIX "/lib/udev/", sizeof(file)); + util_strlcat(file, value, sizeof(file)); pos = strchr(file, ' '); if (pos) pos[0] = '\0'; } - dbg("IMPORT auto mode for '%s'\n", file); + dbg(rules->udev, "IMPORT auto mode for '%s'\n", file); if (!lstat(file, &statbuf) && (statbuf.st_mode & S_IXUSR)) { - dbg("IMPORT is executable, will be executed (autotype)\n"); + dbg(rules->udev, "IMPORT is executable, will be executed (autotype)\n"); rule->import_type = IMPORT_PROGRAM; } else { - dbg("IMPORT is not executable, will be included as file (autotype)\n"); + dbg(rules->udev, "IMPORT is not executable, will be included as file (autotype)\n"); rule->import_type = IMPORT_FILE; } } @@ -477,10 +488,10 @@ static int add_to_rules(struct udev_rules *rules, char *line, const char *filena if (strncasecmp(key, "TEST", sizeof("TEST")-1) == 0) { if (operation != KEY_OP_MATCH && operation != KEY_OP_NOMATCH) { - err("invalid TEST operation\n"); + err(rules->udev, "invalid TEST operation\n"); goto invalid; } - attr = get_key_attribute(key + sizeof("TEST")-1); + attr = get_key_attribute(rules, key + sizeof("TEST")-1); if (attr != NULL) rule->test_mode_mask = strtol(attr, NULL, 8); add_rule_key(rule, &rule->test, operation, value); @@ -489,7 +500,7 @@ static int add_to_rules(struct udev_rules *rules, char *line, const char *filena } if (strncasecmp(key, "RUN", sizeof("RUN")-1) == 0) { - attr = get_key_attribute(key + sizeof("RUN")-1); + attr = get_key_attribute(rules, key + sizeof("RUN")-1); if (attr != NULL) { if (strstr(attr, "ignore_error")) rule->run_ignore_error = 1; @@ -518,19 +529,19 @@ static int add_to_rules(struct udev_rules *rules, char *line, const char *filena } if (strncasecmp(key, "NAME", sizeof("NAME")-1) == 0) { - attr = get_key_attribute(key + sizeof("NAME")-1); + attr = get_key_attribute(rules, key + sizeof("NAME")-1); if (attr != NULL) { if (strstr(attr, "all_partitions") != NULL) { - dbg("creation of partition nodes requested\n"); + dbg(rules->udev, "creation of partition nodes requested\n"); rule->partitions = DEFAULT_PARTITIONS_COUNT; } if (strstr(attr, "ignore_remove") != NULL) { - dbg("remove event should be ignored\n"); + dbg(rules->udev, "remove event should be ignored\n"); rule->ignore_remove = 1; } } if (value[0] == '\0') - dbg("name empty, node creation supressed\n"); + dbg(rules->udev, "name empty, node creation supressed\n"); add_rule_key(rule, &rule->name, operation, value); continue; } @@ -552,8 +563,8 @@ static int add_to_rules(struct udev_rules *rules, char *line, const char *filena strtoul(value, &endptr, 10); if (endptr[0] != '\0') { char owner[32]; - uid_t uid = lookup_user(value); - dbg("replacing username='%s' by id=%i\n", value, uid); + uid_t uid = lookup_user(rules->udev, value); + dbg(rules->udev, "replacing username='%s' by id=%i\n", value, uid); sprintf(owner, "%u", (unsigned int) uid); add_rule_key(rule, &rule->owner, operation, owner); continue; @@ -571,8 +582,8 @@ static int add_to_rules(struct udev_rules *rules, char *line, const char *filena strtoul(value, &endptr, 10); if (endptr[0] != '\0') { char group[32]; - gid_t gid = lookup_group(value); - dbg("replacing groupname='%s' by id=%i\n", value, gid); + gid_t gid = lookup_group(rules->udev, value); + dbg(rules->udev, "replacing groupname='%s' by id=%i\n", value, gid); sprintf(group, "%u", (unsigned int) gid); add_rule_key(rule, &rule->group, operation, group); continue; @@ -593,26 +604,26 @@ static int add_to_rules(struct udev_rules *rules, char *line, const char *filena const char *pos; if (strstr(value, "last_rule") != NULL) { - dbg("last rule to be applied\n"); + dbg(rules->udev, "last rule to be applied\n"); rule->last_rule = 1; } if (strstr(value, "ignore_device") != NULL) { - dbg("device should be ignored\n"); + dbg(rules->udev, "device should be ignored\n"); rule->ignore_device = 1; } if (strstr(value, "ignore_remove") != NULL) { - dbg("remove event should be ignored\n"); + dbg(rules->udev, "remove event should be ignored\n"); rule->ignore_remove = 1; } pos = strstr(value, "link_priority="); if (pos != NULL) { rule->link_priority = atoi(&pos[strlen("link_priority=")]); - dbg("link priority=%i\n", rule->link_priority); + dbg(rules->udev, "link priority=%i\n", rule->link_priority); } pos = strstr(value, "event_timeout="); if (pos != NULL) { rule->event_timeout = atoi(&pos[strlen("event_timeout=")]); - dbg("event timout=%i\n", rule->event_timeout); + dbg(rules->udev, "event timout=%i\n", rule->event_timeout); } pos = strstr(value, "string_escape="); if (pos != NULL) { @@ -623,18 +634,18 @@ static int add_to_rules(struct udev_rules *rules, char *line, const char *filena rule->string_escape = ESCAPE_REPLACE; } if (strstr(value, "all_partitions") != NULL) { - dbg("creation of partition nodes requested\n"); + dbg(rules->udev, "creation of partition nodes requested\n"); rule->partitions = DEFAULT_PARTITIONS_COUNT; } valid = 1; continue; } - err("unknown key '%s' in %s:%u\n", key, filename, lineno); + err(rules->udev, "unknown key '%s' in %s:%u\n", key, filename, lineno); } if (physdev && rule->wait_for.operation == KEY_OP_UNSET) - err("PHYSDEV* values are deprecated and will be removed from a future kernel, \n" + err(rules->udev, "PHYSDEV* values are deprecated and will be removed from a future kernel, \n" "please fix it in %s:%u", filename, lineno); /* skip line if not any valid key was found */ @@ -644,29 +655,29 @@ static int add_to_rules(struct udev_rules *rules, char *line, const char *filena /* grow buffer and add rule */ rule_size = sizeof(struct udev_rule) + rule->bufsize; padding = (sizeof(size_t) - rule_size % sizeof(size_t)) % sizeof(size_t); - dbg("add %zi padding bytes\n", padding); + dbg(rules->udev, "add %zi padding bytes\n", padding); rule_size += padding; rule->bufsize += padding; rules->buf = realloc(rules->buf, rules->bufsize + rule_size); if (!rules->buf) { - err("realloc failed\n"); + err(rules->udev, "realloc failed\n"); goto exit; } - dbg("adding rule to offset %zi\n", rules->bufsize); + dbg(rules->udev, "adding rule to offset %zi\n", rules->bufsize); memcpy(rules->buf + rules->bufsize, rule, rule_size); rules->bufsize += rule_size; exit: return 0; invalid: - err("invalid rule '%s:%u'\n", filename, lineno); + err(rules->udev, "invalid rule '%s:%u'\n", filename, lineno); return -1; } static int parse_file(struct udev_rules *rules, const char *filename) { - char line[LINE_SIZE]; + char line[UTIL_LINE_SIZE]; char *bufline; unsigned int lineno; char *buf; @@ -674,12 +685,17 @@ static int parse_file(struct udev_rules *rules, const char *filename) size_t cur; size_t count; int retval = 0; + size_t start; + struct udev_rule *rule; + struct udev_rules_iter iter; + + start = rules->bufsize; if (file_map(filename, &buf, &bufsize) != 0) { - err("can't open '%s' as rules file: %s\n", filename, strerror(errno)); + err(rules->udev, "can't open '%s' as rules file: %m\n", filename); return -1; } - info("reading '%s' as rules file\n", filename); + info(rules->udev, "reading '%s' as rules file\n", filename); /* loop through the whole file */ cur = 0; @@ -701,11 +717,11 @@ static int parse_file(struct udev_rules *rules, const char *filename) continue; /* see if this is a comment */ - if (bufline[0] == COMMENT_CHARACTER) + if (bufline[0] == '#') continue; if (count >= sizeof(line)) { - err("line too long, rule skipped '%s:%u'\n", filename, lineno); + err(rules->udev, "line too long, rule skipped '%s:%u'\n", filename, lineno); continue; } @@ -718,15 +734,31 @@ static int parse_file(struct udev_rules *rules, const char *filename) } line[j] = '\0'; - dbg("read '%s'\n", line); + dbg(rules->udev, "read '%s'\n", line); add_to_rules(rules, line, filename, lineno); } + /* Compute all goto targets within this file */ + udev_rules_iter_init(&iter, rules); + udev_rules_iter_goto(&iter, start); + while((rule = udev_rules_iter_next(&iter))) { + if (rule->goto_label.operation != KEY_OP_UNSET) { + char *goto_label = &rule->buf[rule->goto_label.val_off]; + + dbg(rules->udev, "resolving goto label '%s'\n", goto_label); + rule->goto_rule_off = find_label(&iter, goto_label); + if (rule->goto_rule_off == iter.current) { + err(rules->udev, "goto nonexistent label '%s' in '%s'\n", + goto_label, filename); + } + } + } + file_unmap(buf, bufsize); return retval; } -int udev_rules_init(struct udev_rules *rules, int resolve_names) +int udev_rules_init(struct udev *udev, struct udev_rules *rules, int resolve_names) { struct stat statbuf; char filename[PATH_MAX]; @@ -737,28 +769,29 @@ int udev_rules_init(struct udev_rules *rules, int resolve_names) int retval = 0; memset(rules, 0x00, sizeof(struct udev_rules)); + rules->udev = udev; rules->resolve_names = resolve_names; - if (udev_rules_dir[0] != '\0') { + if (udev_get_rules_path(udev) != NULL) { /* custom rules location for testing */ - add_matching_files(&name_list, udev_rules_dir, ".rules"); + add_matching_files(udev, &name_list, udev_get_rules_path(udev), ".rules"); } else { /* read user/custom rules */ - add_matching_files(&name_list, SYSCONFDIR "/udev/rules.d", ".rules"); + add_matching_files(udev, &name_list, SYSCONFDIR "/udev/rules.d", ".rules"); /* read dynamic/temporary rules */ - strlcpy(filename, udev_root, sizeof(filename)); - strlcat(filename, "/.udev/rules.d", sizeof(filename)); + util_strlcpy(filename, udev_get_dev_path(udev), sizeof(filename)); + util_strlcat(filename, "/.udev/rules.d", sizeof(filename)); if (stat(filename, &statbuf) != 0) { - create_path(filename); - selinux_setfscreatecon(filename, NULL, S_IFDIR|0755); + create_path(udev, filename); + udev_selinux_setfscreatecon(udev, filename, S_IFDIR|0755); mkdir(filename, 0755); - selinux_resetfscreatecon(); + udev_selinux_resetfscreatecon(udev); } - add_matching_files(&sort_list, filename, ".rules"); + add_matching_files(udev, &sort_list, filename, ".rules"); /* read default rules */ - add_matching_files(&sort_list, UDEV_PREFIX "/lib/udev/rules.d", ".rules"); + add_matching_files(udev, &sort_list, UDEV_PREFIX "/lib/udev/rules.d", ".rules"); /* sort all rules files by basename into list of files */ list_for_each_entry_safe(sort_loop, sort_tmp, &sort_list, node) { @@ -774,7 +807,7 @@ int udev_rules_init(struct udev_rules *rules, int resolve_names) continue; if (strcmp(name_base, sort_base) == 0) { - info("rule file '%s' already added, ignoring '%s'\n", + info(udev, "rule file '%s' already added, ignoring '%s'\n", name_loop->name, sort_loop->name); list_del(&sort_loop->node); free(sort_loop); @@ -796,9 +829,9 @@ int udev_rules_init(struct udev_rules *rules, int resolve_names) if (statbuf.st_size) parse_file(rules, name_loop->name); else - dbg("empty rules file '%s'\n", name_loop->name); + dbg(udev, "empty rules file '%s'\n", name_loop->name); } else - err("could not read '%s': %s\n", name_loop->name, strerror(errno)); + err(udev, "could not read '%s': %m\n", name_loop->name); list_del(&name_loop->node); free(name_loop); }