X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=udev%2Fudev-rules.c;h=44b26906b48465d8cfe3de3583d14933f8c59223;hp=55e27b7bcacf8e71daee24967ac8697d28733b0f;hb=cd94c04c518fffbf7f2c173952d77414a5d6bb6b;hpb=84629ccd85cb65c82dd9cb1c5411c55f2c0abbf0

diff --git a/udev/udev-rules.c b/udev/udev-rules.c
index 55e27b7bc..44b26906b 100644
--- a/udev/udev-rules.c
+++ b/udev/udev-rules.c
@@ -31,28 +31,57 @@
 #define PREALLOC_TOKEN			2048
 #define PREALLOC_STRBUF			32 * 1024
 
-enum key_operation {
-	KEY_OP_UNSET,
-	KEY_OP_MATCH,
-	KEY_OP_NOMATCH,
-	KEY_OP_ADD,
-	KEY_OP_ASSIGN,
-	KEY_OP_ASSIGN_FINAL,
+/* KEY=="", KEY!="", KEY+="", KEY="", KEY:="" */
+enum operation_type {
+	OP_UNSET,
+
+	OP_MATCH,
+	OP_NOMATCH,
+	OP_MATCH_MAX,
+
+	OP_ADD,
+	OP_ASSIGN,
+	OP_ASSIGN_FINAL,
 };
 
 static const char *operation_str[] = {
-	[KEY_OP_MATCH] =	"match",
-	[KEY_OP_NOMATCH] =	"nomatch",
-	[KEY_OP_ADD] =		"add",
-	[KEY_OP_ASSIGN] =	"assign",
-	[KEY_OP_ASSIGN_FINAL] =	"assign-final",
+	[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",
 };
 
+enum string_glob_type {
+	GL_UNSET,
+	GL_PLAIN,			/* no special chars */
+	GL_GLOB,			/* shell globs ?,*,[] */
+	GL_SPLIT,			/* multi-value A|B */
+	GL_SPLIT_GLOB,			/* multi-value with glob A*|B* */
+	GL_SOMETHING,			/* commonly used "?*" */
+	GL_FORMAT,
+};
+
+#ifdef DEBUG
+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",
+};
+#endif
+
+/* tokens of a rule are sorted/handled in this order */
 enum token_type {
-	TK_UNDEF,
+	TK_UNSET,
 	TK_RULE,
 
-	TK_M_WAITFOR,			/* val */
 	TK_M_ACTION,			/* val */
 	TK_M_DEVPATH,			/* val */
 	TK_M_KERNEL,			/* val */
@@ -61,13 +90,14 @@ enum token_type {
 	TK_M_ENV,			/* val, attr */
 	TK_M_SUBSYSTEM,			/* val */
 	TK_M_DRIVER,			/* val */
+	TK_M_WAITFOR,			/* val */
 	TK_M_ATTR,			/* val, attr */
 
 	TK_M_KERNELS,			/* val */
 	TK_M_SUBSYSTEMS,		/* val */
 	TK_M_DRIVERS,			/* val */
 	TK_M_ATTRS,			/* val, attr */
-	TK_PARENTS_MAX,
+	TK_M_PARENTS_MAX,
 
 	TK_M_TEST,			/* val, mode_t */
 	TK_M_PROGRAM,			/* val */
@@ -75,6 +105,7 @@ enum token_type {
 	TK_M_IMPORT_PROG,		/* val */
 	TK_M_IMPORT_PARENT,		/* val */
 	TK_M_RESULT,			/* val */
+	TK_M_MAX,
 
 	TK_A_IGNORE_DEVICE,
 	TK_A_STRING_ESCAPE_NONE,
@@ -101,10 +132,9 @@ enum token_type {
 };
 
 static const char *token_str[] = {
-	[TK_UNDEF] =			"UNDEF",
+	[TK_UNSET] =			"UNSET",
 	[TK_RULE] =			"RULE",
 
-	[TK_M_WAITFOR] =		"M WAITFOR",
 	[TK_M_ACTION] =			"M ACTION",
 	[TK_M_DEVPATH] =		"M DEVPATH",
 	[TK_M_KERNEL] =			"M KERNEL",
@@ -113,13 +143,14 @@ static const char *token_str[] = {
 	[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_KERNELS] =		"M KERNELS",
 	[TK_M_SUBSYSTEMS] =		"M SUBSYSTEMS",
 	[TK_M_DRIVERS] =		"M DRIVERS",
 	[TK_M_ATTRS] =			"M ATTRS",
-	[TK_PARENTS_MAX] =		"PARENTS_MAX",
+	[TK_M_PARENTS_MAX] =		"M PARENTS_MAX",
 
 	[TK_M_TEST] =			"M TEST",
 	[TK_M_PROGRAM] =		"M PROGRAM",
@@ -127,6 +158,7 @@ static const char *token_str[] = {
 	[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",
@@ -161,7 +193,8 @@ struct token {
 			unsigned int filename_off;
 		} rule;
 		struct {
-			enum key_operation op;
+			unsigned short op;
+			unsigned short glob;
 			unsigned int value_off;
 			union {
 				unsigned int attr_off;
@@ -187,32 +220,57 @@ struct rule_tmp {
 	unsigned int token_cur;
 };
 
+struct uid_gid {
+	unsigned int name_off;
+	union {
+		uid_t	uid;
+		gid_t	gid;
+	};
+};
+
 struct udev_rules {
 	struct udev *udev;
 	int resolve_names;
+
+	/* every key in the rules file becomes a token */
 	struct token *tokens;
 	unsigned int token_cur;
 	unsigned int token_max;
+
+	/* all key strings are copied to a single string buffer */
 	char *buf;
 	size_t buf_cur;
 	size_t buf_max;
 	unsigned int buf_count;
+
+	/* during rule parsing, we cache uid/gid lookup results */
+	struct uid_gid *uids;
+	unsigned int uids_cur;
+	unsigned int uids_max;
+	struct uid_gid *gids;
+	unsigned int gids_cur;
+	unsigned int gids_max;
 };
 
-/* we could lookup and return existing strings, or tails of strings */
+/* NOTE: we could lookup and return existing strings, or tails of strings */
 static int add_string(struct udev_rules *rules, const char *str)
 {
 	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) {
 		char *buf;
 		unsigned int add;
 
 		/* double the buffer size */
 		add = rules->buf_max;
-		if (add < len)
-			add = len;
+		if (add < len * 8)
+			add = len * 8;
 
 		buf = realloc(rules->buf, rules->buf_max + add);
 		if (buf == NULL)
@@ -231,14 +289,15 @@ static int add_string(struct udev_rules *rules, const char *str)
 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;
 		unsigned int add;
 
 		/* double the buffer size */
 		add = rules->token_max;
-		if (add < 1)
-			add = 1;
+		if (add < 8)
+			add = 8;
 
 		tokens = realloc(rules->tokens, (rules->token_max + add ) * sizeof(struct token));
 		if (tokens == NULL)
@@ -252,6 +311,92 @@ static int add_token(struct udev_rules *rules, struct token *token)
 	return 0;
 }
 
+static uid_t add_uid(struct udev_rules *rules, const char *owner)
+{
+	unsigned int i;
+	uid_t uid;
+	unsigned int off;
+
+	/* lookup, if we know it already */
+	for (i = 0; i < rules->uids_cur; i++) {
+		off = rules->uids[i].name_off;
+		if (strcmp(&rules->buf[off], owner) == 0) {
+			uid = rules->uids[i].uid;
+			dbg(rules->udev, "return existing %u for '%s'\n", uid, owner);
+			return uid;
+		}
+	}
+	uid = util_lookup_user(rules->udev, owner);
+
+	/* grow buffer if needed */
+	if (rules->uids_cur+1 >= rules->uids_max) {
+		struct uid_gid *uids;
+		unsigned int add;
+
+		/* double the buffer size */
+		add = rules->uids_max;
+		if (add < 1)
+			add = 8;
+
+		uids = realloc(rules->uids, (rules->uids_max + add ) * sizeof(struct uid_gid));
+		if (uids == NULL)
+			return uid;
+		info(rules->udev, "extend uids from %u to %u\n", rules->uids_max, rules->uids_max + add);
+		rules->uids = uids;
+		rules->uids_max += add;
+	}
+	rules->uids[rules->uids_cur].uid = uid;
+	off = add_string(rules, owner);
+	if (off <= 0)
+		return uid;
+	rules->uids[rules->uids_cur].name_off = off;
+	rules->uids_cur++;
+	return uid;
+}
+
+static gid_t add_gid(struct udev_rules *rules, const char *group)
+{
+	unsigned int i;
+	gid_t gid;
+	unsigned int off;
+
+	/* lookup, if we know it already */
+	for (i = 0; i < rules->gids_cur; i++) {
+		off = rules->gids[i].name_off;
+		if (strcmp(&rules->buf[off], group) == 0) {
+			gid = rules->gids[i].gid;
+			dbg(rules->udev, "return existing %u for '%s'\n", gid, group);
+			return gid;
+		}
+	}
+	gid = util_lookup_group(rules->udev, group);
+
+	/* grow buffer if needed */
+	if (rules->gids_cur+1 >= rules->gids_max) {
+		struct uid_gid *gids;
+		unsigned int add;
+
+		/* double the buffer size */
+		add = rules->gids_max;
+		if (add < 1)
+			add = 8;
+
+		gids = realloc(rules->gids, (rules->gids_max + add ) * sizeof(struct uid_gid));
+		if (gids == NULL)
+			return gid;
+		info(rules->udev, "extend gids from %u to %u\n", rules->gids_max, rules->gids_max + add);
+		rules->gids = gids;
+		rules->gids_max += add;
+	}
+	rules->gids[rules->gids_cur].gid = gid;
+	off = add_string(rules, group);
+	if (off <= 0)
+		return gid;
+	rules->gids[rules->gids_cur].name_off = off;
+	rules->gids_cur++;
+	return gid;
+}
+
 static int import_property_from_string(struct udev_device *dev, char *line)
 {
 	struct udev *udev = udev_device_get_udev(dev);
@@ -474,7 +619,7 @@ static int attr_subst_subdir(char *attr, size_t len)
 	return found;
 }
 
-static int get_key(struct udev *udev, char **line, char **key, enum key_operation *op, char **value)
+static int get_key(struct udev *udev, char **line, char **key, enum operation_type *op, char **value)
 {
 	char *linepos;
 	char *temp;
@@ -516,19 +661,19 @@ static int get_key(struct udev *udev, char **line, char **key, enum key_operatio
 
 	/* get operation type */
 	if (linepos[0] == '=' && linepos[1] == '=') {
-		*op = KEY_OP_MATCH;
+		*op = OP_MATCH;
 		linepos += 2;
 	} else if (linepos[0] == '!' && linepos[1] == '=') {
-		*op = KEY_OP_NOMATCH;
+		*op = OP_NOMATCH;
 		linepos += 2;
 	} else if (linepos[0] == '+' && linepos[1] == '=') {
-		*op = KEY_OP_ADD;
+		*op = OP_ADD;
 		linepos += 2;
 	} else if (linepos[0] == '=') {
-		*op = KEY_OP_ASSIGN;
+		*op = OP_ASSIGN;
 		linepos++;
 	} else if (linepos[0] == ':' && linepos[1] == '=') {
-		*op = KEY_OP_ASSIGN_FINAL;
+		*op = OP_ASSIGN_FINAL;
 		linepos += 2;
 	} else
 		return -1;
@@ -542,13 +687,14 @@ static int get_key(struct udev *udev, char **line, char **key, enum key_operatio
 	if (linepos[0] == '\0')
 		return -1;
 
-	/* get the value*/
+	/* get the value */
 	if (linepos[0] == '"')
 		linepos++;
 	else
 		return -1;
 	*value = linepos;
 
+	/* terminate */
 	temp = strchr(linepos, '"');
 	if (!temp)
 		return -1;
@@ -583,20 +729,22 @@ static char *get_key_attribute(struct udev *udev, char *str)
 }
 
 static int rule_add_token(struct rule_tmp *rule_tmp, enum token_type type,
-			  enum key_operation op,
+			  enum operation_type op,
 			  const char *value, const void *data)
 {
 	struct token *token = &rule_tmp->token[rule_tmp->token_cur];
 	const char *attr = data;
-	mode_t mode = 0000;
+	enum string_glob_type glob;
+
+	memset(token, 0x00, sizeof(struct token));
 
 	switch (type) {
-	case TK_M_WAITFOR:
 	case TK_M_ACTION:
 	case TK_M_DEVPATH:
 	case TK_M_KERNEL:
 	case TK_M_SUBSYSTEM:
 	case TK_M_DRIVER:
+	case TK_M_WAITFOR:
 	case TK_M_DEVLINK:
 	case TK_M_NAME:
 	case TK_M_KERNELS:
@@ -624,10 +772,9 @@ static int rule_add_token(struct rule_tmp *rule_tmp, enum token_type type,
 		token->key.attr_off = add_string(rule_tmp->rules, attr);
 		break;
 	case TK_M_TEST:
-		if (data != NULL)
-			mode = *(mode_t *)data;
 		token->key.value_off = add_string(rule_tmp->rules, value);
-		token->key.mode = mode;
+		if (data != NULL)
+			token->key.mode = *(mode_t *)data;
 		break;
 	case TK_A_IGNORE_DEVICE:
 	case TK_A_STRING_ESCAPE_NONE:
@@ -658,14 +805,44 @@ static int rule_add_token(struct rule_tmp *rule_tmp, enum token_type type,
 		token->key.event_timeout = *(int *)data;
 		break;
 	case TK_RULE:
-	case TK_PARENTS_MAX:
+	case TK_M_PARENTS_MAX:
+	case TK_M_MAX:
 	case TK_END:
-	case TK_UNDEF:
+	case TK_UNSET:
 		err(rule_tmp->rules->udev, "wrong type %u\n", 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;
+			}
+		} else {
+			/* check if we need to substitute format strings for matching rules */
+			if (strchr(value, '%') != NULL || strchr(value, '$') != NULL)
+				glob = GL_FORMAT;
+		}
+	}
+
 	token->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");
@@ -678,7 +855,8 @@ static int rule_add_token(struct rule_tmp *rule_tmp, enum token_type type,
 static void dump_token(struct udev_rules *rules, struct token *token)
 {
 	enum token_type type = token->type;
-	enum key_operation op = token->key.op;
+	enum operation_type op = token->key.op;
+	enum string_glob_type glob = token->key.glob;
 	const char *value = &rules->buf[token->key.value_off];
 	const char *attr = &rules->buf[token->key.attr_off];
 
@@ -696,12 +874,12 @@ static void dump_token(struct udev_rules *rules, struct token *token)
 			    &rules->buf[token->rule.label_off]);
 			break;
 		}
-	case TK_M_WAITFOR:
 	case TK_M_ACTION:
 	case TK_M_DEVPATH:
 	case TK_M_KERNEL:
 	case TK_M_SUBSYSTEM:
 	case TK_M_DRIVER:
+	case TK_M_WAITFOR:
 	case TK_M_DEVLINK:
 	case TK_M_NAME:
 	case TK_M_KERNELS:
@@ -718,14 +896,16 @@ static void dump_token(struct udev_rules *rules, struct token *token)
 	case TK_A_GROUP:
 	case TK_A_MODE:
 	case TK_A_RUN:
-		dbg(rules->udev, "%s %s '%s'\n", token_str[type], operation_str[op], value);
+		dbg(rules->udev, "%s %s '%s'(%s)\n",
+		    token_str[type], operation_str[op], value, string_glob_str[glob]);
 		break;
 	case TK_M_ATTR:
 	case TK_M_ATTRS:
 	case TK_M_ENV:
 	case TK_A_ATTR:
 	case TK_A_ENV:
-		dbg(rules->udev, "%s %s '%s' '%s'\n", token_str[type], operation_str[op], attr, value);
+		dbg(rules->udev, "%s %s '%s' '%s'(%s)\n",
+		    token_str[type], operation_str[op], attr, value, string_glob_str[glob]);
 		break;
 	case TK_A_IGNORE_DEVICE:
 	case TK_A_STRING_ESCAPE_NONE:
@@ -735,7 +915,8 @@ static void dump_token(struct udev_rules *rules, struct token *token)
 		dbg(rules->udev, "%s\n", token_str[type]);
 		break;
 	case TK_M_TEST:
-		dbg(rules->udev, "%s %s '%s' %#o\n", token_str[type], operation_str[op], value, token->key.mode);
+		dbg(rules->udev, "%s %s '%s'(%s) %#o\n",
+		    token_str[type], operation_str[op], value, string_glob_str[glob], token->key.mode);
 		break;
 	case TK_A_NUM_FAKE_PART:
 		dbg(rules->udev, "%s %u\n", token_str[type], token->key.num_fake_part);
@@ -761,8 +942,9 @@ static void dump_token(struct udev_rules *rules, struct token *token)
 	case TK_END:
 		dbg(rules->udev, "* %s\n", token_str[type]);
 		break;
-	case TK_PARENTS_MAX:
-	case TK_UNDEF:
+	case TK_M_PARENTS_MAX:
+	case TK_M_MAX:
+	case TK_UNSET:
 		dbg(rules->udev, "unknown type %u\n", type);
 		break;
 	}
@@ -792,15 +974,15 @@ static int sort_token(struct udev_rules *rules, struct rule_tmp *rule_tmp)
 	unsigned int end = rule_tmp->token_cur;
 
 	for (i = 0; i < rule_tmp->token_cur; i++) {
-		enum token_type next_val = TK_UNDEF;
+		enum token_type next_val = TK_UNSET;
 		unsigned int next_idx;
 		unsigned int j;
 
 		/* find smallest value */
 		for (j = start; j < end; j++) {
-			if (rule_tmp->token[j].type == TK_UNDEF)
+			if (rule_tmp->token[j].type == TK_UNSET)
 				continue;
-			if (next_val == TK_UNDEF || rule_tmp->token[j].type < next_val) {
+			if (next_val == TK_UNSET || rule_tmp->token[j].type < next_val) {
 				next_val = rule_tmp->token[j].type;
 				next_idx = j;
 			}
@@ -809,7 +991,7 @@ static int sort_token(struct udev_rules *rules, struct rule_tmp *rule_tmp)
 		/* add token and mark done */
 		if (add_token(rules, &rule_tmp->token[next_idx]) != 0)
 			return -1;
-		rule_tmp->token[next_idx].type = TK_UNDEF;
+		rule_tmp->token[next_idx].type = TK_UNSET;
 
 		/* shrink range */
 		if (next_idx == start)
@@ -838,13 +1020,13 @@ static int add_rule(struct udev_rules *rules, char *line,
 	while (1) {
 		char *key;
 		char *value;
-		enum key_operation op = KEY_OP_UNSET;
+		enum operation_type op;
 
 		if (get_key(rules->udev, &linepos, &key, &op, &value) != 0)
 			break;
 
 		if (strcasecmp(key, "ACTION") == 0) {
-			if (op != KEY_OP_MATCH && op != KEY_OP_NOMATCH) {
+			if (op > OP_MATCH_MAX) {
 				err(rules->udev, "invalid ACTION operation\n");
 				goto invalid;
 			}
@@ -854,7 +1036,7 @@ static int add_rule(struct udev_rules *rules, char *line,
 		}
 
 		if (strcasecmp(key, "DEVPATH") == 0) {
-			if (op != KEY_OP_MATCH && op != KEY_OP_NOMATCH) {
+			if (op > OP_MATCH_MAX) {
 				err(rules->udev, "invalid DEVPATH operation\n");
 				goto invalid;
 			}
@@ -864,7 +1046,7 @@ static int add_rule(struct udev_rules *rules, char *line,
 		}
 
 		if (strcasecmp(key, "KERNEL") == 0) {
-			if (op != KEY_OP_MATCH && op != KEY_OP_NOMATCH) {
+			if (op > OP_MATCH_MAX) {
 				err(rules->udev, "invalid KERNEL operation\n");
 				goto invalid;
 			}
@@ -874,7 +1056,7 @@ static int add_rule(struct udev_rules *rules, char *line,
 		}
 
 		if (strcasecmp(key, "SUBSYSTEM") == 0) {
-			if (op != KEY_OP_MATCH && op != KEY_OP_NOMATCH) {
+			if (op > OP_MATCH_MAX) {
 				err(rules->udev, "invalid SUBSYSTEM operation\n");
 				goto invalid;
 			}
@@ -893,7 +1075,7 @@ static int add_rule(struct udev_rules *rules, char *line,
 		}
 
 		if (strcasecmp(key, "DRIVER") == 0) {
-			if (op != KEY_OP_MATCH && op != KEY_OP_NOMATCH) {
+			if (op > OP_MATCH_MAX) {
 				err(rules->udev, "invalid DRIVER operation\n");
 				goto invalid;
 			}
@@ -908,7 +1090,7 @@ static int add_rule(struct udev_rules *rules, char *line,
 				err(rules->udev, "error parsing ATTR attribute\n");
 				goto invalid;
 			}
-			if (op == KEY_OP_MATCH || op == KEY_OP_NOMATCH) {
+			if (op < OP_MATCH_MAX) {
 				rule_add_token(&rule_tmp, TK_M_ATTR, op, value, attr);
 			} else {
 				rule_add_token(&rule_tmp, TK_A_ATTR, op, value, attr);
@@ -919,7 +1101,7 @@ static int add_rule(struct udev_rules *rules, char *line,
 
 		if (strcasecmp(key, "KERNELS") == 0 ||
 		    strcasecmp(key, "ID") == 0) {
-			if (op != KEY_OP_MATCH && op != KEY_OP_NOMATCH) {
+			if (op > OP_MATCH_MAX) {
 				err(rules->udev, "invalid KERNELS operation\n");
 				goto invalid;
 			}
@@ -930,7 +1112,7 @@ static int add_rule(struct udev_rules *rules, char *line,
 
 		if (strcasecmp(key, "SUBSYSTEMS") == 0 ||
 		    strcasecmp(key, "BUS") == 0) {
-			if (op != KEY_OP_MATCH && op != KEY_OP_NOMATCH) {
+			if (op > OP_MATCH_MAX) {
 				err(rules->udev, "invalid SUBSYSTEMS operation\n");
 				goto invalid;
 			}
@@ -940,7 +1122,7 @@ static int add_rule(struct udev_rules *rules, char *line,
 		}
 
 		if (strcasecmp(key, "DRIVERS") == 0) {
-			if (op != KEY_OP_MATCH && op != KEY_OP_NOMATCH) {
+			if (op > OP_MATCH_MAX) {
 				err(rules->udev, "invalid DRIVERS operation\n");
 				goto invalid;
 			}
@@ -951,7 +1133,7 @@ static int add_rule(struct udev_rules *rules, char *line,
 
 		if (strncasecmp(key, "ATTRS{", sizeof("ATTRS{")-1) == 0 ||
 		    strncasecmp(key, "SYSFS{", sizeof("SYSFS{")-1) == 0) {
-			if (op != KEY_OP_MATCH && op != KEY_OP_NOMATCH) {
+			if (op > OP_MATCH_MAX) {
 				err(rules->udev, "invalid ATTRS operation\n");
 				goto invalid;
 			}
@@ -979,7 +1161,7 @@ static int add_rule(struct udev_rules *rules, char *line,
 			}
 			if (strncmp(attr, "PHYSDEV", 7) == 0)
 				physdev = 1;
-			if (op == KEY_OP_MATCH || op == KEY_OP_NOMATCH) {
+			if (op < OP_MATCH_MAX) {
 				if (rule_add_token(&rule_tmp, TK_M_ENV, op, value, attr) != 0)
 					goto invalid;
 			} else {
@@ -997,7 +1179,7 @@ static int add_rule(struct udev_rules *rules, char *line,
 		}
 
 		if (strcasecmp(key, "RESULT") == 0) {
-			if (op != KEY_OP_MATCH && op != KEY_OP_NOMATCH) {
+			if (op > OP_MATCH_MAX) {
 				err(rules->udev, "invalid RESULT operation\n");
 				goto invalid;
 			}
@@ -1057,7 +1239,7 @@ static int add_rule(struct udev_rules *rules, char *line,
 		if (strncasecmp(key, "TEST", sizeof("TEST")-1) == 0) {
 			mode_t mode = 0;
 
-			if (op != KEY_OP_MATCH && op != KEY_OP_NOMATCH) {
+			if (op > OP_MATCH_MAX) {
 				err(rules->udev, "invalid TEST operation\n");
 				goto invalid;
 			}
@@ -1102,7 +1284,7 @@ static int add_rule(struct udev_rules *rules, char *line,
 		}
 
 		if (strncasecmp(key, "NAME", sizeof("NAME")-1) == 0) {
-			if (op == KEY_OP_MATCH || op == KEY_OP_NOMATCH) {
+			if (op < OP_MATCH_MAX) {
 				rule_add_token(&rule_tmp, TK_M_NAME, op, value, NULL);
 			} else {
 				if (value[0] == '\0')
@@ -1126,13 +1308,13 @@ static int add_rule(struct udev_rules *rules, char *line,
 		}
 
 		if (strcasecmp(key, "SYMLINK") == 0) {
-			if (op == KEY_OP_MATCH || op == KEY_OP_NOMATCH)
-					rule_add_token(&rule_tmp, TK_M_DEVLINK, op, value, NULL);
-				else
-					rule_add_token(&rule_tmp, TK_A_DEVLINK, op, value, NULL);
-				valid = 1;
-				continue;
-			}
+			if (op < OP_MATCH_MAX)
+				rule_add_token(&rule_tmp, TK_M_DEVLINK, op, value, NULL);
+			else
+				rule_add_token(&rule_tmp, TK_A_DEVLINK, op, value, NULL);
+			valid = 1;
+			continue;
+		}
 
 		if (strcasecmp(key, "OWNER") == 0) {
 			uid_t uid;
@@ -1142,7 +1324,7 @@ static int add_rule(struct udev_rules *rules, char *line,
 			if (endptr[0] == '\0') {
 				rule_add_token(&rule_tmp, TK_A_OWNER_ID, op, NULL, &uid);
 			} else if (rules->resolve_names && strchr("$%", value[0]) == NULL) {
-				uid = util_lookup_user(rules->udev, value);
+				uid = add_uid(rules, value);
 				rule_add_token(&rule_tmp, TK_A_OWNER_ID, op, NULL, &uid);
 			} else {
 				rule_add_token(&rule_tmp, TK_A_OWNER, op, value, NULL);
@@ -1159,7 +1341,7 @@ static int add_rule(struct udev_rules *rules, char *line,
 			if (endptr[0] == '\0') {
 				rule_add_token(&rule_tmp, TK_A_GROUP_ID, op, NULL, &gid);
 			} else if (rules->resolve_names && strchr("$%", value[0]) == NULL) {
-				gid = util_lookup_group(rules->udev, value);
+				gid = add_gid(rules, value);
 				rule_add_token(&rule_tmp, TK_A_GROUP_ID, op, NULL, &gid);
 			} else {
 				rule_add_token(&rule_tmp, TK_A_GROUP, op, value, NULL);
@@ -1388,15 +1570,18 @@ struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names)
 
 	/* init token array and string buffer */
 	rules->tokens = malloc(PREALLOC_TOKEN * sizeof(struct token));
-	if (rules->tokens != NULL)
-		rules->token_max = PREALLOC_TOKEN;
+	if (rules->tokens == NULL)
+		return NULL;
+	rules->token_max = PREALLOC_TOKEN;
 	rules->buf = malloc(PREALLOC_STRBUF);
-	if (rules->buf != NULL)
-		rules->buf_max = PREALLOC_STRBUF;
+	if (rules->buf == NULL)
+		return NULL;
+	rules->buf_max = PREALLOC_STRBUF;
+	/* offset 0 is always '\0' */
+	rules->buf[0] = '\0';
+	rules->buf_cur = 1;
 	info(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);
-	/* offset 0 in the string buffer is always empty */
-	add_string(rules, "");
 
 	if (udev_get_rules_path(udev) != NULL) {
 		/* custom rules location for testing */
@@ -1467,7 +1652,16 @@ struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names)
 	end_token.type = TK_END;
 	add_token(rules, &end_token);
 
-	/* shrink allocate buffers */
+	/* 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;
 
@@ -1489,14 +1683,16 @@ struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names)
 	info(udev, "shrunk to %lu bytes tokens (%u * %zu bytes), %zu bytes buffer\n",
 	     rules->token_max * sizeof(struct token), rules->token_max, sizeof(struct token), rules->buf_max);
 
-	/* 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;
-		}
-	}
+	/* cleanup uid/gid cache */
+	free(rules->uids);
+	rules->uids = NULL;
+	rules->uids_cur = 0;
+	rules->uids_max = 0;
+	free(rules->gids);
+	rules->gids = NULL;
+	rules->gids_cur = 0;
+	rules->gids_max = 0;
+
 	dump_rules(rules);
 	return rules;
 }
@@ -1507,12 +1703,13 @@ void udev_rules_unref(struct udev_rules *rules)
 		return;
 	free(rules->tokens);
 	free(rules->buf);
+	free(rules->uids);
+	free(rules->gids);
 	free(rules);
 }
 
 static int match_key(struct udev_rules *rules, struct token *token, const char *val)
 {
-	const char *key_name = token_str[token->type];
 	char *key_value = &rules->buf[token->key.value_off];
 	char *pos;
 	int match = 0;
@@ -1520,37 +1717,75 @@ static int match_key(struct udev_rules *rules, struct token *token, const char *
 	if (val == NULL)
 		val = "";
 
-	/* look for a matching string, parts are separated by '|' */
-	if (strchr(key_value, '|') != NULL) {
-		char value[UTIL_PATH_SIZE];
+	switch (token->key.glob) {
+	case GL_PLAIN:
+		match = (strcmp(key_value, val) == 0);
+		break;
+	case GL_GLOB:
+		match = (fnmatch(key_value, val, 0) == 0);
+		break;
+	case GL_SPLIT:
+		{
+			const char *split;
+			size_t len;
 
-		util_strlcpy(value, &rules->buf[token->key.value_off], sizeof(value));
-		key_value = value;
-		while (key_value != NULL) {
-			pos = strchr(key_value, '|');
-			if (pos != NULL) {
-				pos[0] = '\0';
-				pos = &pos[1];
+			split = &rules->buf[token->key.value_off];
+			len = strlen(val);
+			while (1) {
+				const char *next;
+
+				next = strchr(split, '|');
+				if (next != NULL) {
+					size_t matchlen = (size_t)(next - split);
+
+					match = (matchlen == len && strncmp(split, val, matchlen) == 0);
+					if (match)
+						break;
+				} else {
+					match = (strcmp(split, val) == 0);
+					break;
+				}
+				split = &next[1];
 			}
-			dbg(rules->udev, "match %s '%s' <-> '%s'\n", key_name, key_value, val);
-			match = (fnmatch(key_value, val, 0) == 0);
-			if (match)
-				break;
-			key_value = pos;
+			break;
 		}
-	} else {
-		match = (fnmatch(key_value, val, 0) == 0);
+	case GL_SPLIT_GLOB:
+		{
+			char value[UTIL_PATH_SIZE];
+
+			util_strlcpy(value, &rules->buf[token->key.value_off], sizeof(value));
+			key_value = value;
+			while (key_value != NULL) {
+				pos = strchr(key_value, '|');
+				if (pos != NULL) {
+					pos[0] = '\0';
+					pos = &pos[1];
+				}
+				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;
+				key_value = pos;
+			}
+			break;
+		}
+	case GL_SOMETHING:
+		match = (val[0] != '\0');
+		break;
+	case GL_FORMAT:
+	case GL_UNSET:
+		return -1;
 	}
 
-	if (match && (token->key.op == KEY_OP_MATCH)) {
-		dbg(rules->udev, "%s is true (matching value)\n", key_name);
+	if (match && (token->key.op == OP_MATCH)) {
+		dbg(rules->udev, "%s is true (matching value)\n", token_str[token->type]);
 		return 0;
 	}
-	if (!match && (token->key.op == KEY_OP_NOMATCH)) {
-		dbg(rules->udev, "%s is true (non-matching value)\n", key_name);
+	if (!match && (token->key.op == OP_NOMATCH)) {
+		dbg(rules->udev, "%s is true (non-matching value)\n", token_str[token->type]);
 		return 0;
 	}
-	dbg(rules->udev, "%s is not true\n", key_name);
+	dbg(rules->udev, "%s is not true\n", token_str[token->type]);
 	return -1;
 }
 
@@ -1559,10 +1794,11 @@ static int match_attr(struct udev_rules *rules, struct udev_device *dev, struct
 	char attr[UTIL_PATH_SIZE];
 	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] = "";
+	char value[UTIL_NAME_SIZE];
 	size_t len;
 
 	util_strlcpy(attr, key_name, sizeof(attr));
+	util_strlcpy(value, "", sizeof(value));
 	util_resolve_subsys_kernel(event->udev, attr, value, sizeof(value), 1);
 	if (value[0] == '\0') {
 		const char *val;
@@ -1593,16 +1829,17 @@ enum escape_type {
 
 int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event)
 {
-	struct token *rule;
 	struct token *cur;
+	struct token *rule;
+	enum escape_type esc = ESCAPE_UNSET;
 
 	if (rules->tokens == NULL)
 		return -1;
 
 	/* loop through token list, match, run actions or forward to next rule */
 	cur = &rules->tokens[0];
+	rule = cur;
 	while (cur != NULL && cur->type != TK_END) {
-		enum escape_type esc = ESCAPE_UNSET;
 		unsigned int idx;
 
 		dump_token(rules, cur);
@@ -1612,18 +1849,6 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 			rule = cur;
 			esc = ESCAPE_UNSET;
 			break;
-		case TK_M_WAITFOR:
-			{
-				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));
-				found = (wait_for_file(event->dev, filename, 10) == 0);
-				if (!found && (cur->key.op != KEY_OP_NOMATCH))
-					goto nomatch;
-				break;
-			}
 		case TK_M_ACTION:
 			if (match_key(rules, cur, udev_device_get_action(event->dev)) != 0)
 				goto nomatch;
@@ -1684,6 +1909,18 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 			if (match_key(rules, cur, udev_device_get_driver(event->dev)) != 0)
 				goto nomatch;
 			break;
+		case TK_M_WAITFOR:
+			{
+				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));
+				found = (wait_for_file(event->dev, filename, 10) == 0);
+				if (!found && (cur->key.op != OP_NOMATCH))
+					goto nomatch;
+				break;
+			}
 		case TK_M_ATTR:
 			if (match_attr(rules, event->dev, event, cur) != 0)
 				goto nomatch;
@@ -1697,7 +1934,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 
 				/* get whole sequence of parent matches */
 				next = cur;
-				while (next->type < TK_PARENTS_MAX)
+				while (next->type < TK_M_PARENTS_MAX)
 					next++;
 
 				/* loop over parents */
@@ -1771,9 +2008,9 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 					info(event->udev, "'%s' has mode=%#o and %s %#o\n", filename, statbuf.st_mode,
 					     match ? "matches" : "does not match", cur->key.mode);
 				}
-				if (match && cur->key.op == KEY_OP_NOMATCH)
+				if (match && cur->key.op == OP_NOMATCH)
 					goto nomatch;
-				if (!match && cur->key.op == KEY_OP_MATCH)
+				if (!match && cur->key.op == OP_MATCH)
 					goto nomatch;
 				break;
 			}
@@ -1789,7 +2026,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 				udev_event_apply_format(event, program, sizeof(program));
 				envp = udev_device_get_properties_envp(event->dev);
 				if (util_run_program(event->udev, program, envp, result, sizeof(result), NULL) != 0) {
-					if (cur->key.op != KEY_OP_NOMATCH)
+					if (cur->key.op != OP_NOMATCH)
 						goto nomatch;
 				} else {
 					int count;
@@ -1802,7 +2039,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 					}
 					event->program_result = strdup(result);
 					dbg(event->udev, "storing result '%s'\n", event->program_result);
-					if (cur->key.op == KEY_OP_NOMATCH)
+					if (cur->key.op == OP_NOMATCH)
 						goto nomatch;
 				}
 				break;
@@ -1814,7 +2051,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 				util_strlcpy(import, &rules->buf[cur->key.value_off], sizeof(import));
 				udev_event_apply_format(event, import, sizeof(import));
 				if (import_file_into_properties(event->dev, import) != 0)
-					if (cur->key.op != KEY_OP_NOMATCH)
+					if (cur->key.op != OP_NOMATCH)
 						goto nomatch;
 				break;
 			}
@@ -1825,7 +2062,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 				util_strlcpy(import, &rules->buf[cur->key.value_off], sizeof(import));
 				udev_event_apply_format(event, import, sizeof(import));
 				if (import_program_into_properties(event->dev, import) != 0)
-					if (cur->key.op != KEY_OP_NOMATCH)
+					if (cur->key.op != OP_NOMATCH)
 						goto nomatch;
 				break;
 			}
@@ -1836,7 +2073,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 				util_strlcpy(import, &rules->buf[cur->key.value_off], sizeof(import));
 				udev_event_apply_format(event, import, sizeof(import));
 				if (import_parent_into_properties(event->dev, import) != 0)
-					if (cur->key.op != KEY_OP_NOMATCH)
+					if (cur->key.op != OP_NOMATCH)
 						goto nomatch;
 				break;
 			}
@@ -1871,7 +2108,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 
 				if (event->owner_final)
 					break;
-				if (cur->key.op == KEY_OP_ASSIGN_FINAL)
+				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));
@@ -1884,7 +2121,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 
 				if (event->group_final)
 					break;
-				if (cur->key.op == KEY_OP_ASSIGN_FINAL)
+				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));
@@ -1898,7 +2135,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 
 				if (event->mode_final)
 					break;
-				if (cur->key.op == KEY_OP_ASSIGN_FINAL)
+				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));
@@ -1912,21 +2149,21 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 		case TK_A_OWNER_ID:
 			if (event->owner_final)
 				break;
-			if (cur->key.op == KEY_OP_ASSIGN_FINAL)
+			if (cur->key.op == OP_ASSIGN_FINAL)
 				event->owner_final = 1;
 			event->uid = cur->key.uid;
 			break;
 		case TK_A_GROUP_ID:
 			if (event->group_final)
 				break;
-			if (cur->key.op == KEY_OP_ASSIGN_FINAL)
+			if (cur->key.op == OP_ASSIGN_FINAL)
 				event->group_final = 1;
 			event->gid = cur->key.gid;
 			break;
 		case TK_A_MODE_ID:
 			if (event->mode_final)
 				break;
-			if (cur->key.op == KEY_OP_ASSIGN_FINAL)
+			if (cur->key.op == OP_ASSIGN_FINAL)
 				event->mode_final = 1;
 			event->mode = cur->key.mode;
 			break;
@@ -1957,7 +2194,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 
 				if (event->name_final)
 					break;
-				if (cur->key.op == KEY_OP_ASSIGN_FINAL)
+				if (cur->key.op == OP_ASSIGN_FINAL)
 					event->name_final = 1;
 				if (name[0] == '\0') {
 					free(event->name);
@@ -1984,9 +2221,11 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 
 				if (event->devlink_final)
 					break;
-				if (cur->key.op == KEY_OP_ASSIGN_FINAL)
+				if (major(udev_device_get_devnum(event->dev)) == 0)
+					break;
+				if (cur->key.op == OP_ASSIGN_FINAL)
 					event->devlink_final = 1;
-				if (cur->key.op == KEY_OP_ASSIGN || cur->key.op == KEY_OP_ASSIGN_FINAL)
+				if (cur->key.op == OP_ASSIGN || cur->key.op == OP_ASSIGN_FINAL)
 					udev_device_cleanup_devlinks_list(event->dev);
 
 				/* allow  multiple symlinks separated by spaces */
@@ -2064,7 +2303,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 			{
 				struct udev_list_entry *list_entry;
 
-				if (cur->key.op == KEY_OP_ASSIGN || cur->key.op == KEY_OP_ASSIGN_FINAL)
+				if (cur->key.op == OP_ASSIGN || cur->key.op == OP_ASSIGN_FINAL)
 					udev_list_cleanup_entries(event->udev, &event->run_list);
 				list_entry = udev_list_entry_add(event->udev, &event->run_list,
 								 &rules->buf[cur->key.value_off], NULL, 1, 0);
@@ -2078,9 +2317,10 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 		case TK_A_LAST_RULE:
 			break;
 
-		case TK_PARENTS_MAX:
+		case TK_M_PARENTS_MAX:
+		case TK_M_MAX:
 		case TK_END:
-		case TK_UNDEF:
+		case TK_UNSET:
 			err(rules->udev, "wrong type %u\n", cur->type);
 			goto nomatch;
 		}