X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=udev%2Fudev-event.c;h=6d055943371ac241ca2b59af2ddf8ad2e4801080;hp=86cb92ea949f66cf8fe9239863f25f7da284b36f;hb=ec2dd02e2a2748134f9c8347e12b802b42dea6b5;hpb=eb8837e15cdb9ad8f6840406f6ef0c8cfd702b98

diff --git a/udev/udev-event.c b/udev/udev-event.c
index 86cb92ea9..6d0559433 100644
--- a/udev/udev-event.c
+++ b/udev/udev-event.c
@@ -34,25 +34,25 @@ struct udev_event *udev_event_new(struct udev_device *dev)
 {
 	struct udev_event *event;
 
-	event = malloc(sizeof(struct udev_event));
+	event = calloc(1, sizeof(struct udev_event));
 	if (event == NULL)
 		return NULL;
-	memset(event, 0x00, sizeof(struct udev_event));
-
 	event->dev = dev;
 	event->udev = udev_device_get_udev(dev);
 	udev_list_init(&event->run_list);
 	event->mode = 0660;
-	util_strlcpy(event->owner, "0", sizeof(event->owner));
-	util_strlcpy(event->group, "0", sizeof(event->group));
-
 	dbg(event->udev, "allocated event %p\n", event);
 	return event;
 }
 
 void udev_event_unref(struct udev_event *event)
 {
+	if (event == NULL)
+		return;
 	udev_list_cleanup_entries(event->udev, &event->run_list);
+	free(event->tmp_node);
+	free(event->program_result);
+	free(event->name);
 	dbg(event->udev, "free event %p\n", event);
 	free(event);
 }
@@ -96,69 +96,6 @@ static int get_format_len(struct udev *udev, char **str)
 	return -1;
 }
 
-/* handle "[<SUBSYSTEM>/<KERNEL>]<attribute>" format */
-int udev_event_apply_subsys_kernel(struct udev_event *udev_event, const char *string,
-				   char *result, size_t maxsize, int read_value)
-{
-	char temp[UTIL_PATH_SIZE];
-	char *subsys;
-	char *sysname;
-	char *attr;
-	struct udev_device *dev;
-
-	if (string == NULL)
-		string = result;
-	if (string[0] != '[')
-		return -1;
-
-	util_strlcpy(temp, string, sizeof(temp));
-
-	subsys = &temp[1];
-
-	sysname = strchr(subsys, '/');
-	if (sysname == NULL)
-		return -1;
-	sysname[0] = '\0';
-	sysname = &sysname[1];
-
-	attr = strchr(sysname, ']');
-	if (attr == NULL)
-		return -1;
-	attr[0] = '\0';
-	attr = &attr[1];
-	if (attr[0] == '/')
-		attr = &attr[1];
-	if (attr[0] == '\0')
-		attr = NULL;
-
-	if (read_value && attr == NULL)
-		return -1;
-
-	dev = udev_device_new_from_subsystem_sysname(udev_event->udev, subsys, sysname);
-	if (dev == NULL)
-		return -1;
-
-	if (read_value) {
-		const char *val;
-
-		val = udev_device_get_attr_value(dev, attr);
-		if (val != NULL)
-			util_strlcpy(result, val, maxsize);
-		else
-			result[0] = '\0';
-		info(udev_event->udev, "value '[%s/%s]%s' is '%s'\n", subsys, sysname, attr, result);
-	} else {
-		util_strlcpy(result, udev_device_get_syspath(dev), maxsize);
-		if (attr != NULL) {
-			util_strlcat(result, "/", maxsize);
-			util_strlcat(result, attr, maxsize);
-		}
-		info(udev_event->udev, "path '[%s/%s]%s' is '%s'\n", subsys, sysname, attr, result);
-	}
-	udev_device_unref(dev);
-	return 0;
-}
-
 void udev_event_apply_format(struct udev_event *event, char *string, size_t maxsize)
 {
 	struct udev_device *dev = event->dev;
@@ -294,8 +231,9 @@ found:
 			break;
 		case SUBST_DRIVER:
 			if (event->dev_parent != NULL) {
-				const char *driver = udev_device_get_driver(event->dev_parent);
+				const char *driver;
 
+				driver = udev_device_get_driver(event->dev_parent);
 				if (driver == NULL)
 					break;
 				util_strlcat(string, driver, maxsize);
@@ -313,15 +251,18 @@ found:
 			dbg(event->udev, "substitute minor number '%s'\n", temp2);
 			break;
 		case SUBST_RESULT:
-			if (event->program_result[0] == '\0')
+			if (event->program_result == NULL)
 				break;
 			/* get part part of the result string */
 			i = 0;
 			if (attr != NULL)
 				i = strtoul(attr, &rest, 10);
 			if (i > 0) {
+				char result[UTIL_PATH_SIZE];
+
 				dbg(event->udev, "request part #%d of result string\n", i);
-				cpos = event->program_result;
+				util_strlcpy(result, event->program_result, sizeof(result));
+				cpos = result;
 				while (--i) {
 					while (cpos[0] != '\0' && !isspace(cpos[0]))
 						cpos++;
@@ -350,34 +291,26 @@ found:
 			if (attr == NULL)
 				err(event->udev, "missing file parameter for attr\n");
 			else {
-				char value[UTIL_NAME_SIZE] = "";
+				const char *val;
+				char value[UTIL_NAME_SIZE];
 				size_t size;
 
-				udev_event_apply_subsys_kernel(event, attr, value, sizeof(value), 1);
-
-				/* 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;
+				value[0] = '\0';
+				/* read the value specified by [usb/]*/
+				util_resolve_subsys_kernel(event->udev, attr, value, sizeof(value), 1);
 
-					val = udev_device_get_attr_value(event->dev_parent, attr);
+				/* try to read attribute of the current device */
+				if (value[0] == '\0') {
+					val = udev_device_get_sysattr_value(event->dev, 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);
+				/* try to read the attribute of the parent device, other matches have selected */
+				if (value[0] == '\0' && event->dev_parent != NULL && event->dev_parent != event->dev) {
+					val = udev_device_get_sysattr_value(event->dev_parent, attr);
+					if (val != NULL)
+						util_strlcpy(value, val, sizeof(value));
 				}
 
 				if (value[0]=='\0')
@@ -387,7 +320,7 @@ found:
 				size = strlen(value);
 				while (size > 0 && isspace(value[--size]))
 					value[size] = '\0';
-				count = util_replace_chars(value, ALLOWED_CHARS_INPUT);
+				count = udev_util_replace_chars(value, UDEV_ALLOWED_CHARS_INPUT);
 				if (count > 0)
 					info(event->udev, "%i character(s) replaced\n" , count);
 				util_strlcat(string, value, maxsize);
@@ -413,15 +346,43 @@ found:
 			}
 			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);
+			{
+				dev_t devnum;
+				struct stat statbuf;
+				char filename[UTIL_PATH_SIZE];
+				const char *devtype;
+
+				if (event->tmp_node != NULL) {
+					util_strlcat(string, event->tmp_node, maxsize);
+					dbg(event->udev, "return existing temporary node\n");
+					break;
+				}
+				devnum = udev_device_get_devnum(dev);
+				if (major(udev_device_get_devnum(dev) == 0))
+					break;
+				if (strcmp(udev_device_get_subsystem(dev), "block") == 0)
+					devtype = "block";
+				else
+					devtype = "char";
+				snprintf(filename, sizeof(filename), "%s/%s/%u:%u",
+					 udev_get_dev_path(event->udev), devtype,
+					 major(udev_device_get_devnum(dev)),
+					 minor(udev_device_get_devnum(dev)));
+				if (stat(filename, &statbuf) == 0 && statbuf.st_rdev == devnum) {
+					util_strlcat(string, filename, maxsize);
+					dbg(event->udev, "return existing temporary node\n");
+					break;
+				}
+				dbg(event->udev, "create temporary node\n");
+				asprintf(&event->tmp_node, "%s/.tmp-%s-%u:%u",
+					 udev_get_dev_path(event->udev), devtype,
+					 major(udev_device_get_devnum(dev)),
+					 minor(udev_device_get_devnum(dev)));
+				if (event->tmp_node == NULL)
+					break;
+				udev_node_mknod(dev, event->tmp_node, makedev(0, 0), 0600, 0, 0);
+				util_strlcat(string, event->tmp_node, maxsize);
 			}
-			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) {
@@ -434,13 +395,16 @@ found:
 			break;
 		case SUBST_LINKS:
 			{
+				size_t devlen = strlen(udev_get_dev_path(event->udev))+1;
 				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);
+				list_entry = udev_device_get_devlinks_list_entry(dev);
+				if (list_entry == NULL)
+					break;
+				util_strlcat(string, &udev_list_entry_get_name(list_entry)[devlen], 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);
+					util_strlcat(string, &udev_list_entry_get_name(list_entry)[devlen], maxsize);
 				}
 			}
 			break;
@@ -457,14 +421,11 @@ found:
 				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)
+				value = udev_device_get_property_value(event->dev, attr);
+				if (value == 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;
@@ -511,8 +472,6 @@ static int rename_netif(struct udev_event *event)
 
 	info(event->udev, "changing net interface name from '%s' to '%s'\n",
 	     udev_device_get_sysname(dev), event->name);
-	if (event->test)
-		return 0;
 
 	sk = socket(PF_INET, SOCK_DGRAM, 0);
 	if (sk < 0) {
@@ -548,7 +507,7 @@ static int rename_netif(struct udev_event *event)
 
 		/* wait 30 seconds for our target to become available */
 		util_strlcpy(ifr.ifr_name, ifr.ifr_newname, IFNAMSIZ);
-		util_strlcpy(ifr.ifr_newname, udev_device_get_devnode(dev), IFNAMSIZ);
+		util_strlcpy(ifr.ifr_newname, event->name, IFNAMSIZ);
 		loop = 30 * 20;
 		while (loop--) {
 			err = ioctl(sk, SIOCSIFNAME, &ifr);
@@ -563,7 +522,7 @@ static int rename_netif(struct udev_event *event)
 				break;
 			}
 			dbg(event->udev, "wait for netif '%s' to become free, loop=%i\n",
-			    udev_device_get_devnode(dev), (30 * 20) - loop);
+			    event->name, (30 * 20) - loop);
 			usleep(1000 * 1000 / 20);
 		}
 	}
@@ -591,54 +550,69 @@ int udev_event_execute_rules(struct udev_event *event, struct udev_rules *rules)
 
 		dbg(event->udev, "device node add '%s'\n", udev_device_get_devpath(dev));
 
-		udev_rules_get_name(rules, event);
+		udev_rules_apply_to_event(rules, event);
+		if (event->tmp_node != NULL) {
+			dbg(event->udev, "removing temporary device node\n");
+			util_unlink_secure(event->udev, event->tmp_node);
+			free(event->tmp_node);
+			event->tmp_node = NULL;
+		}
+
 		if (event->ignore_device) {
 			info(event->udev, "device event will be ignored\n");
 			goto exit;
 		}
 
-		if (event->name[0] == '\0') {
+		if (event->name != NULL && event->name[0] == '\0') {
 			info(event->udev, "device node creation supressed\n");
 			goto exit;
 		}
 
+		if (event->name == NULL) {
+			info(event->udev, "no node name set, will use kernel name '%s'\n",
+			     udev_device_get_sysname(event->dev));
+			event->name = strdup(udev_device_get_sysname(event->dev));
+			if (event->name == NULL)
+				goto exit;
+		}
+
 		/* set device node name */
 		util_strlcpy(filename, udev_get_dev_path(event->udev), sizeof(filename));
 		util_strlcat(filename, "/", sizeof(filename));
 		util_strlcat(filename, event->name, sizeof(filename));
 		udev_device_set_devnode(dev, filename);
 
-		/* read current database entry; cleanup, if it is known device */
+		/* read current database entry */
 		dev_old = udev_device_new_from_syspath(event->udev, udev_device_get_syspath(dev));
 		if (dev_old != NULL) {
-			info(event->udev, "device '%s' already in database, updating\n",
-			     udev_device_get_devpath(dev));
-			udev_node_update_old_links(dev, dev_old, event->test);
-			udev_device_unref(dev_old);
+			udev_device_read_db(dev_old);
+			udev_device_set_info_loaded(dev_old);
 		}
 
+		/* update database, create node and symlinks */
 		udev_device_update_db(dev);
+		err = udev_node_add(dev, event->mode, event->uid, event->gid);
 
-		err = udev_node_add(dev, event->mode, event->owner, event->group, event->test);
-		if (err != 0)
-			goto exit;
-
+		/* remove/update possible left-over symlinks from old database entry */
+		if (dev_old != NULL) {
+			udev_node_update_old_links(dev, dev_old);
+			udev_device_unref(dev_old);
+		}
 		goto exit;
 	}
 
 	/* add netif */
 	if (strcmp(udev_device_get_subsystem(dev), "net") == 0 && strcmp(udev_device_get_action(dev), "add") == 0) {
 		dbg(event->udev, "netif add '%s'\n", udev_device_get_devpath(dev));
+		udev_device_delete_db(dev);
 
-		udev_rules_get_name(rules, event);
+		udev_rules_apply_to_event(rules, event);
 		if (event->ignore_device) {
 			info(event->udev, "device event will be ignored\n");
 			goto exit;
 		}
-		if (event->name[0] == '\0') {
-			info(event->udev, "device renaming supressed\n");
+		if (event->name == NULL)
 			goto exit;
-		}
 
 		/* look if we want to change the name of the netif */
 		if (strcmp(event->name, udev_device_get_sysname(dev)) != 0) {
@@ -664,6 +638,7 @@ int udev_event_execute_rules(struct udev_event *event, struct udev_rules *rules)
 				info(event->udev, "changed devpath to '%s'\n", udev_device_get_devpath(dev));
 			}
 		}
+		udev_device_update_db(dev);
 		goto exit;
 	}
 
@@ -671,8 +646,8 @@ int udev_event_execute_rules(struct udev_event *event, struct udev_rules *rules)
 	if (major(udev_device_get_devnum(dev)) != 0 && strcmp(udev_device_get_action(dev), "remove") == 0) {
 		/* import database entry and delete it */
 		udev_device_read_db(dev);
-		if (!event->test)
-			udev_device_delete_db(dev);
+		udev_device_set_info_loaded(dev);
+		udev_device_delete_db(dev);
 
 		if (udev_device_get_devnode(dev) == NULL) {
 			char devnode[UTIL_PATH_SIZE];
@@ -685,7 +660,7 @@ int udev_event_execute_rules(struct udev_event *event, struct udev_rules *rules)
 			udev_device_set_devnode(dev, devnode);
 		}
 
-		udev_rules_get_run(rules, event);
+		udev_rules_apply_to_event(rules, event);
 		if (event->ignore_device) {
 			info(event->udev, "device event will be ignored\n");
 			goto exit;
@@ -696,14 +671,19 @@ int udev_event_execute_rules(struct udev_event *event, struct udev_rules *rules)
 			goto exit;
 		}
 
-		err = udev_node_remove(dev, event->test);
+		err = udev_node_remove(dev);
 		goto exit;
 	}
 
 	/* default devices */
-	udev_rules_get_run(rules, event);
+	udev_rules_apply_to_event(rules, event);
 	if (event->ignore_device)
 		info(event->udev, "device event will be ignored\n");
+
+	if (strcmp(udev_device_get_action(dev), "remove") != 0)
+		udev_device_update_db(dev);
+	else
+		udev_device_delete_db(dev);
 exit:
 	return err;
 }
@@ -731,8 +711,13 @@ int udev_event_execute_run(struct udev_event *event)
 
 			util_strlcpy(program, cmd, sizeof(program));
 			udev_event_apply_format(event, program, sizeof(program));
+			if (event->trace)
+				fprintf(stderr, "run  %s (%llu) '%s'\n",
+				       udev_device_get_syspath(event->dev),
+				       udev_device_get_seqnum(event->dev),
+				       program);
 			envp = udev_device_get_properties_envp(event->dev);
-			if (run_program(event->udev, program, envp, NULL, 0, NULL) != 0) {
+			if (util_run_program(event->udev, program, envp, NULL, 0, NULL) != 0) {
 				if (!udev_list_entry_get_flag(list_entry))
 					err = -1;
 			}