X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=udev%2Fudev-rules.c;h=e4594c31cdef659bb4f12abdb79ca0264fc92411;hp=dc4009f74aefeb29a2bfa1bb4896c5c130ba720a;hb=9379b7c16dd3b2f11d9e69c063706037ae001a0a;hpb=1c8af93aca64033f00d493bad7d505757c1ab414

diff --git a/udev/udev-rules.c b/udev/udev-rules.c
index dc4009f74..e4594c31c 100644
--- a/udev/udev-rules.c
+++ b/udev/udev-rules.c
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2008 Kay Sievers <kay.sievers@vrfy.org>
+ * Copyright (C) 2008 Alan Jenkins <alan-jenkins@tuffmail.co.uk>
  *
  * 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
@@ -41,14 +42,16 @@ struct uid_gid {
 	};
 };
 
-#define TRIE_CHILD_MAX 10
-
 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;
-	size_t value_len;
-	unsigned char child_cur;
-	unsigned char child_key[TRIE_CHILD_MAX];
-	unsigned short child[TRIE_CHILD_MAX];
+	unsigned short value_len;
+	unsigned char key;
 };
 
 struct udev_rules {
@@ -66,13 +69,12 @@ struct udev_rules {
 	size_t buf_max;
 	unsigned int buf_count;
 
-	/* key strings are indexed to avoid wasting space with duplicates */
-	struct trie_node *trie;
-	unsigned short trie_cur;
-	unsigned short trie_max;
-	unsigned short *trie_root;
+	/* 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, we cache uid/gid lookup results */
+	/* during rule parsing, uid/gid lookup results are cached */
 	struct uid_gid *uids;
 	unsigned int uids_cur;
 	unsigned int uids_max;
@@ -138,6 +140,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 */
@@ -180,7 +183,6 @@ struct token {
 			union {
 				unsigned int attr_off;
 				int ignore_error;
-				int i;
 				unsigned int rule_goto;
 				mode_t  mode;
 				uid_t uid;
@@ -188,6 +190,7 @@ struct token {
 				int num_fake_part;
 				int devlink_prio;
 				int event_timeout;
+				int watch;
 			};
 		} key;
 	};
@@ -268,6 +271,7 @@ static const char *token_str(enum token_type type)
 		[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",
@@ -358,6 +362,9 @@ static void dump_token(struct udev_rules *rules, struct token *token)
 		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_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);
 		break;
@@ -438,117 +445,90 @@ static int add_new_string(struct udev_rules *rules, const char *str, size_t byte
 	return off;
 }
 
-static unsigned char trie_child_slot(struct trie_node *node, char key)
-{
-	unsigned char child_slot;
-
-	for (child_slot = 0; child_slot < node->child_cur; child_slot++) {
-		if (node->child_key[child_slot] == key)
-			break;
-	}
-
-	return child_slot;
-}
-
 static int add_string(struct udev_rules *rules, const char *str)
 {
-	struct trie_node *child;
-	unsigned short child_off;
-	unsigned short node_off;
+	unsigned int node_idx;
+	struct trie_node *new_node;
+	unsigned int new_node_idx;
 	unsigned char key;
-	size_t len;
+	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;
 
-	/* offset 0 is always '\0' */
-	if (len == 0)
-		return 0;
+		node = &rules->trie_nodes[node_idx];
+		off = node->value_off + node->value_len - len;
 
-	/* strings with spaces are probably commands e.g. modprobe,
-	   with unique arguments. */
-	if (strchr(str, ' ') != NULL)
-		return add_new_string(rules, str, len + 1);
-
-	/* descend root - start from last character of str */
-	key = str[len - 1];
-	node_off = rules->trie_root[key];
-	depth = 0;
-
-	/* descend suffix trie */
-	if (node_off != 0) {
-		while (1) {
-			struct trie_node *node = &rules->trie[node_off];
-			unsigned char child_slot;
-
-			depth++;
-			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;
-			}
+		/* 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_slot = trie_child_slot(node, key);
+		/* lookup child node */
+		key = str[len - 1 - depth];
+		child_idx = node->child_idx;
+		while (child_idx > 0) {
+			struct trie_node *child;
 
-			if(child_slot == node->child_cur)
+			child = &rules->trie_nodes[child_idx];
+			if (child->key == key)
 				break;
-
-			node_off = node->child[child_slot];
+			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 storage if needed */
-	if (rules->trie_cur >= rules->trie_max) {
-		struct trie_node *trie;
-		unsigned short add;
+	/* 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_max;
+		add = rules->trie_nodes_max;
 		if (add < 8)
 			add = 8;
 
-		trie = realloc(rules->trie, (rules->trie_max + add) * sizeof(struct trie_node));
-		if (trie == NULL)
+		nodes = realloc(rules->trie_nodes, (rules->trie_nodes_max + add) * sizeof(struct trie_node));
+		if (nodes == NULL)
 			return -1;
-		dbg(rules->udev, "extend string index nodes from %u to %u\n", rules->trie_max, rules->trie_max + add);
-		rules->trie = trie;
-		rules->trie_max += add;
+		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;
 	}
 
-	/* insert new child node */
-	child_off = rules->trie_cur;
-	if (depth == 0) {
-		rules->trie_root[key] = child_off;
+	/* 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 *parent = &rules->trie[node_off];
-		unsigned char child_slot = parent->child_cur;
-
-		/* no space in parent, we can't index this string, nevermind */
-		if (child_slot == TRIE_CHILD_MAX)
-			return off;
+		struct trie_node *last_child;
 
-		parent->child[child_slot] = child_off;
-		parent->child_key[child_slot] = key;
-		parent->child_cur = child_slot + 1;
+		last_child = &rules->trie_nodes[parent->last_child_idx];
+		last_child->next_child_idx = new_node_idx;
 	}
-
-	/* allocate and construct the child node */
-	rules->trie_cur++;
-	child = &rules->trie[child_off];
-	memset(child, 0x00, sizeof(struct trie_node));
-	child->value_off = off;
-	child->value_len = len;
-
+	parent->last_child_idx = new_node_idx;
 	return off;
 }
 
@@ -757,7 +737,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;
 
@@ -1052,9 +1032,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;
@@ -1156,10 +1135,10 @@ 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;
+	int waitfor = 0;
 	struct rule_tmp rule_tmp;
 
 	memset(&rule_tmp, 0x00, sizeof(struct rule_tmp));
@@ -1183,7 +1162,6 @@ static int add_rule(struct udev_rules *rules, char *line,
 				goto invalid;
 			}
 			rule_add_key(&rule_tmp, TK_M_ACTION, op, value, NULL);
-			valid = 1;
 			continue;
 		}
 
@@ -1193,7 +1171,6 @@ static int add_rule(struct udev_rules *rules, char *line,
 				goto invalid;
 			}
 			rule_add_key(&rule_tmp, TK_M_DEVPATH, op, value, NULL);
-			valid = 1;
 			continue;
 		}
 
@@ -1203,7 +1180,6 @@ static int add_rule(struct udev_rules *rules, char *line,
 				goto invalid;
 			}
 			rule_add_key(&rule_tmp, TK_M_KERNEL, op, value, NULL);
-			valid = 1;
 			continue;
 		}
 
@@ -1222,7 +1198,6 @@ 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;
 		}
 
@@ -1232,7 +1207,6 @@ static int add_rule(struct udev_rules *rules, char *line,
 				goto invalid;
 			}
 			rule_add_key(&rule_tmp, TK_M_DRIVER, op, value, NULL);
-			valid = 1;
 			continue;
 		}
 
@@ -1247,7 +1221,6 @@ 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;
 		}
 
@@ -1258,7 +1231,6 @@ static int add_rule(struct udev_rules *rules, char *line,
 				goto invalid;
 			}
 			rule_add_key(&rule_tmp, TK_M_KERNELS, op, value, NULL);
-			valid = 1;
 			continue;
 		}
 
@@ -1269,7 +1241,6 @@ static int add_rule(struct udev_rules *rules, char *line,
 				goto invalid;
 			}
 			rule_add_key(&rule_tmp, TK_M_SUBSYSTEMS, op, value, NULL);
-			valid = 1;
 			continue;
 		}
 
@@ -1279,7 +1250,6 @@ static int add_rule(struct udev_rules *rules, char *line,
 				goto invalid;
 			}
 			rule_add_key(&rule_tmp, TK_M_DRIVERS, op, value, NULL);
-			valid = 1;
 			continue;
 		}
 
@@ -1301,7 +1271,6 @@ 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;
 		}
 
@@ -1320,13 +1289,11 @@ 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) {
 			rule_add_key(&rule_tmp, TK_M_PROGRAM, op, value, NULL);
-			valid = 1;
 			continue;
 		}
 
@@ -1336,7 +1303,6 @@ static int add_rule(struct udev_rules *rules, char *line,
 				goto invalid;
 			}
 			rule_add_key(&rule_tmp, TK_M_RESULT, op, value, NULL);
-			valid = 1;
 			continue;
 		}
 
@@ -1345,15 +1311,12 @@ static int add_rule(struct udev_rules *rules, char *line,
 			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];
@@ -1378,11 +1341,9 @@ static int add_rule(struct udev_rules *rules, char *line,
 				if (!lstat(file, &statbuf) && (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;
@@ -1402,7 +1363,6 @@ 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;
 		}
 
@@ -1413,25 +1373,22 @@ static int add_rule(struct udev_rules *rules, char *line,
 			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) {
 			rule_add_key(&rule_tmp, TK_M_WAITFOR, 0, value, NULL);
-			valid = 1;
+			waitfor = 1;
 			continue;
 		}
 
 		if (strcasecmp(key, "LABEL") == 0) {
 			rule_tmp.rule.rule.label_off = add_string(rules, value);
-			valid = 1;
 			continue;
 		}
 
 		if (strcasecmp(key, "GOTO") == 0) {
 			rule_add_key(&rule_tmp, TK_A_GOTO, 0, value, NULL);
-			valid = 1;
 			continue;
 		}
 
@@ -1440,7 +1397,7 @@ static int add_rule(struct udev_rules *rules, char *line,
 				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) {
@@ -1466,7 +1423,6 @@ static int add_rule(struct udev_rules *rules, char *line,
 			else
 				rule_add_key(&rule_tmp, TK_A_DEVLINK, op, value, NULL);
 			rule_tmp.rule.rule.flags = 1;
-			valid = 1;
 			continue;
 		}
 
@@ -1477,14 +1433,13 @@ static int add_rule(struct udev_rules *rules, char *line,
 			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;
 		}
 
@@ -1495,14 +1450,13 @@ static int add_rule(struct udev_rules *rules, char *line,
 			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;
 		}
 
@@ -1516,7 +1470,6 @@ 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;
 		}
 
@@ -1563,19 +1516,29 @@ 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;
+	if (physdev && !waitfor)
+		err(rules->udev, "PHYSDEV* values are deprecated and not available on recent kernels, "
+		    "please fix it in %s:%u\n", filename, lineno);
 
 	/* add rule token */
 	rule_tmp.rule.rule.token_count = 1 + rule_tmp.token_cur;
@@ -1672,7 +1635,7 @@ static int add_matching_files(struct udev *udev, struct udev_list_node *file_lis
 	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;
 	}
 
@@ -1728,23 +1691,25 @@ 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;
 	rules->buf_max = PREALLOC_STRBUF;
-	rules->trie = malloc(PREALLOC_TRIE * sizeof(struct trie_node));
-	if (rules->trie == NULL)
-		return NULL;
-	rules->trie_max = PREALLOC_TRIE;
-	rules->trie_root = calloc(UCHAR_MAX + 1, sizeof(unsigned short));
 	/* offset 0 is always '\0' */
 	rules->buf[0] = '\0';
 	rules->buf_cur = 1;
-	/* offset 0 is reserved for the null trie node */
-	rules->trie_cur = 1;
 	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");
@@ -1855,18 +1820,17 @@ struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names)
 			rules->buf_max = rules->buf_cur;
 		}
 	}
-	info(udev, "shrunk to %zu 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, "used %zu bytes of string index nodes (%hu * %zu bytes)\n",
-	     rules->trie_cur * sizeof(struct trie_node), rules->trie_cur, sizeof(struct trie_node));
+	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);
-	rules->trie = NULL;
-	rules->trie_cur = 0;
-	rules->trie_max = 0;
-	free(rules->trie_root);
-	rules->trie_root = NULL;
+	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);
@@ -1888,8 +1852,7 @@ void udev_rules_unref(struct udev_rules *rules)
 		return;
 	free(rules->tokens);
 	free(rules->buf);
-	free(rules->trie);
-	free(rules->trie_root);
+	free(rules->trie_nodes);
 	free(rules->uids);
 	free(rules->gids);
 	free(rules);
@@ -2042,7 +2005,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:
@@ -2082,13 +2045,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 = "";
@@ -2303,6 +2263,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;
@@ -2424,24 +2387,19 @@ 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));
 				if (esc == ESCAPE_UNSET || esc == ESCAPE_REPLACE) {
 					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:
@@ -2530,9 +2488,8 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
 				     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);