X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=udev%2Fudev-rules.c;h=5cb381ebac68f561e7b2c1372042edd1ca2b2c0f;hp=e07cd3264c4c0d5ae21ef961b5b76d78160941d0;hb=9060b066d9e7aaca9795010ac5fff61018947f87;hpb=08e7f22913075d25af283b3001db598840663f70 diff --git a/udev/udev-rules.c b/udev/udev-rules.c index e07cd3264..5cb381eba 100644 --- a/udev/udev-rules.c +++ b/udev/udev-rules.c @@ -1,5 +1,6 @@ /* - * Copyright (C) 2008 Kay Sievers + * Copyright (C) 2008-2009 Kay Sievers + * Copyright (C) 2008 Alan Jenkins * * 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 @@ -16,6 +17,7 @@ */ #include +#include #include #include #include @@ -30,6 +32,7 @@ #define PREALLOC_TOKEN 2048 #define PREALLOC_STRBUF 32 * 1024 +#define PREALLOC_TRIE 256 struct uid_gid { unsigned int name_off; @@ -39,7 +42,18 @@ struct uid_gid { }; }; -/* KEY=="", KEY!="", KEY+="", KEY="", KEY:="" */ +struct trie_node { + /* this node's first child */ + unsigned int child_idx; + /* the next child of our parent node's child list */ + unsigned int next_child_idx; + /* this node's last child (shortcut for append) */ + unsigned int last_child_idx; + unsigned int value_off; + unsigned short value_len; + unsigned char key; +}; + struct udev_rules { struct udev *udev; int resolve_names; @@ -55,7 +69,12 @@ struct udev_rules { size_t buf_max; unsigned int buf_count; - /* during rule parsing, we cache uid/gid lookup results */ + /* during rule parsing, strings are indexed to find duplicates */ + struct trie_node *trie_nodes; + unsigned int trie_nodes_cur; + unsigned int trie_nodes_max; + + /* during rule parsing, uid/gid lookup results are cached */ struct uid_gid *uids; unsigned int uids_cur; unsigned int uids_max; @@ -64,6 +83,7 @@ struct udev_rules { unsigned int gids_max; }; +/* KEY=="", KEY!="", KEY+="", KEY="", KEY:="" */ enum operation_type { OP_UNSET, @@ -83,7 +103,13 @@ enum string_glob_type { GL_SPLIT, /* multi-value A|B */ GL_SPLIT_GLOB, /* multi-value with glob A*|B* */ GL_SOMETHING, /* commonly used "?*" */ - GL_FORMAT, +}; + +enum string_subst_type { + SB_UNSET, + SB_NONE, + SB_FORMAT, + SB_SUBSYS, }; /* tokens of a rule are sorted/handled in this order */ @@ -120,6 +146,7 @@ enum token_type { TK_A_IGNORE_DEVICE, TK_A_STRING_ESCAPE_NONE, TK_A_STRING_ESCAPE_REPLACE, + TK_A_INOTIFY_WATCH, /* int */ TK_A_NUM_FAKE_PART, /* int */ TK_A_DEVLINK_PRIO, /* int */ TK_A_OWNER, /* val */ @@ -141,28 +168,28 @@ enum token_type { TK_END, }; -/* we try to pack stuff in a way that we take only 16 bytes per token */ +/* we try to pack stuff in a way that we take only 12 bytes per token */ struct token { union { - unsigned short type; /* same as in rule and key */ + unsigned char type; /* same as in rule and key */ struct { - unsigned short type; - unsigned short flags; - unsigned int next_rule; + enum token_type type:8; + unsigned int flags:8; + unsigned short token_count; unsigned int label_off; unsigned short filename_off; unsigned short filename_line; } rule; struct { - unsigned short type; - unsigned short flags; - unsigned short op; - unsigned short glob; + enum token_type type:8; + enum operation_type op:8; + enum string_glob_type glob:8; + enum string_subst_type subst:4; + enum string_subst_type attrsubst:4; unsigned int value_off; union { unsigned int attr_off; int ignore_error; - int i; unsigned int rule_goto; mode_t mode; uid_t uid; @@ -170,6 +197,7 @@ struct token { int num_fake_part; int devlink_prio; int event_timeout; + int watch; }; } key; }; @@ -184,80 +212,95 @@ struct rule_tmp { }; #ifdef DEBUG -static const char *operation_str[] = { - [OP_UNSET] = "UNSET", - [OP_MATCH] = "match", - [OP_NOMATCH] = "nomatch", - [OP_MATCH_MAX] = "MATCH_MAX", - - [OP_ADD] = "add", - [OP_ASSIGN] = "assign", - [OP_ASSIGN_FINAL] = "assign-final", -}; +static const char *operation_str(enum operation_type type) +{ + static const char *operation_strs[] = { + [OP_UNSET] = "UNSET", + [OP_MATCH] = "match", + [OP_NOMATCH] = "nomatch", + [OP_MATCH_MAX] = "MATCH_MAX", + + [OP_ADD] = "add", + [OP_ASSIGN] = "assign", + [OP_ASSIGN_FINAL] = "assign-final", +} ; + + return operation_strs[type]; +} -static const char *string_glob_str[] = { - [GL_UNSET] = "UNSET", - [GL_PLAIN] = "plain", - [GL_GLOB] = "glob", - [GL_SPLIT] = "split", - [GL_SPLIT_GLOB] = "split-glob", - [GL_SOMETHING] = "split-glob", - [GL_FORMAT] = "format", -}; +static const char *string_glob_str(enum string_glob_type type) +{ + static const char *string_glob_strs[] = { + [GL_UNSET] = "UNSET", + [GL_PLAIN] = "plain", + [GL_GLOB] = "glob", + [GL_SPLIT] = "split", + [GL_SPLIT_GLOB] = "split-glob", + [GL_SOMETHING] = "split-glob", + }; -static const char *token_str[] = { - [TK_UNSET] = "UNSET", - [TK_RULE] = "RULE", - - [TK_M_ACTION] = "M ACTION", - [TK_M_DEVPATH] = "M DEVPATH", - [TK_M_KERNEL] = "M KERNEL", - [TK_M_DEVLINK] = "M DEVLINK", - [TK_M_NAME] = "M NAME", - [TK_M_ENV] = "M ENV", - [TK_M_SUBSYSTEM] = "M SUBSYSTEM", - [TK_M_DRIVER] = "M DRIVER", - [TK_M_WAITFOR] = "M WAITFOR", - [TK_M_ATTR] = "M ATTR", - - [TK_M_PARENTS_MIN] = "M PARENTS_MIN", - [TK_M_KERNELS] = "M KERNELS", - [TK_M_SUBSYSTEMS] = "M SUBSYSTEMS", - [TK_M_DRIVERS] = "M DRIVERS", - [TK_M_ATTRS] = "M ATTRS", - [TK_M_PARENTS_MAX] = "M PARENTS_MAX", - - [TK_M_TEST] = "M TEST", - [TK_M_PROGRAM] = "M PROGRAM", - [TK_M_IMPORT_FILE] = "M IMPORT_FILE", - [TK_M_IMPORT_PROG] = "M IMPORT_PROG", - [TK_M_IMPORT_PARENT] = "M MPORT_PARENT", - [TK_M_RESULT] = "M RESULT", - [TK_M_MAX] = "M MAX", - - [TK_A_IGNORE_DEVICE] = "A IGNORE_DEVICE", - [TK_A_STRING_ESCAPE_NONE] = "A STRING_ESCAPE_NONE", - [TK_A_STRING_ESCAPE_REPLACE] = "A STRING_ESCAPE_REPLACE", - [TK_A_NUM_FAKE_PART] = "A NUM_FAKE_PART", - [TK_A_DEVLINK_PRIO] = "A DEVLINK_PRIO", - [TK_A_OWNER] = "A OWNER", - [TK_A_GROUP] = "A GROUP", - [TK_A_MODE] = "A MODE", - [TK_A_OWNER_ID] = "A OWNER_ID", - [TK_A_GROUP_ID] = "A GROUP_ID", - [TK_A_MODE_ID] = "A MODE_ID", - [TK_A_ENV] = "A ENV", - [TK_A_NAME] = "A NAME", - [TK_A_DEVLINK] = "A DEVLINK", - [TK_A_EVENT_TIMEOUT] = "A EVENT_TIMEOUT", - [TK_A_IGNORE_REMOVE] = "A IGNORE_REMOVE", - [TK_A_ATTR] = "A ATTR", - [TK_A_RUN] = "A RUN", - [TK_A_GOTO] = "A GOTO", - [TK_A_LAST_RULE] = "A LAST_RULE", - - [TK_END] = "END", -}; + return string_glob_strs[type]; +} + +static const char *token_str(enum token_type type) +{ + static const char *token_strs[] = { + [TK_UNSET] = "UNSET", + [TK_RULE] = "RULE", + + [TK_M_ACTION] = "M ACTION", + [TK_M_DEVPATH] = "M DEVPATH", + [TK_M_KERNEL] = "M KERNEL", + [TK_M_DEVLINK] = "M DEVLINK", + [TK_M_NAME] = "M NAME", + [TK_M_ENV] = "M ENV", + [TK_M_SUBSYSTEM] = "M SUBSYSTEM", + [TK_M_DRIVER] = "M DRIVER", + [TK_M_WAITFOR] = "M WAITFOR", + [TK_M_ATTR] = "M ATTR", + + [TK_M_PARENTS_MIN] = "M PARENTS_MIN", + [TK_M_KERNELS] = "M KERNELS", + [TK_M_SUBSYSTEMS] = "M SUBSYSTEMS", + [TK_M_DRIVERS] = "M DRIVERS", + [TK_M_ATTRS] = "M ATTRS", + [TK_M_PARENTS_MAX] = "M PARENTS_MAX", + + [TK_M_TEST] = "M TEST", + [TK_M_PROGRAM] = "M PROGRAM", + [TK_M_IMPORT_FILE] = "M IMPORT_FILE", + [TK_M_IMPORT_PROG] = "M IMPORT_PROG", + [TK_M_IMPORT_PARENT] = "M MPORT_PARENT", + [TK_M_RESULT] = "M RESULT", + [TK_M_MAX] = "M MAX", + + [TK_A_IGNORE_DEVICE] = "A IGNORE_DEVICE", + [TK_A_STRING_ESCAPE_NONE] = "A STRING_ESCAPE_NONE", + [TK_A_STRING_ESCAPE_REPLACE] = "A STRING_ESCAPE_REPLACE", + [TK_A_INOTIFY_WATCH] = "A INOTIFY_WATCH", + [TK_A_NUM_FAKE_PART] = "A NUM_FAKE_PART", + [TK_A_DEVLINK_PRIO] = "A DEVLINK_PRIO", + [TK_A_OWNER] = "A OWNER", + [TK_A_GROUP] = "A GROUP", + [TK_A_MODE] = "A MODE", + [TK_A_OWNER_ID] = "A OWNER_ID", + [TK_A_GROUP_ID] = "A GROUP_ID", + [TK_A_MODE_ID] = "A MODE_ID", + [TK_A_ENV] = "A ENV", + [TK_A_NAME] = "A NAME", + [TK_A_DEVLINK] = "A DEVLINK", + [TK_A_EVENT_TIMEOUT] = "A EVENT_TIMEOUT", + [TK_A_IGNORE_REMOVE] = "A IGNORE_REMOVE", + [TK_A_ATTR] = "A ATTR", + [TK_A_RUN] = "A RUN", + [TK_A_GOTO] = "A GOTO", + [TK_A_LAST_RULE] = "A LAST_RULE", + + [TK_END] = "END", + }; + + return token_strs[type]; +} static void dump_token(struct udev_rules *rules, struct token *token) { @@ -272,12 +315,11 @@ static void dump_token(struct udev_rules *rules, struct token *token) { const char *tks_ptr = (char *)rules->tokens; const char *tk_ptr = (char *)token; - unsigned int off = tk_ptr - tks_ptr; + unsigned int idx = (tk_ptr - tks_ptr) / sizeof(struct token); - dbg(rules->udev, "* RULE %s:%u, off: %u(%u), next: %u, label: '%s', flags: 0x%02x\n", + dbg(rules->udev, "* RULE %s:%u, token: %u, count: %u, label: '%s', flags: 0x%02x\n", &rules->buf[token->rule.filename_off], token->rule.filename_line, - off / (unsigned int) sizeof(struct token), off, - token->rule.next_rule, + idx, token->rule.token_count, &rules->buf[token->rule.label_off], token->rule.flags); break; @@ -305,7 +347,7 @@ static void dump_token(struct udev_rules *rules, struct token *token) case TK_A_MODE: case TK_A_RUN: dbg(rules->udev, "%s %s '%s'(%s)\n", - token_str[type], operation_str[op], value, string_glob_str[glob]); + token_str(type), operation_str(op), value, string_glob_str(glob)); break; case TK_M_ATTR: case TK_M_ATTRS: @@ -313,42 +355,45 @@ static void dump_token(struct udev_rules *rules, struct token *token) case TK_A_ATTR: case TK_A_ENV: dbg(rules->udev, "%s %s '%s' '%s'(%s)\n", - token_str[type], operation_str[op], attr, value, string_glob_str[glob]); + token_str(type), operation_str(op), attr, value, string_glob_str(glob)); break; case TK_A_IGNORE_DEVICE: case TK_A_STRING_ESCAPE_NONE: case TK_A_STRING_ESCAPE_REPLACE: case TK_A_LAST_RULE: case TK_A_IGNORE_REMOVE: - dbg(rules->udev, "%s\n", token_str[type]); + dbg(rules->udev, "%s\n", token_str(type)); break; case TK_M_TEST: dbg(rules->udev, "%s %s '%s'(%s) %#o\n", - token_str[type], operation_str[op], value, string_glob_str[glob], token->key.mode); + token_str(type), operation_str(op), value, string_glob_str(glob), token->key.mode); + break; + case TK_A_INOTIFY_WATCH: + dbg(rules->udev, "%s %u\n", token_str(type), token->key.watch); break; case TK_A_NUM_FAKE_PART: - dbg(rules->udev, "%s %u\n", token_str[type], token->key.num_fake_part); + dbg(rules->udev, "%s %u\n", token_str(type), token->key.num_fake_part); break; case TK_A_DEVLINK_PRIO: - dbg(rules->udev, "%s %s %u\n", token_str[type], operation_str[op], token->key.devlink_prio); + dbg(rules->udev, "%s %s %u\n", token_str(type), operation_str(op), token->key.devlink_prio); break; case TK_A_OWNER_ID: - dbg(rules->udev, "%s %s %u\n", token_str[type], operation_str[op], token->key.uid); + dbg(rules->udev, "%s %s %u\n", token_str(type), operation_str(op), token->key.uid); break; case TK_A_GROUP_ID: - dbg(rules->udev, "%s %s %u\n", token_str[type], operation_str[op], token->key.gid); + dbg(rules->udev, "%s %s %u\n", token_str(type), operation_str(op), token->key.gid); break; case TK_A_MODE_ID: - dbg(rules->udev, "%s %s %#o\n", token_str[type], operation_str[op], token->key.mode); + dbg(rules->udev, "%s %s %#o\n", token_str(type), operation_str(op), token->key.mode); break; case TK_A_EVENT_TIMEOUT: - dbg(rules->udev, "%s %s %u\n", token_str[type], operation_str[op], token->key.event_timeout); + dbg(rules->udev, "%s %s %u\n", token_str(type), operation_str(op), token->key.event_timeout); break; case TK_A_GOTO: - dbg(rules->udev, "%s '%s' %u\n", token_str[type], value, token->key.rule_goto); + dbg(rules->udev, "%s '%s' %u\n", token_str(type), value, token->key.rule_goto); break; case TK_END: - dbg(rules->udev, "* %s\n", token_str[type]); + dbg(rules->udev, "* %s\n", token_str(type)); break; case TK_M_PARENTS_MIN: case TK_M_PARENTS_MAX: @@ -372,31 +417,25 @@ static void dump_rules(struct udev_rules *rules) dump_token(rules, &rules->tokens[i]); } #else -static const char **operation_str; -static const char **token_str; +static inline const char *operation_str(enum operation_type type) { return NULL; } +static inline const char *token_str(enum token_type type) { return NULL; } static inline void dump_token(struct udev_rules *rules, struct token *token) {} static inline void dump_rules(struct udev_rules *rules) {} #endif /* DEBUG */ -/* we could lookup and return existing strings, or tails of strings */ -static int add_string(struct udev_rules *rules, const char *str) +static int add_new_string(struct udev_rules *rules, const char *str, size_t bytes) { - size_t len = strlen(str)+1; int off; - /* offset 0 is always '\0' */ - if (str[0] == '\0') - return 0; - /* grow buffer if needed */ - if (rules->buf_cur + len+1 >= rules->buf_max) { + if (rules->buf_cur + bytes+1 >= rules->buf_max) { char *buf; unsigned int add; /* double the buffer size */ add = rules->buf_max; - if (add < len * 8) - add = len * 8; + if (add < bytes * 8) + add = bytes * 8; buf = realloc(rules->buf, rules->buf_max + add); if (buf == NULL) @@ -406,15 +445,101 @@ static int add_string(struct udev_rules *rules, const char *str) rules->buf_max += add; } off = rules->buf_cur; - memcpy(&rules->buf[rules->buf_cur], str, len); - rules->buf_cur += len; + memcpy(&rules->buf[rules->buf_cur], str, bytes); + rules->buf_cur += bytes; rules->buf_count++; return off; } -static int add_token(struct udev_rules *rules, struct token *token) +static int add_string(struct udev_rules *rules, const char *str) { + unsigned int node_idx; + struct trie_node *new_node; + unsigned int new_node_idx; + unsigned char key; + unsigned short len; + unsigned int depth; + unsigned int off; + struct trie_node *parent; + + /* walk trie, start from last character of str to find matching tails */ + len = strlen(str); + key = str[len-1]; + node_idx = 0; + for (depth = 0; depth <= len; depth++) { + struct trie_node *node; + unsigned int child_idx; + + node = &rules->trie_nodes[node_idx]; + off = node->value_off + node->value_len - len; + + /* match against current node */ + if (depth == len || (node->value_len >= len && memcmp(&rules->buf[off], str, len) == 0)) + return off; + + /* lookup child node */ + key = str[len - 1 - depth]; + child_idx = node->child_idx; + while (child_idx > 0) { + struct trie_node *child; + + child = &rules->trie_nodes[child_idx]; + if (child->key == key) + break; + child_idx = child->next_child_idx; + } + if (child_idx == 0) + break; + node_idx = child_idx; + } + + /* string not found, add it */ + off = add_new_string(rules, str, len + 1); + + /* grow trie nodes if needed */ + if (rules->trie_nodes_cur >= rules->trie_nodes_max) { + struct trie_node *nodes; + unsigned int add; + + /* double the buffer size */ + add = rules->trie_nodes_max; + if (add < 8) + add = 8; + + nodes = realloc(rules->trie_nodes, (rules->trie_nodes_max + add) * sizeof(struct trie_node)); + if (nodes == NULL) + return -1; + dbg(rules->udev, "extend trie nodes from %u to %u\n", + rules->trie_nodes_max, rules->trie_nodes_max + add); + rules->trie_nodes = nodes; + rules->trie_nodes_max += add; + } + + /* get a new node */ + new_node_idx = rules->trie_nodes_cur; + rules->trie_nodes_cur++; + new_node = &rules->trie_nodes[new_node_idx]; + memset(new_node, 0x00, sizeof(struct trie_node)); + new_node->value_off = off; + new_node->value_len = len; + new_node->key = key; + + /* join the parent's child list */ + parent = &rules->trie_nodes[node_idx]; + if (parent->child_idx == 0) { + parent->child_idx = new_node_idx; + } else { + struct trie_node *last_child; + + last_child = &rules->trie_nodes[parent->last_child_idx]; + last_child->next_child_idx = new_node_idx; + } + parent->last_child_idx = new_node_idx; + return off; +} +static int add_token(struct udev_rules *rules, struct token *token) +{ /* grow buffer if needed */ if (rules->token_cur+1 >= rules->token_max) { struct token *tokens; @@ -587,8 +712,7 @@ static int import_property_from_string(struct udev_device *dev, char *line) info(udev, "updating devpath from '%s' to '%s'\n", udev_device_get_devpath(dev), val); - util_strlcpy(syspath, udev_get_sys_path(udev), sizeof(syspath)); - util_strlcat(syspath, val, sizeof(syspath)); + util_strscpyl(syspath, sizeof(syspath), udev_get_sys_path(udev), val, NULL); udev_device_set_syspath(dev, syspath); } else { struct udev_list_entry *entry; @@ -618,7 +742,7 @@ static int import_program_into_properties(struct udev_device *dev, const char *p { struct udev *udev = udev_device_get_udev(dev); char **envp; - char result[2048]; + char result[4096]; size_t reslen; char *line; @@ -680,12 +804,9 @@ static int wait_for_file(struct udev_device *dev, const char *file, int timeout) /* a relative path is a device attribute */ devicepath[0] = '\0'; if (file[0] != '/') { - util_strlcpy(devicepath, udev_get_sys_path(udev), sizeof(devicepath)); - util_strlcat(devicepath, udev_device_get_devpath(dev), sizeof(devicepath)); - - util_strlcpy(filepath, devicepath, sizeof(filepath)); - util_strlcat(filepath, "/", sizeof(filepath)); - util_strlcat(filepath, file, sizeof(filepath)); + util_strscpyl(devicepath, sizeof(devicepath), + udev_get_sys_path(udev), udev_device_get_devpath(dev), NULL); + util_strscpyl(filepath, sizeof(filepath), devicepath, "/", file, NULL); file = filepath; } @@ -710,17 +831,21 @@ static int wait_for_file(struct udev_device *dev, const char *file, int timeout) static int attr_subst_subdir(char *attr, size_t len) { - char *pos; int found = 0; - pos = strstr(attr, "/*/"); - if (pos != NULL) { - char str[UTIL_PATH_SIZE]; + if (strstr(attr, "/*/")) { + char *pos; + char dirname[UTIL_PATH_SIZE]; + const char *tail; DIR *dir; - pos[1] = '\0'; - util_strlcpy(str, &pos[2], sizeof(str)); - dir = opendir(attr); + util_strscpy(dirname, sizeof(dirname), attr); + pos = strstr(dirname, "/*/"); + if (pos == NULL) + return -1; + pos[0] = '\0'; + tail = &pos[2]; + dir = opendir(dirname); if (dir != NULL) { struct dirent *dent; @@ -729,18 +854,14 @@ static int attr_subst_subdir(char *attr, size_t len) if (dent->d_name[0] == '.') continue; - util_strlcat(attr, dent->d_name, len); - util_strlcat(attr, str, len); + util_strscpyl(attr, len, dirname, "/", dent->d_name, tail, NULL); if (stat(attr, &stats) == 0) { found = 1; break; } - pos[1] = '\0'; } closedir(dir); } - if (!found) - util_strlcat(attr, str, len); } return found; @@ -827,7 +948,7 @@ static int get_key(struct udev *udev, char **line, char **key, enum operation_ty return -1; temp[0] = '\0'; temp++; - dbg(udev, "%s '%s'-'%s'\n", operation_str[*op], *key, *value); + dbg(udev, "%s '%s'-'%s'\n", operation_str(*op), *key, *value); /* move line to next key */ *line = temp; @@ -860,8 +981,7 @@ static int rule_add_key(struct rule_tmp *rule_tmp, enum token_type type, const char *value, const void *data) { struct token *token = &rule_tmp->token[rule_tmp->token_cur]; - const char *attr = data; - enum string_glob_type glob; + const char *attr = NULL; memset(token, 0x00, sizeof(struct token)); @@ -895,6 +1015,7 @@ static int rule_add_key(struct rule_tmp *rule_tmp, enum token_type type, case TK_M_ATTRS: case TK_A_ATTR: case TK_A_ENV: + attr = data; token->key.value_off = add_string(rule_tmp->rules, value); token->key.attr_off = add_string(rule_tmp->rules, attr); break; @@ -913,9 +1034,8 @@ static int rule_add_key(struct rule_tmp *rule_tmp, enum token_type type, token->key.value_off = add_string(rule_tmp->rules, value); token->key.ignore_error = *(int *)data; break; + case TK_A_INOTIFY_WATCH: case TK_A_NUM_FAKE_PART: - token->key.num_fake_part = *(int *)data; - break; case TK_A_DEVLINK_PRIO: token->key.devlink_prio = *(int *)data; break; @@ -941,36 +1061,51 @@ static int rule_add_key(struct rule_tmp *rule_tmp, enum token_type type, return -1; } - glob = GL_PLAIN; - if (value != NULL) { - if (type < TK_M_MAX) { - /* check if we need to split or call fnmatch() while matching rules */ - int has_split; - int has_glob; - - has_split = (strchr(value, '|') != NULL); - has_glob = (strchr(value, '*') != NULL || strchr(value, '?') != NULL || - strchr(value, '[') != NULL || strchr(value, ']') != NULL); - if (has_split && has_glob) { - glob = GL_SPLIT_GLOB; - } else if (has_split) { - glob = GL_SPLIT; - } else if (has_glob) { - if (strcmp(value, "?*") == 0) - glob = GL_SOMETHING; - else - glob = GL_GLOB; - } + if (value != NULL && type < TK_M_MAX) { + /* check if we need to split or call fnmatch() while matching rules */ + enum string_glob_type glob; + int has_split; + int has_glob; + + has_split = (strchr(value, '|') != NULL); + has_glob = (strchr(value, '*') != NULL || strchr(value, '?') != NULL || strchr(value, '[') != NULL); + if (has_split && has_glob) { + glob = GL_SPLIT_GLOB; + } else if (has_split) { + glob = GL_SPLIT; + } else if (has_glob) { + if (strcmp(value, "?*") == 0) + glob = GL_SOMETHING; + else + glob = GL_GLOB; } else { - /* check if we need to substitute format strings for matching rules */ - if (strchr(value, '%') != NULL || strchr(value, '$') != NULL) - glob = GL_FORMAT; + glob = GL_PLAIN; } + token->key.glob = glob; + } + + if (value != NULL && type > TK_M_MAX) { + /* check if assigned value has substitution chars */ + if (value[0] == '[') + token->key.subst = SB_SUBSYS; + else if (strchr(value, '%') != NULL || strchr(value, '$') != NULL) + token->key.subst = SB_FORMAT; + else + token->key.subst = SB_NONE; + } + + if (attr != NULL) { + /* check if property/attribut name has substitution chars */ + if (attr[0] == '[') + token->key.attrsubst = SB_SUBSYS; + else if (strchr(attr, '%') != NULL || strchr(attr, '$') != NULL) + token->key.attrsubst = SB_FORMAT; + else + token->key.attrsubst = SB_NONE; } token->key.type = type; token->key.op = op; - token->key.glob = glob; rule_tmp->token_cur++; if (rule_tmp->token_cur >= ARRAY_SIZE(rule_tmp->token)) { err(rule_tmp->rules->udev, "temporary rule array too small\n"); @@ -1017,10 +1152,8 @@ static int sort_token(struct udev_rules *rules, struct rule_tmp *rule_tmp) static int add_rule(struct udev_rules *rules, char *line, const char *filename, unsigned int filename_off, unsigned int lineno) { - int valid = 0; char *linepos; char *attr; - int physdev = 0; struct rule_tmp rule_tmp; memset(&rule_tmp, 0x00, sizeof(struct rule_tmp)); @@ -1038,37 +1171,34 @@ static int add_rule(struct udev_rules *rules, char *line, if (get_key(rules->udev, &linepos, &key, &op, &value) != 0) break; - if (strcasecmp(key, "ACTION") == 0) { + if (strcmp(key, "ACTION") == 0) { if (op > OP_MATCH_MAX) { err(rules->udev, "invalid ACTION operation\n"); goto invalid; } rule_add_key(&rule_tmp, TK_M_ACTION, op, value, NULL); - valid = 1; continue; } - if (strcasecmp(key, "DEVPATH") == 0) { + if (strcmp(key, "DEVPATH") == 0) { if (op > OP_MATCH_MAX) { err(rules->udev, "invalid DEVPATH operation\n"); goto invalid; } rule_add_key(&rule_tmp, TK_M_DEVPATH, op, value, NULL); - valid = 1; continue; } - if (strcasecmp(key, "KERNEL") == 0) { + if (strcmp(key, "KERNEL") == 0) { if (op > OP_MATCH_MAX) { err(rules->udev, "invalid KERNEL operation\n"); goto invalid; } rule_add_key(&rule_tmp, TK_M_KERNEL, op, value, NULL); - valid = 1; continue; } - if (strcasecmp(key, "SUBSYSTEM") == 0) { + if (strcmp(key, "SUBSYSTEM") == 0) { if (op > OP_MATCH_MAX) { err(rules->udev, "invalid SUBSYSTEM operation\n"); goto invalid; @@ -1083,21 +1213,19 @@ static int add_rule(struct udev_rules *rules, char *line, rule_add_key(&rule_tmp, TK_M_SUBSYSTEM, op, "subsystem|class|bus", NULL); } else rule_add_key(&rule_tmp, TK_M_SUBSYSTEM, op, value, NULL); - valid = 1; continue; } - if (strcasecmp(key, "DRIVER") == 0) { + if (strcmp(key, "DRIVER") == 0) { if (op > OP_MATCH_MAX) { err(rules->udev, "invalid DRIVER operation\n"); goto invalid; } rule_add_key(&rule_tmp, TK_M_DRIVER, op, value, NULL); - valid = 1; continue; } - if (strncasecmp(key, "ATTR{", sizeof("ATTR{")-1) == 0) { + if (strncmp(key, "ATTR{", sizeof("ATTR{")-1) == 0) { attr = get_key_attribute(rules->udev, key + sizeof("ATTR")-1); if (attr == NULL) { err(rules->udev, "error parsing ATTR attribute\n"); @@ -1108,44 +1236,40 @@ static int add_rule(struct udev_rules *rules, char *line, } else { rule_add_key(&rule_tmp, TK_A_ATTR, op, value, attr); } - valid = 1; continue; } - if (strcasecmp(key, "KERNELS") == 0 || - strcasecmp(key, "ID") == 0) { + if (strcmp(key, "KERNELS") == 0 || + strcmp(key, "ID") == 0) { if (op > OP_MATCH_MAX) { err(rules->udev, "invalid KERNELS operation\n"); goto invalid; } rule_add_key(&rule_tmp, TK_M_KERNELS, op, value, NULL); - valid = 1; continue; } - if (strcasecmp(key, "SUBSYSTEMS") == 0 || - strcasecmp(key, "BUS") == 0) { + if (strcmp(key, "SUBSYSTEMS") == 0 || + strcmp(key, "BUS") == 0) { if (op > OP_MATCH_MAX) { err(rules->udev, "invalid SUBSYSTEMS operation\n"); goto invalid; } rule_add_key(&rule_tmp, TK_M_SUBSYSTEMS, op, value, NULL); - valid = 1; continue; } - if (strcasecmp(key, "DRIVERS") == 0) { + if (strcmp(key, "DRIVERS") == 0) { if (op > OP_MATCH_MAX) { err(rules->udev, "invalid DRIVERS operation\n"); goto invalid; } rule_add_key(&rule_tmp, TK_M_DRIVERS, op, value, NULL); - valid = 1; continue; } - if (strncasecmp(key, "ATTRS{", sizeof("ATTRS{")-1) == 0 || - strncasecmp(key, "SYSFS{", sizeof("SYSFS{")-1) == 0) { + if (strncmp(key, "ATTRS{", sizeof("ATTRS{")-1) == 0 || + strncmp(key, "SYSFS{", sizeof("SYSFS{")-1) == 0) { if (op > OP_MATCH_MAX) { err(rules->udev, "invalid ATTRS operation\n"); goto invalid; @@ -1162,18 +1286,15 @@ static int add_rule(struct udev_rules *rules, char *line, err(rules->udev, "do not reference parent sysfs directories directly, " "it may break with a future kernel, please fix it in %s:%u", filename, lineno); rule_add_key(&rule_tmp, TK_M_ATTRS, op, value, attr); - valid = 1; continue; } - if (strncasecmp(key, "ENV{", sizeof("ENV{")-1) == 0) { + if (strncmp(key, "ENV{", sizeof("ENV{")-1) == 0) { attr = get_key_attribute(rules->udev, key + sizeof("ENV")-1); if (attr == NULL) { err(rules->udev, "error parsing ENV attribute\n"); goto invalid; } - if (strncmp(attr, "PHYSDEV", 7) == 0) - physdev = 1; if (op < OP_MATCH_MAX) { if (rule_add_key(&rule_tmp, TK_M_ENV, op, value, attr) != 0) goto invalid; @@ -1181,75 +1302,61 @@ static int add_rule(struct udev_rules *rules, char *line, if (rule_add_key(&rule_tmp, TK_A_ENV, op, value, attr) != 0) goto invalid; } - valid = 1; continue; } - if (strcasecmp(key, "PROGRAM") == 0) { + if (strcmp(key, "PROGRAM") == 0) { rule_add_key(&rule_tmp, TK_M_PROGRAM, op, value, NULL); - valid = 1; continue; } - if (strcasecmp(key, "RESULT") == 0) { + if (strcmp(key, "RESULT") == 0) { if (op > OP_MATCH_MAX) { err(rules->udev, "invalid RESULT operation\n"); goto invalid; } rule_add_key(&rule_tmp, TK_M_RESULT, op, value, NULL); - valid = 1; continue; } - if (strncasecmp(key, "IMPORT", sizeof("IMPORT")-1) == 0) { + if (strncmp(key, "IMPORT", sizeof("IMPORT")-1) == 0) { attr = get_key_attribute(rules->udev, key + sizeof("IMPORT")-1); if (attr != NULL && strstr(attr, "program")) { dbg(rules->udev, "IMPORT will be executed\n"); rule_add_key(&rule_tmp, TK_M_IMPORT_PROG, op, value, NULL); - valid = 1; } else if (attr != NULL && strstr(attr, "file")) { dbg(rules->udev, "IMPORT will be included as file\n"); rule_add_key(&rule_tmp, TK_M_IMPORT_FILE, op, value, NULL); - valid = 1; } else if (attr != NULL && strstr(attr, "parent")) { dbg(rules->udev, "IMPORT will include the parent values\n"); rule_add_key(&rule_tmp, TK_M_IMPORT_PARENT, op, value, NULL); - valid = 1; } else { /* figure it out if it is executable */ char file[UTIL_PATH_SIZE]; char *pos; struct stat statbuf; - util_strlcpy(file, value, sizeof(file)); + /* allow programs in /lib/udev called without the path */ + if (value[0] != '/') + util_strscpyl(file, sizeof(file), UDEV_PREFIX "/lib/udev/", value, NULL); + else + util_strscpy(file, sizeof(file), value); pos = strchr(file, ' '); if (pos) pos[0] = '\0'; - - /* allow programs in /lib/udev called without the path */ - if (strchr(file, '/') == NULL) { - util_strlcpy(file, UDEV_PREFIX "/lib/udev/", sizeof(file)); - util_strlcat(file, value, sizeof(file)); - pos = strchr(file, ' '); - if (pos) - pos[0] = '\0'; - } - dbg(rules->udev, "IMPORT auto mode for '%s'\n", file); - if (!lstat(file, &statbuf) && (statbuf.st_mode & S_IXUSR)) { + if (stat(file, &statbuf) == 0 && (statbuf.st_mode & S_IXUSR)) { dbg(rules->udev, "IMPORT will be executed (autotype)\n"); rule_add_key(&rule_tmp, TK_M_IMPORT_PROG, op, value, NULL); - valid = 1; } else { dbg(rules->udev, "IMPORT will be included as file (autotype)\n"); rule_add_key(&rule_tmp, TK_M_IMPORT_FILE, op, value, NULL); - valid = 1; } } continue; } - if (strncasecmp(key, "TEST", sizeof("TEST")-1) == 0) { + if (strncmp(key, "TEST", sizeof("TEST")-1) == 0) { mode_t mode = 0; if (op > OP_MATCH_MAX) { @@ -1263,45 +1370,40 @@ static int add_rule(struct udev_rules *rules, char *line, } else { rule_add_key(&rule_tmp, TK_M_TEST, op, value, NULL); } - valid = 1; continue; } - if (strncasecmp(key, "RUN", sizeof("RUN")-1) == 0) { + if (strncmp(key, "RUN", sizeof("RUN")-1) == 0) { int flag = 0; attr = get_key_attribute(rules->udev, key + sizeof("RUN")-1); if (attr != NULL && strstr(attr, "ignore_error")) flag = 1; rule_add_key(&rule_tmp, TK_A_RUN, op, value, &flag); - valid = 1; continue; } - if (strcasecmp(key, "WAIT_FOR") == 0 || strcasecmp(key, "WAIT_FOR_SYSFS") == 0) { + if (strcmp(key, "WAIT_FOR") == 0 || strcmp(key, "WAIT_FOR_SYSFS") == 0) { rule_add_key(&rule_tmp, TK_M_WAITFOR, 0, value, NULL); - valid = 1; continue; } - if (strcasecmp(key, "LABEL") == 0) { + if (strcmp(key, "LABEL") == 0) { rule_tmp.rule.rule.label_off = add_string(rules, value); - valid = 1; continue; } - if (strcasecmp(key, "GOTO") == 0) { + if (strcmp(key, "GOTO") == 0) { rule_add_key(&rule_tmp, TK_A_GOTO, 0, value, NULL); - valid = 1; continue; } - if (strncasecmp(key, "NAME", sizeof("NAME")-1) == 0) { + if (strncmp(key, "NAME", sizeof("NAME")-1) == 0) { if (op < OP_MATCH_MAX) { rule_add_key(&rule_tmp, TK_M_NAME, op, value, NULL); } else { if (value[0] == '\0') - dbg(rules->udev, "name empty, node creation suppressed\n"); + info(rules->udev, "name empty, node creation suppressed\n"); rule_add_key(&rule_tmp, TK_A_NAME, op, value, NULL); attr = get_key_attribute(rules->udev, key + sizeof("NAME")-1); if (attr != NULL) { @@ -1321,53 +1423,50 @@ static int add_rule(struct udev_rules *rules, char *line, continue; } - if (strcasecmp(key, "SYMLINK") == 0) { + if (strcmp(key, "SYMLINK") == 0) { if (op < OP_MATCH_MAX) rule_add_key(&rule_tmp, TK_M_DEVLINK, op, value, NULL); else rule_add_key(&rule_tmp, TK_A_DEVLINK, op, value, NULL); rule_tmp.rule.rule.flags = 1; - valid = 1; continue; } - if (strcasecmp(key, "OWNER") == 0) { + if (strcmp(key, "OWNER") == 0) { uid_t uid; char *endptr; uid = strtoul(value, &endptr, 10); if (endptr[0] == '\0') { rule_add_key(&rule_tmp, TK_A_OWNER_ID, op, NULL, &uid); - } else if (rules->resolve_names && strchr("$%", value[0]) == NULL) { + } else if ((rules->resolve_names > 0) && strchr("$%", value[0]) == NULL) { uid = add_uid(rules, value); rule_add_key(&rule_tmp, TK_A_OWNER_ID, op, NULL, &uid); - } else { + } else if (rules->resolve_names >= 0) { rule_add_key(&rule_tmp, TK_A_OWNER, op, value, NULL); } rule_tmp.rule.rule.flags = 1; - valid = 1; continue; } - if (strcasecmp(key, "GROUP") == 0) { + if (strcmp(key, "GROUP") == 0) { gid_t gid; char *endptr; gid = strtoul(value, &endptr, 10); if (endptr[0] == '\0') { rule_add_key(&rule_tmp, TK_A_GROUP_ID, op, NULL, &gid); - } else if (rules->resolve_names && strchr("$%", value[0]) == NULL) { + } else if ((rules->resolve_names > 0) && strchr("$%", value[0]) == NULL) { gid = add_gid(rules, value); rule_add_key(&rule_tmp, TK_A_GROUP_ID, op, NULL, &gid); - } else { + } else if (rules->resolve_names >= 0) { rule_add_key(&rule_tmp, TK_A_GROUP, op, value, NULL); } rule_tmp.rule.rule.flags = 1; - valid = 1; continue; } - if (strcasecmp(key, "MODE") == 0) { + if (strcmp(key, "MODE") == 0) { mode_t mode; char *endptr; @@ -1377,11 +1476,10 @@ static int add_rule(struct udev_rules *rules, char *line, else rule_add_key(&rule_tmp, TK_A_MODE, op, value, NULL); rule_tmp.rule.rule.flags = 1; - valid = 1; continue; } - if (strcasecmp(key, "OPTIONS") == 0) { + if (strcmp(key, "OPTIONS") == 0) { const char *pos; if (strstr(value, "last_rule") != NULL) { @@ -1424,27 +1522,35 @@ static int add_rule(struct udev_rules *rules, char *line, rule_add_key(&rule_tmp, TK_A_NUM_FAKE_PART, 0, NULL, &num); dbg(rules->udev, "creation of partition nodes requested\n"); } - valid = 1; + pos = strstr(value, "nowatch"); + if (pos != NULL) { + const int off = 0; + + rule_add_key(&rule_tmp, TK_A_INOTIFY_WATCH, 0, NULL, &off); + dbg(rules->udev, "inotify watch of device disabled\n"); + } else { + pos = strstr(value, "watch"); + if (pos != NULL) { + const int on = 1; + + rule_add_key(&rule_tmp, TK_A_INOTIFY_WATCH, 0, NULL, &on); + dbg(rules->udev, "inotify watch of device requested\n"); + } + } continue; } err(rules->udev, "unknown key '%s' in %s:%u\n", key, filename, lineno); } - if (physdev) - err(rules->udev, "PHYSDEV* values are deprecated and not available on recent kernels, \n" - "please fix it in %s:%u", filename, lineno); - - /* skip line if not any valid key was found */ - if (!valid) - goto invalid; - /* add rule token */ + rule_tmp.rule.rule.token_count = 1 + rule_tmp.token_cur; if (add_token(rules, &rule_tmp.rule) != 0) goto invalid; /* add tokens to list, sorted by type */ if (sort_token(rules, &rule_tmp) != 0) goto invalid; + return 0; invalid: err(rules->udev, "invalid rule '%s:%u'\n", filename, lineno); @@ -1515,6 +1621,7 @@ static int parse_file(struct udev_rules *rules, const char *filename, unsigned s if (strcmp(label, &rules->buf[rules->tokens[j].rule.label_off]) != 0) continue; rules->tokens[i].key.rule_goto = j; + break; } if (rules->tokens[i].key.rule_goto == 0) err(rules->udev, "GOTO '%s' has no matching label in: '%s'\n", label, filename); @@ -1525,39 +1632,38 @@ static int parse_file(struct udev_rules *rules, const char *filename, unsigned s static int add_matching_files(struct udev *udev, struct udev_list_node *file_list, const char *dirname, const char *suffix) { - struct dirent *ent; DIR *dir; char filename[UTIL_PATH_SIZE]; dbg(udev, "open directory '%s'\n", dirname); dir = opendir(dirname); if (dir == NULL) { - err(udev, "unable to open '%s': %m\n", dirname); + info(udev, "unable to open '%s': %m\n", dirname); return -1; } while (1) { - ent = readdir(dir); - if (ent == NULL || ent->d_name[0] == '\0') + struct dirent *dent; + + dent = readdir(dir); + if (dent == NULL || dent->d_name[0] == '\0') break; - if ((ent->d_name[0] == '.') || (ent->d_name[0] == '#')) + if (dent->d_name[0] == '.') continue; /* look for file matching with specified suffix */ if (suffix != NULL) { const char *ext; - ext = strrchr(ent->d_name, '.'); + ext = strrchr(dent->d_name, '.'); if (ext == NULL) continue; if (strcmp(ext, suffix) != 0) continue; } - dbg(udev, "put file '%s/%s' into list\n", dirname, ent->d_name); - - snprintf(filename, sizeof(filename), "%s/%s", dirname, ent->d_name); - filename[sizeof(filename)-1] = '\0'; + util_strscpyl(filename, sizeof(filename), dirname, "/", dent->d_name, NULL); + dbg(udev, "put file '%s' into list\n", filename); udev_list_entry_add(udev, file_list, filename, NULL, 1, 1); } @@ -1571,9 +1677,7 @@ struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names) struct stat statbuf; struct udev_list_node file_list; struct udev_list_entry *file_loop, *file_tmp; - unsigned int prev_rule; struct token end_token; - unsigned int i; rules = malloc(sizeof(struct udev_rules)); if (rules == NULL) @@ -1588,6 +1692,7 @@ struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names) if (rules->tokens == NULL) return NULL; rules->token_max = PREALLOC_TOKEN; + rules->buf = malloc(PREALLOC_STRBUF); if (rules->buf == NULL) return NULL; @@ -1598,6 +1703,14 @@ struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names) dbg(udev, "prealloc %zu bytes tokens (%u * %zu bytes), %zu bytes buffer\n", rules->token_max * sizeof(struct token), rules->token_max, sizeof(struct token), rules->buf_max); + rules->trie_nodes = malloc(PREALLOC_TRIE * sizeof(struct trie_node)); + if (rules->trie_nodes == NULL) + return NULL; + rules->trie_nodes_max = PREALLOC_TRIE; + /* offset 0 is the trie root, with an empty string */ + memset(rules->trie_nodes, 0x00, sizeof(struct trie_node)); + rules->trie_nodes_cur = 1; + if (udev_get_rules_path(udev) != NULL) { /* custom rules location for testing */ add_matching_files(udev, &file_list, udev_get_rules_path(udev), ".rules"); @@ -1610,8 +1723,7 @@ struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names) add_matching_files(udev, &file_list, SYSCONFDIR "/udev/rules.d", ".rules"); /* read dynamic/temporary rules */ - util_strlcpy(filename, udev_get_dev_path(udev), sizeof(filename)); - util_strlcat(filename, "/.udev/rules.d", sizeof(filename)); + util_strscpyl(filename, sizeof(filename), udev_get_dev_path(udev), "/.udev/rules.d", NULL); if (stat(filename, &statbuf) != 0) { util_create_path(udev, filename); udev_selinux_setfscreatecon(udev, filename, S_IFDIR|0755); @@ -1689,15 +1801,6 @@ struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names) end_token.type = TK_END; add_token(rules, &end_token); - /* link all TK_RULE tokens to be able to fast-forward to next TK_RULE */ - prev_rule = 0; - for (i = 1; i < rules->token_cur; i++) { - if (rules->tokens[i].type == TK_RULE) { - rules->tokens[prev_rule].rule.next_rule = i; - prev_rule = i; - } - } - /* shrink allocated token and string buffer */ if (rules->token_cur < rules->token_max) { struct token *tokens; @@ -1717,8 +1820,17 @@ struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names) rules->buf_max = rules->buf_cur; } } - info(udev, "shrunk to %lu bytes tokens (%u * %zu bytes), %zu bytes buffer\n", + info(udev, "rules use %zu bytes tokens (%u * %zu bytes), %zu bytes buffer\n", rules->token_max * sizeof(struct token), rules->token_max, sizeof(struct token), rules->buf_max); + info(udev, "temporary index used %zu bytes (%u * %zu bytes)\n", + rules->trie_nodes_cur * sizeof(struct trie_node), + rules->trie_nodes_cur, sizeof(struct trie_node)); + + /* cleanup trie */ + free(rules->trie_nodes); + rules->trie_nodes = NULL; + rules->trie_nodes_cur = 0; + rules->trie_nodes_max = 0; /* cleanup uid/gid cache */ free(rules->uids); @@ -1740,6 +1852,7 @@ void udev_rules_unref(struct udev_rules *rules) return; free(rules->tokens); free(rules->buf); + free(rules->trie_nodes); free(rules->uids); free(rules->gids); free(rules); @@ -1790,7 +1903,7 @@ static int match_key(struct udev_rules *rules, struct token *token, const char * { char value[UTIL_PATH_SIZE]; - util_strlcpy(value, &rules->buf[token->key.value_off], sizeof(value)); + util_strscpy(value, sizeof(value), &rules->buf[token->key.value_off]); key_value = value; while (key_value != NULL) { pos = strchr(key_value, '|'); @@ -1798,7 +1911,7 @@ static int match_key(struct udev_rules *rules, struct token *token, const char * pos[0] = '\0'; pos = &pos[1]; } - dbg(rules->udev, "match %s '%s' <-> '%s'\n", token_str[token->type], key_value, val); + dbg(rules->udev, "match %s '%s' <-> '%s'\n", token_str(token->type), key_value, val); match = (fnmatch(key_value, val, 0) == 0); if (match) break; @@ -1809,54 +1922,69 @@ static int match_key(struct udev_rules *rules, struct token *token, const char * case GL_SOMETHING: match = (val[0] != '\0'); break; - case GL_FORMAT: case GL_UNSET: return -1; } if (match && (token->key.op == OP_MATCH)) { - dbg(rules->udev, "%s is true (matching value)\n", token_str[token->type]); + dbg(rules->udev, "%s is true (matching value)\n", token_str(token->type)); return 0; } if (!match && (token->key.op == OP_NOMATCH)) { - dbg(rules->udev, "%s is true (non-matching value)\n", token_str[token->type]); + dbg(rules->udev, "%s is true (non-matching value)\n", token_str(token->type)); return 0; } - dbg(rules->udev, "%s is not true\n", token_str[token->type]); + dbg(rules->udev, "%s is not true\n", token_str(token->type)); return -1; } static int match_attr(struct udev_rules *rules, struct udev_device *dev, struct udev_event *event, struct token *cur) { - const char *key_name = &rules->buf[cur->key.attr_off]; - const char *key_value = &rules->buf[cur->key.value_off]; - char value[UTIL_NAME_SIZE]; + const char *name; + char nbuf[UTIL_NAME_SIZE]; + const char *value; + char vbuf[UTIL_NAME_SIZE]; size_t len; - value[0] = '\0'; - if (key_name[0] == '[') { - char attr[UTIL_PATH_SIZE]; - - util_strlcpy(attr, key_name, sizeof(attr)); - util_resolve_subsys_kernel(event->udev, attr, value, sizeof(value), 1); - } - if (value[0] == '\0') { - const char *val; - - val = udev_device_get_sysattr_value(dev, key_name); - if (val == NULL) + name = &rules->buf[cur->key.attr_off]; + switch (cur->key.attrsubst) { + case SB_FORMAT: + udev_event_apply_format(event, name, nbuf, sizeof(nbuf)); + name = nbuf; + /* fall through */ + case SB_NONE: + value = udev_device_get_sysattr_value(dev, name); + if (value == NULL) return -1; - util_strlcpy(value, val, sizeof(value)); + break; + case SB_SUBSYS: + if (util_resolve_subsys_kernel(event->udev, name, vbuf, sizeof(vbuf), 1) != 0) + return -1; + value = vbuf; + break; + default: + return -1; } - /* strip trailing whitespace of value, if not asked to match for it */ - len = strlen(key_value); - if (len > 0 && !isspace(key_value[len-1])) { - len = strlen(value); - while (len > 0 && isspace(value[--len])) - value[len] = '\0'; - dbg(rules->udev, "removed trailing whitespace from '%s'\n", value); + /* remove trailing whitespace, if not asked to match for it */ + len = strlen(value); + if (len > 0 && isspace(value[len-1])) { + const char *key_value; + size_t klen; + + key_value = &rules->buf[cur->key.value_off]; + klen = strlen(key_value); + if (klen > 0 && !isspace(key_value[klen-1])) { + if (value != vbuf) { + util_strscpy(vbuf, sizeof(vbuf), value); + value = vbuf; + } + while (len > 0 && isspace(vbuf[--len])) + vbuf[len] = '\0'; + dbg(rules->udev, "removed trailing whitespace from '%s'\n", value); + } } + return match_key(rules, cur, value); } @@ -1885,8 +2013,6 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event cur = &rules->tokens[0]; rule = cur; while (1) { - unsigned int idx; - dump_token(rules, cur); switch (cur->type) { case TK_RULE: @@ -1894,7 +2020,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event rule = cur; /* possibly skip rules which want to set NAME, SYMLINK, OWNER, GROUP, MODE */ if (!can_set_name && rule->rule.flags) - ;//goto nomatch; + goto nomatch; esc = ESCAPE_UNSET; break; case TK_M_ACTION: @@ -1934,13 +2060,10 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event break; case TK_M_ENV: { - struct udev_list_entry *list_entry; const char *key_name = &rules->buf[cur->key.attr_off]; const char *value; - list_entry = udev_device_get_properties_list_entry(event->dev); - list_entry = udev_list_entry_get_by_name(list_entry, key_name); - value = udev_list_entry_get_value(list_entry); + value = udev_device_get_property_value(event->dev, key_name); if (value == NULL) { dbg(event->udev, "ENV{%s} is not set, treat as empty\n", key_name); value = ""; @@ -1962,8 +2085,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event char filename[UTIL_PATH_SIZE]; int found; - util_strlcpy(filename, &rules->buf[cur->key.value_off], sizeof(filename)); - udev_event_apply_format(event, filename, sizeof(filename)); + udev_event_apply_format(event, &rules->buf[cur->key.value_off], filename, sizeof(filename)); found = (wait_for_file(event->dev, filename, 10) == 0); if (!found && (cur->key.op != OP_NOMATCH)) goto nomatch; @@ -2035,18 +2157,16 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event struct stat statbuf; int match; - util_strlcpy(filename, &rules->buf[cur->key.value_off], sizeof(filename)); - udev_event_apply_format(event, filename, sizeof(filename)); - if (util_resolve_subsys_kernel(event->udev, NULL, filename, sizeof(filename), 0) != 0) + udev_event_apply_format(event, &rules->buf[cur->key.value_off], filename, sizeof(filename)); + if (util_resolve_subsys_kernel(event->udev, filename, filename, sizeof(filename), 0) != 0) { if (filename[0] != '/') { char tmp[UTIL_PATH_SIZE]; - util_strlcpy(tmp, udev_device_get_syspath(event->dev), sizeof(tmp)); - util_strlcat(tmp, "/", sizeof(tmp)); - util_strlcat(tmp, filename, sizeof(tmp)); - util_strlcpy(filename, tmp, sizeof(filename)); + util_strscpy(tmp, sizeof(tmp), filename); + util_strscpyl(filename, sizeof(filename), + udev_device_get_syspath(event->dev), "/", tmp, NULL); } - + } attr_subst_subdir(filename, sizeof(filename)); match = (stat(filename, &statbuf) == 0); @@ -2070,8 +2190,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event free(event->program_result); event->program_result = NULL; - util_strlcpy(program, &rules->buf[cur->key.value_off], sizeof(program)); - udev_event_apply_format(event, program, sizeof(program)); + udev_event_apply_format(event, &rules->buf[cur->key.value_off], program, sizeof(program)); envp = udev_device_get_properties_envp(event->dev); info(event->udev, "PROGRAM '%s' %s:%u\n", program, @@ -2085,7 +2204,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event util_remove_trailing_chars(result, '\n'); if (esc == ESCAPE_UNSET || esc == ESCAPE_REPLACE) { - count = util_replace_chars(result, ALLOWED_CHARS_INPUT); + count = udev_util_replace_chars(result, UDEV_ALLOWED_CHARS_INPUT); if (count > 0) info(event->udev, "%i character(s) replaced\n" , count); } @@ -2100,8 +2219,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event { char import[UTIL_PATH_SIZE]; - util_strlcpy(import, &rules->buf[cur->key.value_off], sizeof(import)); - udev_event_apply_format(event, import, sizeof(import)); + udev_event_apply_format(event, &rules->buf[cur->key.value_off], import, sizeof(import)); if (import_file_into_properties(event->dev, import) != 0) if (cur->key.op != OP_NOMATCH) goto nomatch; @@ -2111,8 +2229,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event { char import[UTIL_PATH_SIZE]; - util_strlcpy(import, &rules->buf[cur->key.value_off], sizeof(import)); - udev_event_apply_format(event, import, sizeof(import)); + udev_event_apply_format(event, &rules->buf[cur->key.value_off], import, sizeof(import)); info(event->udev, "IMPORT '%s' %s:%u\n", import, &rules->buf[rule->rule.filename_off], @@ -2126,8 +2243,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event { char import[UTIL_PATH_SIZE]; - util_strlcpy(import, &rules->buf[cur->key.value_off], sizeof(import)); - udev_event_apply_format(event, import, sizeof(import)); + udev_event_apply_format(event, &rules->buf[cur->key.value_off], import, sizeof(import)); if (import_parent_into_properties(event->dev, import) != 0) if (cur->key.op != OP_NOMATCH) goto nomatch; @@ -2155,6 +2271,9 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event break; udev_device_set_num_fake_partitions(event->dev, cur->key.num_fake_part); break; + case TK_A_INOTIFY_WATCH: + event->inotify_watch = cur->key.watch; + break; case TK_A_DEVLINK_PRIO: udev_device_set_devlink_priority(event->dev, cur->key.devlink_prio); break; @@ -2166,8 +2285,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event break; if (cur->key.op == OP_ASSIGN_FINAL) event->owner_final = 1; - util_strlcpy(owner, &rules->buf[cur->key.value_off], sizeof(owner)); - udev_event_apply_format(event, owner, sizeof(owner)); + udev_event_apply_format(event, &rules->buf[cur->key.value_off], owner, sizeof(owner)); event->uid = util_lookup_user(event->udev, owner); info(event->udev, "OWNER %u %s:%u\n", event->uid, @@ -2183,8 +2301,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event break; if (cur->key.op == OP_ASSIGN_FINAL) event->group_final = 1; - util_strlcpy(group, &rules->buf[cur->key.value_off], sizeof(group)); - udev_event_apply_format(event, group, sizeof(group)); + udev_event_apply_format(event, &rules->buf[cur->key.value_off], group, sizeof(group)); event->gid = util_lookup_group(event->udev, group); info(event->udev, "GROUP %u %s:%u\n", event->gid, @@ -2201,8 +2318,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event break; if (cur->key.op == OP_ASSIGN_FINAL) event->mode_final = 1; - util_strlcpy(mode, &rules->buf[cur->key.value_off], sizeof(mode)); - udev_event_apply_format(event, mode, sizeof(mode)); + udev_event_apply_format(event, &rules->buf[cur->key.value_off], mode, sizeof(mode)); event->mode = strtol(mode, &endptr, 8); if (endptr[0] != '\0') { err(event->udev, "invalide mode '%s' set default mode 0660\n", mode); @@ -2256,8 +2372,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event char temp_value[UTIL_NAME_SIZE]; struct udev_list_entry *entry; - util_strlcpy(temp_value, value, sizeof(temp_value)); - udev_event_apply_format(event, temp_value, sizeof(temp_value)); + udev_event_apply_format(event, value, temp_value, sizeof(temp_value)); entry = udev_device_add_property(event->dev, name, temp_value); /* store in db */ udev_list_entry_set_flag(entry, 1); @@ -2276,24 +2391,18 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event break; if (cur->key.op == OP_ASSIGN_FINAL) event->name_final = 1; - if (name[0] == '\0') { - free(event->name); - event->name = NULL; - break; - } - util_strlcpy(name_str, name, sizeof(name_str)); - udev_event_apply_format(event, name_str, sizeof(name_str)); + udev_event_apply_format(event, name, name_str, sizeof(name_str)); if (esc == ESCAPE_UNSET || esc == ESCAPE_REPLACE) { - count = util_replace_chars(name_str, ALLOWED_CHARS_FILE); + count = udev_util_replace_chars(name_str, "/"); if (count > 0) info(event->udev, "%i character(s) replaced\n", count); - free(event->name); - event->name = strdup(name_str); - info(event->udev, "NAME '%s' %s:%u\n", - event->name, - &rules->buf[rule->rule.filename_off], - rule->rule.filename_line); } + free(event->name); + event->name = strdup(name_str); + info(event->udev, "NAME '%s' %s:%u\n", + event->name, + &rules->buf[rule->rule.filename_off], + rule->rule.filename_line); break; } case TK_A_DEVLINK: @@ -2313,12 +2422,11 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event udev_device_cleanup_devlinks_list(event->dev); /* allow multiple symlinks separated by spaces */ - util_strlcpy(temp, &rules->buf[cur->key.value_off], sizeof(temp)); - udev_event_apply_format(event, temp, sizeof(temp)); + udev_event_apply_format(event, &rules->buf[cur->key.value_off], temp, sizeof(temp)); if (esc == ESCAPE_UNSET) - count = util_replace_chars(temp, ALLOWED_CHARS_FILE " "); + count = udev_util_replace_chars(temp, "/ "); else if (esc == ESCAPE_REPLACE) - count = util_replace_chars(temp, ALLOWED_CHARS_FILE); + count = udev_util_replace_chars(temp, "/"); if (count > 0) info(event->udev, "%i character(s) replaced\n" , count); dbg(event->udev, "rule applied, added symlink(s) '%s'\n", temp); @@ -2332,9 +2440,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event pos, &rules->buf[rule->rule.filename_off], rule->rule.filename_line); - util_strlcpy(filename, udev_get_dev_path(event->udev), sizeof(filename)); - util_strlcat(filename, "/", sizeof(filename)); - util_strlcat(filename, pos, sizeof(filename)); + util_strscpyl(filename, sizeof(filename), udev_get_dev_path(event->udev), "/", pos, NULL); udev_device_add_devlink(event->dev, filename); while (isspace(next[1])) next++; @@ -2346,9 +2452,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event pos, &rules->buf[rule->rule.filename_off], rule->rule.filename_line); - util_strlcpy(filename, udev_get_dev_path(event->udev), sizeof(filename)); - util_strlcat(filename, "/", sizeof(filename)); - util_strlcat(filename, pos, sizeof(filename)); + util_strscpyl(filename, sizeof(filename), udev_get_dev_path(event->udev), "/", pos, NULL); udev_device_add_devlink(event->dev, filename); } } @@ -2366,25 +2470,18 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event char value[UTIL_NAME_SIZE]; FILE *f; - util_strlcpy(attr, key_name, sizeof(attr)); - if (util_resolve_subsys_kernel(event->udev, key_name, attr, sizeof(attr), 0) != 0) { - util_strlcpy(attr, udev_device_get_syspath(event->dev), sizeof(attr)); - util_strlcat(attr, "/", sizeof(attr)); - util_strlcat(attr, key_name, sizeof(attr)); - } - + if (util_resolve_subsys_kernel(event->udev, key_name, attr, sizeof(attr), 0) != 0) + util_strscpyl(attr, sizeof(attr), udev_device_get_syspath(event->dev), "/", key_name, NULL); attr_subst_subdir(attr, sizeof(attr)); - util_strlcpy(value, &rules->buf[cur->key.value_off], sizeof(value)); - udev_event_apply_format(event, value, sizeof(value)); + udev_event_apply_format(event, &rules->buf[cur->key.value_off], value, sizeof(value)); info(event->udev, "ATTR '%s' writing '%s' %s:%u\n", attr, value, &rules->buf[rule->rule.filename_off], rule->rule.filename_line); f = fopen(attr, "w"); if (f != NULL) { - if (!event->test) - if (fprintf(f, "%s", value) <= 0) - err(event->udev, "error writing ATTR{%s}: %m\n", attr); + if (fprintf(f, "%s", value) <= 0) + err(event->udev, "error writing ATTR{%s}: %m\n", attr); fclose(f); } else { err(event->udev, "error opening ATTR{%s} for writing: %m\n", attr); @@ -2408,6 +2505,8 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event break; } case TK_A_GOTO: + if (cur->key.rule_goto == 0) + break; cur = &rules->tokens[cur->key.rule_goto]; continue; case TK_A_LAST_RULE: @@ -2426,10 +2525,8 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event continue; nomatch: /* fast-forward to next rule */ - idx = rule->rule.next_rule; - if (idx == 0) - return 0; - dbg(rules->udev, "forward to rule: %u\n", idx); - cur = &rules->tokens[idx]; + cur = rule + rule->rule.token_count; + dbg(rules->udev, "forward to rule: %u\n", + (unsigned int) (cur - rules->tokens)); } }