1 files changed, 21 insertions, 474 deletions

diff --git a/udev/udev-rules.c b/udev/udev-rules.c
index 978581fb50..a9793f4e8d 100644
--- a/udev/udev-rules.c
+++ b/udev/udev-rules.c
@@ -190,45 +190,6 @@ next:
 	return current;
 }
 
-/* extract possible {attr} and move str behind it */
-static char *get_format_attribute(struct udev *udev, char **str)
-{
-	char *pos;
-	char *attr = NULL;
-
-	if (*str[0] == '{') {
-		pos = strchr(*str, '}');
-		if (pos == NULL) {
-			err(udev, "missing closing brace for format\n");
-			return NULL;
-		}
-		pos[0] = '\0';
-		attr = *str+1;
-		*str = pos+1;
-		dbg(udev, "attribute='%s', str='%s'\n", attr, *str);
-	}
-	return attr;
-}
-
-/* extract possible format length and move str behind it*/
-static int get_format_len(struct udev *udev, char **str)
-{
-	int num;
-	char *tail;
-
-	if (isdigit(*str[0])) {
-		num = (int) strtoul(*str, &tail, 10);
-		if (num > 0) {
-			*str = tail;
-			dbg(udev, "format length=%i\n", num);
-			return num;
-		} else {
-			err(udev, "format parsing error '%s'\n", *str);
-		}
-	}
-	return -1;
-}
-
 static int import_property_from_string(struct udev_device *dev, char *line)
 {
 	struct udev *udev = udev_device_get_udev(dev);
@@ -412,36 +373,6 @@ static int wait_for_file(struct udev_event *event, const char *file, int timeout
 	return -1;
 }
 
-/* handle "[$SUBSYSTEM/$KERNEL]<attribute>" lookup */
-static int split_subsys_sysname(struct udev *udev, char *attrstr, char **subsys, char **sysname, char **attr)
-{
-	char *pos;
-
-	if (attrstr[0] != '[')
-		return -1;
-
-	*subsys = &attrstr[1];
-	pos = strchr(*subsys, ']');
-	if (pos == NULL)
-		return -1;
-	pos[0] = '\0';
-	pos = &pos[1];
-
-	if (pos[0] == '/')
-		pos = &pos[1];
-	if (pos[0] != '\0')
-		*attr = pos;
-	else
-		*attr = NULL;
-
-	pos = strchr(*subsys, '/');
-	if (pos == NULL)
-		return -1;
-	pos[0] = '\0';
-	*sysname = &pos[1];
-	return 0;
-}
-
 static int attr_subst_subdir(char *attr, size_t len)
 {
 	char *pos;
@@ -480,345 +411,6 @@ static int attr_subst_subdir(char *attr, size_t len)
 	return found;
 }
 
-void udev_rules_apply_format(struct udev_event *event, char *string, size_t maxsize)
-{
-	struct udev_device *dev = event->dev;
-	char temp[UTIL_PATH_SIZE];
-	char temp2[UTIL_PATH_SIZE];
-	char *head, *tail, *cpos, *attr, *rest;
-	int len;
-	int i;
-	int count;
-	enum subst_type {
-		SUBST_UNKNOWN,
-		SUBST_DEVPATH,
-		SUBST_KERNEL,
-		SUBST_KERNEL_NUMBER,
-		SUBST_ID,
-		SUBST_DRIVER,
-		SUBST_MAJOR,
-		SUBST_MINOR,
-		SUBST_RESULT,
-		SUBST_ATTR,
-		SUBST_PARENT,
-		SUBST_TEMP_NODE,
-		SUBST_NAME,
-		SUBST_LINKS,
-		SUBST_ROOT,
-		SUBST_SYS,
-		SUBST_ENV,
-	};
-	static const struct subst_map {
-		char *name;
-		char fmt;
-		enum subst_type type;
-	} map[] = {
-		{ .name = "devpath",	.fmt = 'p',	.type = SUBST_DEVPATH },
-		{ .name = "number",	.fmt = 'n',	.type = SUBST_KERNEL_NUMBER },
-		{ .name = "kernel",	.fmt = 'k',	.type = SUBST_KERNEL },
-		{ .name = "id",		.fmt = 'b',	.type = SUBST_ID },
-		{ .name = "driver",	.fmt = 'd',	.type = SUBST_DRIVER },
-		{ .name = "major",	.fmt = 'M',	.type = SUBST_MAJOR },
-		{ .name = "minor",	.fmt = 'm',	.type = SUBST_MINOR },
-		{ .name = "result",	.fmt = 'c',	.type = SUBST_RESULT },
-		{ .name = "attr",	.fmt = 's',	.type = SUBST_ATTR },
-		{ .name = "sysfs",	.fmt = 's',	.type = SUBST_ATTR },
-		{ .name = "parent",	.fmt = 'P',	.type = SUBST_PARENT },
-		{ .name = "tempnode",	.fmt = 'N',	.type = SUBST_TEMP_NODE },
-		{ .name = "name",	.fmt = 'D',	.type = SUBST_NAME },
-		{ .name = "links",	.fmt = 'L',	.type = SUBST_LINKS },
-		{ .name = "root",	.fmt = 'r',	.type = SUBST_ROOT },
-		{ .name = "sys",	.fmt = 'S',	.type = SUBST_SYS },
-		{ .name = "env",	.fmt = 'E',	.type = SUBST_ENV },
-		{ NULL, '\0', 0 }
-	};
-	enum subst_type type;
-	const struct subst_map *subst;
-
-	head = string;
-	while (1) {
-		len = -1;
-		while (head[0] != '\0') {
-			if (head[0] == '$') {
-				/* substitute named variable */
-				if (head[1] == '\0')
-					break;
-				if (head[1] == '$') {
-					util_strlcpy(temp, head+2, sizeof(temp));
-					util_strlcpy(head+1, temp, maxsize);
-					head++;
-					continue;
-				}
-				head[0] = '\0';
-				for (subst = map; subst->name; subst++) {
-					if (strncasecmp(&head[1], subst->name, strlen(subst->name)) == 0) {
-						type = subst->type;
-						tail = head + strlen(subst->name)+1;
-						dbg(event->udev, "will substitute format name '%s'\n", subst->name);
-						goto found;
-					}
-				}
-				head[0] = '$';
-				err(event->udev, "unknown format variable '%s'\n", head);
-			} else if (head[0] == '%') {
-				/* substitute format char */
-				if (head[1] == '\0')
-					break;
-				if (head[1] == '%') {
-					util_strlcpy(temp, head+2, sizeof(temp));
-					util_strlcpy(head+1, temp, maxsize);
-					head++;
-					continue;
-				}
-				head[0] = '\0';
-				tail = head+1;
-				len = get_format_len(event->udev, &tail);
-				for (subst = map; subst->name; subst++) {
-					if (tail[0] == subst->fmt) {
-						type = subst->type;
-						tail++;
-						dbg(event->udev, "will substitute format char '%c'\n", subst->fmt);
-						goto found;
-					}
-				}
-				head[0] = '%';
-				err(event->udev, "unknown format char '%c'\n", tail[0]);
-			}
-			head++;
-		}
-		break;
-found:
-		attr = get_format_attribute(event->udev, &tail);
-		util_strlcpy(temp, tail, sizeof(temp));
-		dbg(event->udev, "format=%i, string='%s', tail='%s'\n", type ,string, tail);
-
-		switch (type) {
-		case SUBST_DEVPATH:
-			util_strlcat(string, udev_device_get_devpath(dev), maxsize);
-			dbg(event->udev, "substitute devpath '%s'\n", udev_device_get_devpath(dev));
-			break;
-		case SUBST_KERNEL:
-			util_strlcat(string, udev_device_get_sysname(dev), maxsize);
-			dbg(event->udev, "substitute kernel name '%s'\n", udev_device_get_sysname(dev));
-			break;
-		case SUBST_KERNEL_NUMBER:
-			if (udev_device_get_sysnum(dev) == NULL)
-				break;
-			util_strlcat(string, udev_device_get_sysnum(dev), maxsize);
-			dbg(event->udev, "substitute kernel number '%s'\n", udev_device_get_sysnum(dev));
-			break;
-		case SUBST_ID:
-			if (event->dev_parent != NULL) {
-				util_strlcat(string, udev_device_get_sysname(event->dev_parent), maxsize);
-				dbg(event->udev, "substitute id '%s'\n", udev_device_get_sysname(event->dev_parent));
-			}
-			break;
-		case SUBST_DRIVER:
-			if (event->dev_parent != NULL) {
-				const char *driver = udev_device_get_driver(event->dev_parent);
-
-				if (driver == NULL)
-					break;
-				util_strlcat(string, driver, maxsize);
-				dbg(event->udev, "substitute driver '%s'\n", driver);
-			}
-			break;
-		case SUBST_MAJOR:
-			sprintf(temp2, "%d", major(udev_device_get_devnum(dev)));
-			util_strlcat(string, temp2, maxsize);
-			dbg(event->udev, "substitute major number '%s'\n", temp2);
-			break;
-		case SUBST_MINOR:
-			sprintf(temp2, "%d", minor(udev_device_get_devnum(dev)));
-			util_strlcat(string, temp2, maxsize);
-			dbg(event->udev, "substitute minor number '%s'\n", temp2);
-			break;
-		case SUBST_RESULT:
-			if (event->program_result[0] == '\0')
-				break;
-			/* get part part of the result string */
-			i = 0;
-			if (attr != NULL)
-				i = strtoul(attr, &rest, 10);
-			if (i > 0) {
-				dbg(event->udev, "request part #%d of result string\n", i);
-				cpos = event->program_result;
-				while (--i) {
-					while (cpos[0] != '\0' && !isspace(cpos[0]))
-						cpos++;
-					while (isspace(cpos[0]))
-						cpos++;
-				}
-				if (i > 0) {
-					err(event->udev, "requested part of result string not found\n");
-					break;
-				}
-				util_strlcpy(temp2, cpos, sizeof(temp2));
-				/* %{2+}c copies the whole string from the second part on */
-				if (rest[0] != '+') {
-					cpos = strchr(temp2, ' ');
-					if (cpos)
-						cpos[0] = '\0';
-				}
-				util_strlcat(string, temp2, maxsize);
-				dbg(event->udev, "substitute part of result string '%s'\n", temp2);
-			} else {
-				util_strlcat(string, event->program_result, maxsize);
-				dbg(event->udev, "substitute result string '%s'\n", event->program_result);
-			}
-			break;
-		case SUBST_ATTR:
-			if (attr == NULL)
-				err(event->udev, "missing file parameter for attr\n");
-			else {
-				char *subsys;
-				char *sysname;
-				char *attrib;
-				char value[UTIL_NAME_SIZE] = "";
-				size_t size;
-
-				if (split_subsys_sysname(event->udev, attr, &subsys, &sysname, &attrib) == 0) {
-					struct udev_device *d;
-					const char *val;
-
-					if (attrib == NULL)
-						break;
-					d = udev_device_new_from_subsystem_sysname(event->udev, subsys, sysname);
-					if (d == NULL)
-						break;
-					val = udev_device_get_attr_value(d, attrib);
-					if (val != NULL)
-						util_strlcpy(value, val, sizeof(value));
-					udev_device_unref(d);
-				}
-
-				/* try the current device, other matches may have selected */
-				if (value[0]=='\0' && event->dev_parent != NULL && event->dev_parent != event->dev) {
-					const char *val;
-
-					val = udev_device_get_attr_value(event->dev_parent, attr);
-					if (val != NULL)
-						util_strlcpy(value, val, sizeof(value));
-				}
-
-				/* look at all devices along the chain of parents */
-				if (value[0]=='\0') {
-					struct udev_device *dev_parent = dev;
-					const char *val;
-
-					do {
-						dbg(event->udev, "looking at '%s'\n", udev_device_get_syspath(dev_parent));
-						val = udev_device_get_attr_value(dev_parent, attr);
-						if (val != NULL) {
-							util_strlcpy(value, val, sizeof(value));
-							break;
-						}
-						dev_parent = udev_device_get_parent(dev_parent);
-					} while (dev_parent != NULL);
-				}
-
-				if (value[0]=='\0')
-					break;
-
-				/* strip trailing whitespace, and replace unwanted characters */
-				size = strlen(value);
-				while (size > 0 && isspace(value[--size]))
-					value[size] = '\0';
-				count = util_replace_chars(value, ALLOWED_CHARS_INPUT);
-				if (count > 0)
-					info(event->udev, "%i character(s) replaced\n" , count);
-				util_strlcat(string, value, maxsize);
-				dbg(event->udev, "substitute sysfs value '%s'\n", value);
-			}
-			break;
-		case SUBST_PARENT:
-			{
-				struct udev_device *dev_parent;
-				const char *devnode;
-
-				dev_parent = udev_device_get_parent(event->dev);
-				if (dev_parent == NULL)
-					break;
-				devnode = udev_device_get_devnode(dev_parent);
-				if (devnode != NULL) {
-					size_t devlen = strlen(udev_get_dev_path(event->udev))+1;
-
-					util_strlcat(string, &devnode[devlen], maxsize);
-					dbg(event->udev, "found parent '%s', got node name '%s'\n",
-					    udev_device_get_syspath(dev_parent), &devnode[devlen]);
-				}
-			}
-			break;
-		case SUBST_TEMP_NODE:
-			if (event->tmp_node[0] == '\0' && major(udev_device_get_devnum(dev)) > 0) {
-				dbg(event->udev, "create temporary device node for callout\n");
-				snprintf(event->tmp_node, sizeof(event->tmp_node), "%s/.tmp-%u-%u",
-					 udev_get_dev_path(event->udev),
-					 major(udev_device_get_devnum(dev)), minor(udev_device_get_devnum(dev)));
-				udev_node_mknod(dev, event->tmp_node, makedev(0,0), 0600, 0, 0);
-			}
-			util_strlcat(string, event->tmp_node, maxsize);
-			dbg(event->udev, "substitute temporary device node name '%s'\n", event->tmp_node);
-			break;
-		case SUBST_NAME:
-			if (event->name != NULL) {
-				util_strlcat(string, event->name, maxsize);
-				dbg(event->udev, "substitute name '%s'\n", event->name);
-			} else {
-				util_strlcat(string, udev_device_get_sysname(dev), maxsize);
-				dbg(event->udev, "substitute sysname '%s'\n", udev_device_get_sysname(dev));
-			}
-			break;
-		case SUBST_LINKS:
-			{
-				struct udev_list_entry *list_entry;
-
-				list_entry = udev_device_get_properties_list_entry(dev);
-				util_strlcpy(string, udev_list_entry_get_name(list_entry), maxsize);
-				udev_list_entry_foreach(list_entry, udev_list_entry_get_next(list_entry)) {
-					util_strlcat(string, " ", maxsize);
-					util_strlcat(string, udev_list_entry_get_name(list_entry), maxsize);
-				}
-			}
-			break;
-		case SUBST_ROOT:
-			util_strlcat(string, udev_get_dev_path(event->udev), maxsize);
-			dbg(event->udev, "substitute udev_root '%s'\n", udev_get_dev_path(event->udev));
-			break;
-		case SUBST_SYS:
-			util_strlcat(string, udev_get_sys_path(event->udev), maxsize);
-			dbg(event->udev, "substitute sys_path '%s'\n", udev_get_sys_path(event->udev));
-			break;
-		case SUBST_ENV:
-			if (attr == NULL) {
-				dbg(event->udev, "missing attribute\n");
-				break;
-			} else {
-				struct udev_list_entry *list_entry;
-				const char *value;
-
-				list_entry = udev_device_get_properties_list_entry(event->dev);
-				list_entry = udev_list_entry_get_by_name(list_entry, attr);
-				if (list_entry == NULL)
-					break;
-				value = udev_list_entry_get_value(list_entry);
-				dbg(event->udev, "substitute env '%s=%s'\n", attr, value);
-				util_strlcat(string, value, maxsize);
-				break;
-			}
-		default:
-			err(event->udev, "unknown substitution type=%i\n", type);
-			break;
-		}
-		/* possibly truncate to format-char specified length */
-		if (len >= 0 && len < (int)strlen(head)) {
-			head[len] = '\0';
-			dbg(event->udev, "truncate to %i chars, subtitution string becomes '%s'\n", len, head);
-		}
-		util_strlcat(string, temp, maxsize);
-	}
-}
-
 static char *key_val(struct udev_rule *rule, struct key *key)
 {
 	return rule->buf + key->val_off;
@@ -943,34 +535,20 @@ static int match_rule(struct udev_event *event, struct udev_rule *rule)
 	if (rule->test.operation == KEY_OP_MATCH ||
 	    rule->test.operation == KEY_OP_NOMATCH) {
 		char filename[UTIL_PATH_SIZE];
-		char *subsys;
-		char *sysname;
-		char *attrib;
 		struct stat statbuf;
 		int match;
 
 		util_strlcpy(filename, key_val(rule, &rule->test), sizeof(filename));
-		udev_rules_apply_format(event, filename, sizeof(filename));
-
-		if (split_subsys_sysname(event->udev, filename, &subsys, &sysname, &attrib) == 0) {
-			struct udev_device *d;
-			d = udev_device_new_from_subsystem_sysname(event->udev, subsys, sysname);
-			if (d != NULL) {
-				util_strlcpy(filename, udev_device_get_syspath(d), sizeof(filename));
-				if (attrib != NULL) {
-					util_strlcat(filename, "/", sizeof(filename));
-					util_strlcat(filename, attrib, sizeof(filename));
-				}
-				udev_device_unref(d);
-			}
-		} else if (filename[0] != '/') {
-			char tmp[UTIL_PATH_SIZE];
+		udev_event_apply_format(event, filename, sizeof(filename));
+		if (udev_event_apply_subsys_kernel(event, NULL, filename, sizeof(filename), 0) != 0)
+			if (filename[0] != '/') {
+				char tmp[UTIL_PATH_SIZE];
 
-			util_strlcpy(tmp, udev_device_get_syspath(dev), sizeof(tmp));
-			util_strlcat(tmp, "/", sizeof(tmp));
-			util_strlcat(tmp, filename, sizeof(tmp));
-			util_strlcpy(filename, tmp, sizeof(filename));
-		}
+				util_strlcpy(tmp, udev_device_get_syspath(dev), sizeof(tmp));
+				util_strlcat(tmp, "/", sizeof(tmp));
+				util_strlcat(tmp, filename, sizeof(tmp));
+				util_strlcpy(filename, tmp, sizeof(filename));
+			}
 
 		attr_subst_subdir(filename, sizeof(filename));
 
@@ -994,7 +572,7 @@ static int match_rule(struct udev_event *event, struct udev_rule *rule)
 		int found;
 
 		util_strlcpy(filename, key_val(rule, &rule->wait_for), sizeof(filename));
-		udev_rules_apply_format(event, filename, sizeof(filename));
+		udev_event_apply_format(event, filename, sizeof(filename));
 		found = (wait_for_file(event, filename, 10) == 0);
 		if (!found && (rule->wait_for.operation != KEY_OP_NOMATCH))
 			goto nomatch;
@@ -1009,27 +587,11 @@ static int match_rule(struct udev_event *event, struct udev_rule *rule)
 			char attr[UTIL_PATH_SIZE];
 			const char *key_name = key_pair_name(rule, pair);
 			const char *key_value = key_val(rule, &pair->key);
-			char *subsys;
-			char *sysname;
-			char *attrib;
 			char value[UTIL_NAME_SIZE] = "";
 			size_t len;
 
 			util_strlcpy(attr, key_name, sizeof(attr));
-			if (split_subsys_sysname(event->udev, attr, &subsys, &sysname, &attrib) == 0) {
-				struct udev_device *d;
-				const char *val;
-
-				if (attrib == NULL)
-					goto nomatch;
-				d = udev_device_new_from_subsystem_sysname(event->udev, subsys, sysname);
-				if (d == NULL)
-					goto nomatch;
-				val = udev_device_get_attr_value(d, attrib);
-				if (val != NULL)
-					util_strlcpy(value, val, sizeof(value));
-				udev_device_unref(d);
-			}
+			udev_event_apply_subsys_kernel(event, attr, value, sizeof(value), 1);
 
 			if (value[0]=='\0') {
 				const char *val;
@@ -1126,7 +688,7 @@ try_parent:
 		char result[UTIL_PATH_SIZE];
 
 		util_strlcpy(program, key_val(rule, &rule->program), sizeof(program));
-		udev_rules_apply_format(event, program, sizeof(program));
+		udev_event_apply_format(event, program, sizeof(program));
 		envp = udev_device_get_properties_envp(dev);
 		if (run_program(event->udev, program, envp, result, sizeof(result), NULL) != 0) {
 			dbg(event->udev, "PROGRAM is false\n");
@@ -1163,7 +725,7 @@ try_parent:
 		int rc = -1;
 
 		util_strlcpy(import, key_val(rule, &rule->import), sizeof(import));
-		udev_rules_apply_format(event, import, sizeof(import));
+		udev_event_apply_format(event, import, sizeof(import));
 		dbg(event->udev, "check for IMPORT import='%s'\n", import);
 		if (rule->import_type == IMPORT_PROGRAM) {
 			rc = import_program_into_env(event->dev, import);
@@ -1194,7 +756,7 @@ try_parent:
 
 			/* make sure we don't write to the same string we possibly read from */
 			util_strlcpy(temp_value, value, sizeof(temp_value));
-			udev_rules_apply_format(event, temp_value, sizeof(temp_value));
+			udev_event_apply_format(event, temp_value, sizeof(temp_value));
 
 			if (temp_value[0] != '\0') {
 				struct udev_list_entry *entry;
@@ -1213,27 +775,12 @@ try_parent:
 
 		if (pair->key.operation == KEY_OP_ASSIGN) {
 			const char *key_name = key_pair_name(rule, pair);
-			char *subsys;
-			char *sysname;
-			char *attrib;
 			char attr[UTIL_PATH_SIZE];
 			char value[UTIL_NAME_SIZE];
 			FILE *f;
 
 			util_strlcpy(attr, key_name, sizeof(attr));
-			if (split_subsys_sysname(event->udev, attr, &subsys, &sysname, &attrib) == 0) {
-				struct udev_device *d;
-
-				d = udev_device_new_from_subsystem_sysname(event->udev, subsys, sysname);
-				if (d != NULL) {
-					util_strlcpy(attr, udev_device_get_syspath(d), sizeof(attr));
-					if (attrib != NULL) {
-						util_strlcat(attr, "/", sizeof(attr));
-						util_strlcat(attr, attrib, sizeof(attr));
-					}
-					udev_device_unref(d);
-				}
-			} else {
+			if (udev_event_apply_subsys_kernel(event, key_name, attr, sizeof(attr), 0) != 0) {
 				util_strlcpy(attr, udev_device_get_syspath(dev), sizeof(attr));
 				util_strlcat(attr, "/", sizeof(attr));
 				util_strlcat(attr, key_name, sizeof(attr));
@@ -1242,7 +789,7 @@ try_parent:
 			attr_subst_subdir(attr, sizeof(attr));
 
 			util_strlcpy(value, key_val(rule, &pair->key), sizeof(value));
-			udev_rules_apply_format(event, value, sizeof(value));
+			udev_event_apply_format(event, value, sizeof(value));
 			info(event->udev, "writing '%s' to sysfs file '%s'\n", value, attr);
 			f = fopen(attr, "w");
 			if (f != NULL) {
@@ -1318,7 +865,7 @@ int udev_rules_get_name(struct udev_rules *rules, struct udev_event *event)
 					event->mode_final = 1;
 				char buf[20];
 				util_strlcpy(buf, key_val(rule, &rule->mode), sizeof(buf));
-				udev_rules_apply_format(event, buf, sizeof(buf));
+				udev_event_apply_format(event, buf, sizeof(buf));
 				event->mode = strtol(buf, NULL, 8);
 				dbg(event->udev, "applied mode=%#o to '%s'\n",
 				    event->mode, udev_device_get_sysname(dev));
@@ -1327,7 +874,7 @@ int udev_rules_get_name(struct udev_rules *rules, struct udev_event *event)
 				if (rule->owner.operation == KEY_OP_ASSIGN_FINAL)
 					event->owner_final = 1;
 				util_strlcpy(event->owner, key_val(rule, &rule->owner), sizeof(event->owner));
-				udev_rules_apply_format(event, event->owner, sizeof(event->owner));
+				udev_event_apply_format(event, event->owner, sizeof(event->owner));
 				dbg(event->udev, "applied owner='%s' to '%s'\n",
 				    event->owner, udev_device_get_sysname(dev));
 			}
@@ -1335,7 +882,7 @@ int udev_rules_get_name(struct udev_rules *rules, struct udev_event *event)
 				if (rule->group.operation == KEY_OP_ASSIGN_FINAL)
 					event->group_final = 1;
 				util_strlcpy(event->group, key_val(rule, &rule->group), sizeof(event->group));
-				udev_rules_apply_format(event, event->group, sizeof(event->group));
+				udev_event_apply_format(event, event->group, sizeof(event->group));
 				dbg(event->udev, "applied group='%s' to '%s'\n",
 				    event->group, udev_device_get_sysname(dev));
 			}
@@ -1359,7 +906,7 @@ int udev_rules_get_name(struct udev_rules *rules, struct udev_event *event)
 				}
 				/* allow  multiple symlinks separated by spaces */
 				util_strlcpy(temp, key_val(rule, &rule->symlink), sizeof(temp));
-				udev_rules_apply_format(event, temp, sizeof(temp));
+				udev_event_apply_format(event, temp, sizeof(temp));
 				if (rule->string_escape == ESCAPE_UNSET)
 					count = util_replace_chars(temp, ALLOWED_CHARS_FILE " ");
 				else if (rule->string_escape == ESCAPE_REPLACE)
@@ -1400,7 +947,7 @@ int udev_rules_get_name(struct udev_rules *rules, struct udev_event *event)
 
 				name_set = 1;
 				util_strlcpy(event->name, key_val(rule, &rule->name), sizeof(event->name));
-				udev_rules_apply_format(event, event->name, sizeof(event->name));
+				udev_event_apply_format(event, event->name, sizeof(event->name));
 				if (rule->string_escape == ESCAPE_UNSET ||
 				    rule->string_escape == ESCAPE_REPLACE) {
 					count = util_replace_chars(event->name, ALLOWED_CHARS_FILE);