X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=udev%2Flib%2Flibudev-enumerate.c;h=a92bf0b6207c165f561ef39f50d1fc5a08e652fa;hb=4061ab9f4bb0bdad3858e8ef1738dc892afe9de4;hp=7d2d592c92d1b6345591938a25d3ea4ada31d99b;hpb=cabfd8d0b487b856a2a41b9595e310e63674b99f;p=elogind.git diff --git a/udev/lib/libudev-enumerate.c b/udev/lib/libudev-enumerate.c index 7d2d592c9..a92bf0b62 100644 --- a/udev/lib/libudev-enumerate.c +++ b/udev/lib/libudev-enumerate.c @@ -3,18 +3,10 @@ * * Copyright (C) 2008 Kay Sievers * - * 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 . + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. */ #include @@ -30,14 +22,18 @@ #include "libudev.h" #include "libudev-private.h" +static int devices_sort(struct udev_enumerate *udev_enumerate); + struct udev_enumerate { struct udev *udev; int refcount; - struct list_node attr_match_list; - struct list_node attr_nomatch_list; - struct list_node subsystem_match_list; - struct list_node subsystem_nomatch_list; - struct list_node devices_list; + struct udev_list_node sysattr_match_list; + struct udev_list_node sysattr_nomatch_list; + struct udev_list_node subsystem_match_list; + struct udev_list_node subsystem_nomatch_list; + struct udev_list_node properties_match_list; + struct udev_list_node devices_list; + int devices_sorted; }; /** @@ -50,17 +46,17 @@ struct udev_enumerate *udev_enumerate_new(struct udev *udev) { struct udev_enumerate *udev_enumerate; - udev_enumerate = malloc(sizeof(struct udev_enumerate)); + udev_enumerate = calloc(1, 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); - list_init(&udev_enumerate->attr_match_list); - list_init(&udev_enumerate->attr_nomatch_list); - list_init(&udev_enumerate->subsystem_match_list); - list_init(&udev_enumerate->subsystem_nomatch_list); + udev_list_init(&udev_enumerate->devices_list); + udev_list_init(&udev_enumerate->sysattr_match_list); + udev_list_init(&udev_enumerate->sysattr_nomatch_list); + udev_list_init(&udev_enumerate->subsystem_match_list); + udev_list_init(&udev_enumerate->subsystem_nomatch_list); + udev_list_init(&udev_enumerate->properties_match_list); return udev_enumerate; } @@ -79,11 +75,12 @@ void udev_enumerate_unref(struct udev_enumerate *udev_enumerate) udev_enumerate->refcount--; if (udev_enumerate->refcount > 0) return; - list_cleanup(udev_enumerate->udev, &udev_enumerate->devices_list); - list_cleanup(udev_enumerate->udev, &udev_enumerate->attr_match_list); - list_cleanup(udev_enumerate->udev, &udev_enumerate->attr_nomatch_list); - list_cleanup(udev_enumerate->udev, &udev_enumerate->subsystem_match_list); - list_cleanup(udev_enumerate->udev, &udev_enumerate->subsystem_nomatch_list); + udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->devices_list); + udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->sysattr_match_list); + udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->sysattr_nomatch_list); + udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->subsystem_match_list); + udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->subsystem_nomatch_list); + udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->properties_match_list); free(udev_enumerate); } @@ -98,7 +95,9 @@ struct udev_list_entry *udev_enumerate_get_list_entry(struct udev_enumerate *ude { if (udev_enumerate == NULL) return NULL; - return list_get_entry(&udev_enumerate->devices_list); + if (!udev_enumerate->devices_sorted) + devices_sort(udev_enumerate); + return udev_list_get_entry(&udev_enumerate->devices_list); } int udev_enumerate_add_match_subsystem(struct udev_enumerate *udev_enumerate, const char *subsystem) @@ -107,8 +106,8 @@ int udev_enumerate_add_match_subsystem(struct udev_enumerate *udev_enumerate, co return -EINVAL; if (subsystem == NULL) return 0; - if (list_entry_add(udev_enumerate_get_udev(udev_enumerate), - &udev_enumerate->subsystem_match_list, subsystem, NULL, 1, 0) == NULL) + if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate), + &udev_enumerate->subsystem_match_list, subsystem, NULL, 1, 0) == NULL) return -ENOMEM; return 0; } @@ -119,37 +118,37 @@ int udev_enumerate_add_nomatch_subsystem(struct udev_enumerate *udev_enumerate, return -EINVAL; if (subsystem == NULL) return 0; - if (list_entry_add(udev_enumerate_get_udev(udev_enumerate), - &udev_enumerate->subsystem_nomatch_list, subsystem, NULL, 1, 0) == NULL) + if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate), + &udev_enumerate->subsystem_nomatch_list, subsystem, NULL, 1, 0) == NULL) return -ENOMEM; return 0; } -int udev_enumerate_add_match_attr(struct udev_enumerate *udev_enumerate, const char *attr, const char *value) +int udev_enumerate_add_match_sysattr(struct udev_enumerate *udev_enumerate, const char *sysattr, const char *value) { if (udev_enumerate == NULL) return -EINVAL; - if (attr == NULL) + if (sysattr == NULL) return 0; - if (list_entry_add(udev_enumerate_get_udev(udev_enumerate), - &udev_enumerate->attr_match_list, attr, value, 1, 0) == NULL) + if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate), + &udev_enumerate->sysattr_match_list, sysattr, value, 1, 0) == NULL) return -ENOMEM; return 0; } -int udev_enumerate_add_nomatch_attr(struct udev_enumerate *udev_enumerate, const char *attr, const char *value) +int udev_enumerate_add_nomatch_sysattr(struct udev_enumerate *udev_enumerate, const char *sysattr, const char *value) { if (udev_enumerate == NULL) return -EINVAL; - if (attr == NULL) + if (sysattr == NULL) return 0; - if (list_entry_add(udev_enumerate_get_udev(udev_enumerate), - &udev_enumerate->attr_nomatch_list, attr, value, 1, 0) == NULL) + if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate), + &udev_enumerate->sysattr_nomatch_list, sysattr, value, 1, 0) == NULL) return -ENOMEM; return 0; } -static int match_attr_value(struct udev *udev, const char *syspath, const char *attr, const char *match_val) +static int match_sysattr_value(struct udev *udev, const char *syspath, const char *sysattr, const char *match_val) { struct udev_device *device; const char *val = NULL; @@ -158,7 +157,7 @@ static int match_attr_value(struct udev *udev, const char *syspath, const char * device = udev_device_new_from_syspath(udev, syspath); if (device == NULL) return -EINVAL; - val = udev_device_get_attr_value(device, attr); + val = udev_device_get_sysattr_value(device, sysattr); if (val == NULL) goto exit; if (match_val == NULL) { @@ -174,23 +173,35 @@ exit: return match; } -static int match_attr(struct udev_enumerate *udev_enumerate, const char *syspath) +int udev_enumerate_add_match_property(struct udev_enumerate *udev_enumerate, const char *property, const char *value) +{ + if (udev_enumerate == NULL) + return -EINVAL; + if (property == NULL) + return 0; + if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate), + &udev_enumerate->properties_match_list, property, value, 1, 0) == NULL) + return -ENOMEM; + return 0; +} + +static int match_sysattr(struct udev_enumerate *udev_enumerate, const char *syspath) { struct udev *udev = udev_enumerate_get_udev(udev_enumerate); struct udev_list_entry *list_entry; /* skip list */ - udev_list_entry_foreach(list_entry, list_get_entry(&udev_enumerate->attr_nomatch_list)) { - if (match_attr_value(udev, syspath, + udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->sysattr_nomatch_list)) { + if (match_sysattr_value(udev, syspath, udev_list_entry_get_name(list_entry), udev_list_entry_get_value(list_entry))) return 0; } /* include list */ - if (list_get_entry(&udev_enumerate->attr_match_list) != NULL) { - udev_list_entry_foreach(list_entry, list_get_entry(&udev_enumerate->attr_match_list)) { + if (udev_list_get_entry(&udev_enumerate->sysattr_match_list) != NULL) { + udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->sysattr_match_list)) { /* anything that does not match, will make it FALSE */ - if (!match_attr_value(udev, syspath, + if (!match_sysattr_value(udev, syspath, udev_list_entry_get_name(list_entry), udev_list_entry_get_value(list_entry))) return 0; @@ -200,6 +211,51 @@ static int match_attr(struct udev_enumerate *udev_enumerate, const char *syspath return 1; } +static int match_property(struct udev_enumerate *udev_enumerate, const char *syspath) +{ + struct udev_device *dev; + struct udev_list_entry *list_entry; + int match = 0; + + /* no match always matches */ + if (udev_list_get_entry(&udev_enumerate->properties_match_list) == NULL) + return 1; + + /* no device does not match */ + dev = udev_device_new_from_syspath(udev_enumerate->udev, syspath); + if (dev == NULL) + return 0; + + /* loop over matches */ + udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->properties_match_list)) { + struct udev_list_entry *property_entry; + + /* loop over device properties */ + udev_list_entry_foreach(property_entry, udev_device_get_properties_list_entry(dev)) { + if (fnmatch(udev_list_entry_get_name(list_entry), udev_list_entry_get_name(property_entry), 0) == 0) { + const char *match_value; + const char *dev_value; + + match_value = udev_list_entry_get_value(list_entry); + dev_value = udev_list_entry_get_value(property_entry); + if (match_value == NULL && dev_value == NULL) { + match = 1; + goto out; + } + if (match_value == NULL || dev_value == NULL) + continue; + if (fnmatch(match_value, dev_value, 0) == 0) { + match = 1; + goto out; + } + } + } + } +out: + udev_device_unref(dev); + return match; +} + static int scan_dir_and_add_devices(struct udev_enumerate *udev_enumerate, const char *basedir, const char *subdir1, const char *subdir2) { @@ -242,9 +298,11 @@ static int scan_dir_and_add_devices(struct udev_enumerate *udev_enumerate, util_strlcat(filename, "/uevent", sizeof(filename)); if (stat(filename, &statbuf) != 0) continue; - if (!match_attr(udev_enumerate, syspath)) + if (!match_sysattr(udev_enumerate, syspath)) continue; - list_entry_add(udev, &udev_enumerate->devices_list, syspath, NULL, 1, 1); + if (!match_property(udev_enumerate, syspath)) + continue; + udev_list_entry_add(udev, &udev_enumerate->devices_list, syspath, NULL, 1, 1); } closedir(dir); return 0; @@ -254,12 +312,12 @@ static int match_subsystem(struct udev_enumerate *udev_enumerate, const char *su { struct udev_list_entry *list_entry; - udev_list_entry_foreach(list_entry, list_get_entry(&udev_enumerate->subsystem_nomatch_list)) { + udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->subsystem_nomatch_list)) { if (fnmatch(udev_list_entry_get_name(list_entry), subsystem, 0) == 0) return 0; } - if (list_get_entry(&udev_enumerate->subsystem_match_list) != NULL) { - udev_list_entry_foreach(list_entry, list_get_entry(&udev_enumerate->subsystem_match_list)) { + if (udev_list_get_entry(&udev_enumerate->subsystem_match_list) != NULL) { + udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->subsystem_match_list)) { if (fnmatch(udev_list_entry_get_name(list_entry), subsystem, 0) == 0) return 1; } @@ -306,30 +364,53 @@ static int devices_delay(struct udev *udev, const char *syspath) 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); + dbg(udev, "delaying: %s\n", syspath); return 1; } } return 0; } -int udev_enumerate_add_device(struct udev_enumerate *udev_enumerate, struct udev_device *udev_device) +/* sort delayed devices to the end of the list */ +static int devices_sort(struct udev_enumerate *udev_enumerate) +{ + struct udev_list_entry *entry_loop; + struct udev_list_entry *entry_tmp; + struct udev_list_node devices_list; + + udev_list_init(&devices_list); + /* move delayed to delay list */ + udev_list_entry_foreach_safe(entry_loop, entry_tmp, udev_list_get_entry(&udev_enumerate->devices_list)) { + if (devices_delay(udev_enumerate->udev, udev_list_entry_get_name(entry_loop))) { + udev_list_entry_remove(entry_loop); + udev_list_entry_append(entry_loop, &devices_list); + } + } + /* move delayed back to end of list */ + udev_list_entry_foreach_safe(entry_loop, entry_tmp, udev_list_get_entry(&devices_list)) { + udev_list_entry_remove(entry_loop); + udev_list_entry_append(entry_loop, &udev_enumerate->devices_list); + } + udev_enumerate->devices_sorted = 1; + return 0; +} + +int udev_enumerate_add_syspath(struct udev_enumerate *udev_enumerate, const char *syspath) { struct udev *udev = udev_enumerate_get_udev(udev_enumerate); - struct udev_list_entry *list_entry; + struct udev_device *udev_device; if (udev_enumerate == NULL) return -EINVAL; - if (udev_device == NULL) + if (syspath == NULL) return 0; - list_entry_add(udev, - &udev_enumerate->devices_list, - udev_device_get_syspath(udev_device), NULL, 1, 1); - /* 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); - } + /* resolve to real syspath */ + udev_device = udev_device_new_from_syspath(udev_enumerate->udev, syspath); + if (udev_device == NULL) + return -EINVAL; + udev_list_entry_add(udev, &udev_enumerate->devices_list, + udev_device_get_syspath(udev_device), NULL, 1, 1); + udev_device_unref(udev_device); return 0; } @@ -344,7 +425,6 @@ int udev_enumerate_scan_devices(struct udev_enumerate *udev_enumerate) struct udev *udev = udev_enumerate_get_udev(udev_enumerate); char base[UTIL_PATH_SIZE]; struct stat statbuf; - struct udev_list_entry *list_entry; if (udev_enumerate == NULL) return -EINVAL; @@ -352,32 +432,27 @@ int udev_enumerate_scan_devices(struct udev_enumerate *udev_enumerate) 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"); + dbg(udev, "searching '/subsystem/*/devices/*' dir\n"); scan_dir(udev_enumerate, "subsystem", "devices", NULL); } else { - info(udev, "searching '/bus/*/devices/*' dir\n"); + dbg(udev, "searching '/bus/*/devices/*' dir\n"); scan_dir(udev_enumerate, "bus", "devices", NULL); - info(udev, "searching '/class/*' dir\n"); + dbg(udev, "searching '/class/*' dir\n"); scan_dir(udev_enumerate, "class", NULL, NULL); /* 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) { if (match_subsystem(udev_enumerate, "block")) { - info(udev, "searching '/block/*' dir\n"); + dbg(udev, "searching '/block/*' dir\n"); /* scan disks */ scan_dir_and_add_devices(udev_enumerate, "block", NULL, NULL); /* scan partitions */ - info(udev, "searching '/block/*/*' dir\n"); + dbg(udev, "searching '/block/*/*' dir\n"); scan_dir(udev_enumerate, "block", NULL, "block"); } } } - /* 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 0; } @@ -403,11 +478,11 @@ int udev_enumerate_scan_subsystems(struct udev_enumerate *udev_enumerate) else subsysdir = "bus"; if (match_subsystem(udev_enumerate, "subsystem")) { - info(udev, "searching '%s/*' dir\n", subsysdir); + dbg(udev, "searching '%s/*' dir\n", subsysdir); scan_dir_and_add_devices(udev_enumerate, subsysdir, NULL, NULL); } if (match_subsystem(udev_enumerate, "drivers")) { - info(udev, "searching '%s/*/drivers/*' dir\n", subsysdir); + dbg(udev, "searching '%s/*/drivers/*' dir\n", subsysdir); scan_dir(udev_enumerate, subsysdir, "drivers", "drivers"); } return 0;