[thirdparty/systemd.git] / udev / lib / libudev-enumerate.c

/*
 * libudev - interface to udev device information
 *
 * Copyright (C) 2008 Kay Sievers <kay.sievers@vrfy.org>
 *
 * 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
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <dirent.h>
#include <sys/stat.h>

#include "libudev.h"
#include "libudev-private.h"

struct udev_enumerate {
	struct udev *udev;
	int refcount;
	struct list_node devices_list;
};

struct udev_enumerate *udev_enumerate_ref(struct udev_enumerate *udev_enumerate)
{
	if (udev_enumerate == NULL)
		return NULL;
	udev_enumerate->refcount++;
	return udev_enumerate;
}

void udev_enumerate_unref(struct udev_enumerate *udev_enumerate)
{
	if (udev_enumerate == NULL)
		return;
	udev_enumerate->refcount--;
	if (udev_enumerate->refcount > 0)
		return;
	list_cleanup(udev_enumerate->udev, &udev_enumerate->devices_list);
	free(udev_enumerate);
}

struct udev *udev_enumerate_get_udev(struct udev_enumerate *udev_enumerate)
{
	if (udev_enumerate == NULL)
		return NULL;
	return udev_enumerate->udev;
}

struct udev_list_entry *udev_enumerate_get_list_entry(struct udev_enumerate *udev_enumerate)
{
	if (udev_enumerate == NULL)
		return NULL;
	return list_get_entry(&udev_enumerate->devices_list);
}

static int devices_scan_subsystem(struct udev *udev,
				  const char *basedir, const char *subsystem, const char *subdir,
				  struct list_node *devices_list)
{
	char path[UTIL_PATH_SIZE];
	DIR *dir;
	struct dirent *dent;

	util_strlcpy(path, udev_get_sys_path(udev), sizeof(path));
	util_strlcat(path, basedir, sizeof(path));
	if (subsystem != NULL) {
		util_strlcat(path, "/", sizeof(path));
		util_strlcat(path, subsystem, sizeof(path));
	}
	if (subdir != NULL)
		util_strlcat(path, subdir, sizeof(path));
	dir = opendir(path);
	if (dir == NULL)
		return -1;
	for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
		char syspath[UTIL_PATH_SIZE];
		char filename[UTIL_PATH_SIZE];
		struct stat statbuf;

		if (dent->d_name[0] == '.')
			continue;
		util_strlcpy(syspath, path, sizeof(syspath));
		util_strlcat(syspath, "/", sizeof(syspath));
		util_strlcat(syspath, dent->d_name, sizeof(syspath));
		util_strlcpy(filename, syspath, sizeof(filename));
		util_strlcat(filename, "/uevent", sizeof(filename));
		if (stat(filename, &statbuf) != 0)
			continue;
		util_resolve_sys_link(udev, syspath, sizeof(syspath));
		list_entry_add(udev, devices_list, syspath, NULL, 1, 1);
	}
	closedir(dir);
	return 0;
}

static int devices_scan_subsystems(struct udev *udev,
				   const char *basedir, const char *subdir,
				   struct udev_list_entry *subsystem_include_list,
				   struct udev_list_entry *subsystem_exclude_list,
				   struct list_node *devices_list)
{
	if (subsystem_include_list != NULL) {
		struct udev_list_entry *list_entry;

		/* if list of subsystems to scan is given, just use this list */
		udev_list_entry_foreach(list_entry, subsystem_include_list) {
			if (udev_list_entry_get_by_name(subsystem_exclude_list, udev_list_entry_get_name(list_entry)) != NULL)
					continue;
			devices_scan_subsystem(udev, basedir, udev_list_entry_get_name(list_entry), subdir, devices_list);
		}
	} else {
		char path[UTIL_PATH_SIZE];
		DIR *dir;
		struct dirent *dent;

		/* if no list of subsystems to scan is given, scan all, and possible exclude some subsystems */
		util_strlcpy(path, udev_get_sys_path(udev), sizeof(path));
		util_strlcat(path, basedir, sizeof(path));
		dir = opendir(path);
		if (dir == NULL)
			return -1;
		for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
			if (dent->d_name[0] == '.')
				continue;
			if (udev_list_entry_get_by_name(subsystem_exclude_list, dent->d_name) != NULL)
					continue;
			devices_scan_subsystem(udev, basedir, dent->d_name, subdir, devices_list);
		}
		closedir(dir);
	}
	return 0;
}

static int devices_delay(struct udev *udev, const char *syspath)
{
	static const char *delay_device_list[] = {
		"/block/md",
		"/block/dm-",
		NULL
	};
	size_t len;
	int i;

	len = strlen(udev_get_sys_path(udev));

	for (i = 0; delay_device_list[i] != NULL; i++) {
		if (strstr(&syspath[len], delay_device_list[i]) != NULL) {
			info(udev, "delaying: %s\n", syspath);
			return 1;
		}
	}
	return 0;
}

static struct udev_enumerate *enumerate_new(struct udev *udev)
{
	struct udev_enumerate *udev_enumerate;

	udev_enumerate = malloc(sizeof(struct udev_enumerate));
	if (udev_enumerate == NULL)
		return NULL;
	memset(udev_enumerate, 0x00, (sizeof(struct udev_enumerate)));
	udev_enumerate->refcount = 1;
	udev_enumerate->udev = udev;
	list_init(&udev_enumerate->devices_list);
	return udev_enumerate;
}

/**
 * udev_enumerate_new_from_devices:
 * @udev: udev library context
 * @subsystem: the list of names of subsystems to look for devices
 *
 * Returns: an enumeration context
 **/
struct udev_enumerate *udev_enumerate_new_from_devices(struct udev *udev, const char *subsystem, ...)
{
	struct udev_enumerate *udev_enumerate;
	va_list vargs;
	const char *arg;
	char base[UTIL_PATH_SIZE];
	struct stat statbuf;
	struct list_node subsystem_include_list;
	struct list_node subsystem_exclude_list;
	struct udev_list_entry *list_entry;

	if (udev == NULL)
		return NULL;

	udev_enumerate = enumerate_new(udev);
	if (udev_enumerate == NULL)
		return NULL;

	va_start(vargs, subsystem);
	list_init(&subsystem_include_list);
	list_init(&subsystem_exclude_list);
	for (arg = subsystem; arg != NULL; arg = va_arg(vargs, const char *)) {
		if (arg[0] != '!')
			list_entry_add(udev, &subsystem_include_list, arg, NULL, 1, 0);
		else
			list_entry_add(udev, &subsystem_exclude_list, &arg[1], NULL, 1, 0);
	}
	va_end(vargs);

	util_strlcpy(base, udev_get_sys_path(udev), sizeof(base));
	util_strlcat(base, "/subsystem", sizeof(base));
	if (stat(base, &statbuf) == 0) {
		/* we have /subsystem/, forget all the old stuff */
		info(udev, "searching '/subsystem/*/devices/*' dir\n");
		devices_scan_subsystems(udev, "/subsystem", "/devices",
					list_get_entry(&subsystem_include_list),
					list_get_entry(&subsystem_exclude_list),
					&udev_enumerate->devices_list);
	} else {
		info(udev, "searching '/bus/*/devices/*' dir\n");
		devices_scan_subsystems(udev, "/bus", "/devices",
					list_get_entry(&subsystem_include_list),
					list_get_entry(&subsystem_exclude_list),
					&udev_enumerate->devices_list);
		info(udev, "searching '/class/*' dir\n");
		devices_scan_subsystems(udev, "/class", NULL,
					list_get_entry(&subsystem_include_list),
					list_get_entry(&subsystem_exclude_list),
					&udev_enumerate->devices_list);
		/* if block isn't a class, scan /block/ */
		util_strlcpy(base, udev_get_sys_path(udev), sizeof(base));
		util_strlcat(base, "/class/block", sizeof(base));
		if (stat(base, &statbuf) != 0) {
			struct udev_list_entry *include_list = list_get_entry(&subsystem_include_list);
			struct udev_list_entry *exclude_list = list_get_entry(&subsystem_exclude_list);
			int include_block = (include_list == NULL || udev_list_entry_get_by_name(include_list, "block") != NULL);
			int exclude_block = (udev_list_entry_get_by_name(exclude_list, "block") != NULL);

			if (include_block && !exclude_block) {
				info(udev, "searching '/block/*/*' dir\n");
				/* scan disks */
				devices_scan_subsystem(udev, "/block", NULL, NULL, &udev_enumerate->devices_list);
				/* scan partitions */
				devices_scan_subsystems(udev, "/block", NULL,
							NULL, NULL,
							&udev_enumerate->devices_list);
			}
		}
	}

	list_cleanup(udev, &subsystem_include_list);
	list_cleanup(udev, &subsystem_exclude_list);

	/* sort delayed devices to the end of the list */
	udev_list_entry_foreach(list_entry, list_get_entry(&udev_enumerate->devices_list)) {
		if (devices_delay(udev, udev_list_entry_get_name(list_entry)))
			list_entry_move_to_end(list_entry);
	}
	return udev_enumerate;
}

struct udev_enumerate *udev_enumerate_new_from_subsystems(struct udev *udev)
{
	struct udev_enumerate *udev_enumerate;
	char base[UTIL_PATH_SIZE];
	struct stat statbuf;
	const char *subsysdir;

	if (udev == NULL)
		return NULL;

	udev_enumerate = enumerate_new(udev);
	if (udev_enumerate == NULL)
		return NULL;

	util_strlcpy(base, udev_get_sys_path(udev), sizeof(base));
	util_strlcat(base, "/subsystem", sizeof(base));
	if (stat(base, &statbuf) == 0)
		subsysdir = "/subsystem";
	else
		subsysdir = "/bus";
	info(udev, "searching '%s/*' dir\n", subsysdir);
	devices_scan_subsystem(udev, subsysdir, NULL, NULL, &udev_enumerate->devices_list);
	info(udev, "searching '%s/*/drivers/*' dir\n", subsysdir);
	devices_scan_subsystems(udev, subsysdir, "/drivers",
				NULL, NULL,
				&udev_enumerate->devices_list);
	return udev_enumerate;
}
Commit	Line	Data
eb1f0e66 KS	1	/*
	2	* libudev - interface to udev device information
	3	*
	4	* Copyright (C) 2008 Kay Sievers <kay.sievers@vrfy.org>
	5	*
	6	* This program is free software: you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation, either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
eb1f0e66 KS	20	#include <stdio.h>
	21	#include <stdlib.h>
	22	#include <stddef.h>
	23	#include <unistd.h>
	24	#include <errno.h>
	25	#include <string.h>
	26	#include <dirent.h>
	27	#include <sys/stat.h>
	28
	29	#include "libudev.h"
	30	#include "libudev-private.h"
eb1f0e66	31
bf7ad0ea KS	32	struct udev_enumerate {
	33	struct udev *udev;
	34	int refcount;
e345e267	35	struct list_node devices_list;
bf7ad0ea KS	36	};
	37
	38	struct udev_enumerate udev_enumerate_ref(struct udev_enumerate udev_enumerate)
	39	{
	40	if (udev_enumerate == NULL)
	41	return NULL;
	42	udev_enumerate->refcount++;
	43	return udev_enumerate;
	44	}
	45
	46	void udev_enumerate_unref(struct udev_enumerate *udev_enumerate)
	47	{
	48	if (udev_enumerate == NULL)
	49	return;
	50	udev_enumerate->refcount--;
	51	if (udev_enumerate->refcount > 0)
	52	return;
	53	list_cleanup(udev_enumerate->udev, &udev_enumerate->devices_list);
	54	free(udev_enumerate);
	55	}
	56
bc8184ed KS	57	struct udev udev_enumerate_get_udev(struct udev_enumerate udev_enumerate)
	58	{
	59	if (udev_enumerate == NULL)
	60	return NULL;
	61	return udev_enumerate->udev;
	62	}
	63
0de33a61	64	struct udev_list_entry udev_enumerate_get_list_entry(struct udev_enumerate udev_enumerate)
bf7ad0ea KS	65	{
	66	if (udev_enumerate == NULL)
	67	return NULL;
	68	return list_get_entry(&udev_enumerate->devices_list);
	69	}
	70
eb1f0e66 KS	71	static int devices_scan_subsystem(struct udev *udev,
eb1f0e66 KS	72	const char basedir, const char subsystem, const char *subdir,
bc8184ed	73	struct list_node *devices_list)
eb1f0e66	74	{
3eb46ec6	75	char path[UTIL_PATH_SIZE];
eb1f0e66 KS	76	DIR *dir;
eb1f0e66 KS	77	struct dirent *dent;
eb1f0e66	78
8753fadf	79	util_strlcpy(path, udev_get_sys_path(udev), sizeof(path));
3eb46ec6	80	util_strlcat(path, basedir, sizeof(path));
6f67f1df KS	81	if (subsystem != NULL) {
	82	util_strlcat(path, "/", sizeof(path));
	83	util_strlcat(path, subsystem, sizeof(path));
	84	}
eb1f0e66	85	if (subdir != NULL)
3eb46ec6	86	util_strlcat(path, subdir, sizeof(path));
eb1f0e66 KS	87	dir = opendir(path);
	88	if (dir == NULL)
	89	return -1;
	90	for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
8753fadf	91	char syspath[UTIL_PATH_SIZE];
b03e89cf	92	char filename[UTIL_PATH_SIZE];
6f67f1df	93	struct stat statbuf;
eb1f0e66 KS	94
	95	if (dent->d_name[0] == '.')
	96	continue;
8753fadf KS	97	util_strlcpy(syspath, path, sizeof(syspath));
	98	util_strlcat(syspath, "/", sizeof(syspath));
	99	util_strlcat(syspath, dent->d_name, sizeof(syspath));
b03e89cf KS	100	util_strlcpy(filename, syspath, sizeof(filename));
	101	util_strlcat(filename, "/uevent", sizeof(filename));
	102	if (stat(filename, &statbuf) != 0)
6f67f1df	103	continue;
8753fadf	104	util_resolve_sys_link(udev, syspath, sizeof(syspath));
bc8184ed	105	list_entry_add(udev, devices_list, syspath, NULL, 1, 1);
eb1f0e66 KS	106	}
	107	closedir(dir);
	108	return 0;
	109	}
	110
	111	static int devices_scan_subsystems(struct udev *udev,
bc8184ed KS	112	const char basedir, const char subdir,
	113	struct udev_list_entry *subsystem_include_list,
	114	struct udev_list_entry *subsystem_exclude_list,
	115	struct list_node *devices_list)
eb1f0e66	116	{
bc8184ed KS	117	if (subsystem_include_list != NULL) {
bc8184ed KS	118	struct udev_list_entry *list_entry;
eb1f0e66	119
bc8184ed	120	/* if list of subsystems to scan is given, just use this list */
b03e89cf KS	121	udev_list_entry_foreach(list_entry, subsystem_include_list) {
	122	if (udev_list_entry_get_by_name(subsystem_exclude_list, udev_list_entry_get_name(list_entry)) != NULL)
	123	continue;
bc8184ed	124	devices_scan_subsystem(udev, basedir, udev_list_entry_get_name(list_entry), subdir, devices_list);
b03e89cf	125	}
bc8184ed KS	126	} else {
	127	char path[UTIL_PATH_SIZE];
	128	DIR *dir;
	129	struct dirent *dent;
	130
	131	/* if no list of subsystems to scan is given, scan all, and possible exclude some subsystems */
	132	util_strlcpy(path, udev_get_sys_path(udev), sizeof(path));
	133	util_strlcat(path, basedir, sizeof(path));
	134	dir = opendir(path);
	135	if (dir == NULL)
	136	return -1;
	137	for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
	138	if (dent->d_name[0] == '.')
	139	continue;
	140	if (udev_list_entry_get_by_name(subsystem_exclude_list, dent->d_name) != NULL)
	141	continue;
	142	devices_scan_subsystem(udev, basedir, dent->d_name, subdir, devices_list);
	143	}
	144	closedir(dir);
eb1f0e66	145	}
eb1f0e66 KS	146	return 0;
	147	}
	148
8753fadf	149	static int devices_delay(struct udev udev, const char syspath)
eb1f0e66 KS	150	{
	151	static const char *delay_device_list[] = {
	152	"/block/md",
	153	"/block/dm-",
	154	NULL
	155	};
8753fadf	156	size_t len;
eb1f0e66 KS	157	int i;
eb1f0e66 KS	158
8753fadf KS	159	len = strlen(udev_get_sys_path(udev));
8753fadf KS	160
eb1f0e66	161	for (i = 0; delay_device_list[i] != NULL; i++) {
8753fadf KS	162	if (strstr(&syspath[len], delay_device_list[i]) != NULL) {
8753fadf KS	163	info(udev, "delaying: %s\n", syspath);
eb1f0e66 KS	164	return 1;
	165	}
	166	}
	167	return 0;
	168	}
	169
6f67f1df KS	170	static struct udev_enumerate enumerate_new(struct udev udev)
	171	{
	172	struct udev_enumerate *udev_enumerate;
	173
	174	udev_enumerate = malloc(sizeof(struct udev_enumerate));
	175	if (udev_enumerate == NULL)
	176	return NULL;
	177	memset(udev_enumerate, 0x00, (sizeof(struct udev_enumerate)));
	178	udev_enumerate->refcount = 1;
	179	udev_enumerate->udev = udev;
	180	list_init(&udev_enumerate->devices_list);
	181	return udev_enumerate;
	182	}
	183
eb1f0e66	184	/**
bc8184ed	185	* udev_enumerate_new_from_devices:
a076080b	186	* @udev: udev library context
bc8184ed	187	* @subsystem: the list of names of subsystems to look for devices
eb1f0e66	188	*
bf7ad0ea	189	* Returns: an enumeration context
eb1f0e66	190	**/
bc8184ed	191	struct udev_enumerate udev_enumerate_new_from_devices(struct udev udev, const char *subsystem, ...)
eb1f0e66	192	{
bf7ad0ea	193	struct udev_enumerate *udev_enumerate;
bc8184ed KS	194	va_list vargs;
bc8184ed KS	195	const char *arg;
3eb46ec6	196	char base[UTIL_PATH_SIZE];
eb1f0e66	197	struct stat statbuf;
bc8184ed KS	198	struct list_node subsystem_include_list;
bc8184ed KS	199	struct list_node subsystem_exclude_list;
0de33a61	200	struct udev_list_entry *list_entry;
bf7ad0ea KS	201
	202	if (udev == NULL)
	203	return NULL;
eb1f0e66	204
6f67f1df	205	udev_enumerate = enumerate_new(udev);
bf7ad0ea KS	206	if (udev_enumerate == NULL)
bf7ad0ea KS	207	return NULL;
eb1f0e66	208
bc8184ed KS	209	va_start(vargs, subsystem);
	210	list_init(&subsystem_include_list);
	211	list_init(&subsystem_exclude_list);
	212	for (arg = subsystem; arg != NULL; arg = va_arg(vargs, const char *)) {
	213	if (arg[0] != '!')
	214	list_entry_add(udev, &subsystem_include_list, arg, NULL, 1, 0);
	215	else
	216	list_entry_add(udev, &subsystem_exclude_list, &arg[1], NULL, 1, 0);
	217	}
	218	va_end(vargs);
	219
3eb46ec6 KS	220	util_strlcpy(base, udev_get_sys_path(udev), sizeof(base));
3eb46ec6 KS	221	util_strlcat(base, "/subsystem", sizeof(base));
eb1f0e66	222	if (stat(base, &statbuf) == 0) {
b03e89cf	223	/* we have /subsystem/, forget all the old stuff */
6f67f1df	224	info(udev, "searching '/subsystem//devices/' dir\n");
bc8184ed KS	225	devices_scan_subsystems(udev, "/subsystem", "/devices",
	226	list_get_entry(&subsystem_include_list),
	227	list_get_entry(&subsystem_exclude_list),
	228	&udev_enumerate->devices_list);
eb1f0e66	229	} else {
6f67f1df	230	info(udev, "searching '/bus//devices/' dir\n");
bc8184ed KS	231	devices_scan_subsystems(udev, "/bus", "/devices",
	232	list_get_entry(&subsystem_include_list),
	233	list_get_entry(&subsystem_exclude_list),
	234	&udev_enumerate->devices_list);
6f67f1df	235	info(udev, "searching '/class/*' dir\n");
bc8184ed KS	236	devices_scan_subsystems(udev, "/class", NULL,
	237	list_get_entry(&subsystem_include_list),
	238	list_get_entry(&subsystem_exclude_list),
	239	&udev_enumerate->devices_list);
b03e89cf KS	240	/* if block isn't a class, scan /block/ */
	241	util_strlcpy(base, udev_get_sys_path(udev), sizeof(base));
	242	util_strlcat(base, "/class/block", sizeof(base));
	243	if (stat(base, &statbuf) != 0) {
	244	struct udev_list_entry *include_list = list_get_entry(&subsystem_include_list);
	245	struct udev_list_entry *exclude_list = list_get_entry(&subsystem_exclude_list);
	246	int include_block = (include_list == NULL \|\| udev_list_entry_get_by_name(include_list, "block") != NULL);
	247	int exclude_block = (udev_list_entry_get_by_name(exclude_list, "block") != NULL);
	248
	249	if (include_block && !exclude_block) {
	250	info(udev, "searching '/block//' dir\n");
	251	/* scan disks */
	252	devices_scan_subsystem(udev, "/block", NULL, NULL, &udev_enumerate->devices_list);
	253	/* scan partitions */
	254	devices_scan_subsystems(udev, "/block", NULL,
	255	NULL, NULL,
	256	&udev_enumerate->devices_list);
	257	}
	258	}
eb1f0e66 KS	259	}
eb1f0e66 KS	260
bc8184ed KS	261	list_cleanup(udev, &subsystem_include_list);
	262	list_cleanup(udev, &subsystem_exclude_list);
	263
bf7ad0ea	264	/* sort delayed devices to the end of the list */
0de33a61 KS	265	udev_list_entry_foreach(list_entry, list_get_entry(&udev_enumerate->devices_list)) {
	266	if (devices_delay(udev, udev_list_entry_get_name(list_entry)))
	267	list_entry_move_to_end(list_entry);
eb1f0e66	268	}
bf7ad0ea	269	return udev_enumerate;
eb1f0e66	270	}
bc8184ed KS	271
	272	struct udev_enumerate udev_enumerate_new_from_subsystems(struct udev udev)
	273	{
6f67f1df KS	274	struct udev_enumerate *udev_enumerate;
	275	char base[UTIL_PATH_SIZE];
	276	struct stat statbuf;
	277	const char *subsysdir;
	278
	279	if (udev == NULL)
	280	return NULL;
	281
	282	udev_enumerate = enumerate_new(udev);
	283	if (udev_enumerate == NULL)
	284	return NULL;
	285
	286	util_strlcpy(base, udev_get_sys_path(udev), sizeof(base));
	287	util_strlcat(base, "/subsystem", sizeof(base));
	288	if (stat(base, &statbuf) == 0)
	289	subsysdir = "/subsystem";
	290	else
	291	subsysdir = "/bus";
	292	info(udev, "searching '%s/*' dir\n", subsysdir);
	293	devices_scan_subsystem(udev, subsysdir, NULL, NULL, &udev_enumerate->devices_list);
	294	info(udev, "searching '%s//drivers/' dir\n", subsysdir);
	295	devices_scan_subsystems(udev, subsysdir, "/drivers",
	296	NULL, NULL,
	297	&udev_enumerate->devices_list);
	298	return udev_enumerate;
bc8184ed	299	}