libudev/libudev-enumerate.c

   1 /*
   2  * libudev - interface to udev device information
   3  *
   4  * Copyright (C) 2008-2010 Kay Sievers <kay.sievers@vrfy.org>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  */
  11
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <stddef.h>
  15 #include <unistd.h>
  16 #include <errno.h>
  17 #include <string.h>
  18 #include <dirent.h>
  19 #include <fnmatch.h>
  20 #include <stdbool.h>
  21 #include <sys/stat.h>
  22 #include <sys/param.h>
  23
  24 #include "libudev.h"
  25 #include "libudev-private.h"
  26
  27 /**
  28  * SECTION:libudev-enumerate
  29  * @short_description: lookup and sort sys devices
  30  *
  31  * Lookup devices in the sys filesystem, filter devices by properties,
  32  * and return a sorted list of devices.
  33  */
  34
  35 struct syspath {
  36         char *syspath;
  37         size_t len;
  38 };
  39
  40 /**
  41  * udev_enumerate:
  42  *
  43  * Opaque object representing one device lookup/sort context.
  44  */
  45 struct udev_enumerate {
  46         struct udev *udev;
  47         int refcount;
  48         struct udev_list_node sysattr_match_list;
  49         struct udev_list_node sysattr_nomatch_list;
  50         struct udev_list_node subsystem_match_list;
  51         struct udev_list_node subsystem_nomatch_list;
  52         struct udev_list_node sysname_match_list;
  53         struct udev_list_node properties_match_list;
  54         struct udev_list_node tags_match_list;
  55         struct udev_device *parent_match;
  56         struct udev_list_node devices_list;
  57         struct syspath *devices;
  58         unsigned int devices_cur;
  59         unsigned int devices_max;
  60         bool devices_uptodate:1;
  61         bool match_is_initialized;
  62 };
  63
  64 /**
  65  * udev_enumerate_new:
  66  * @udev: udev library context
  67  *
  68  * Returns: an enumeration context
  69  **/
  70 UDEV_EXPORT struct udev_enumerate *udev_enumerate_new(struct udev *udev)
  71 {
  72         struct udev_enumerate *udev_enumerate;
  73
  74         udev_enumerate = calloc(1, sizeof(struct udev_enumerate));
  75         if (udev_enumerate == NULL)
  76                 return NULL;
  77         udev_enumerate->refcount = 1;
  78         udev_enumerate->udev = udev;
  79         udev_list_init(&udev_enumerate->sysattr_match_list);
  80         udev_list_init(&udev_enumerate->sysattr_nomatch_list);
  81         udev_list_init(&udev_enumerate->subsystem_match_list);
  82         udev_list_init(&udev_enumerate->subsystem_nomatch_list);
  83         udev_list_init(&udev_enumerate->sysname_match_list);
  84         udev_list_init(&udev_enumerate->properties_match_list);
  85         udev_list_init(&udev_enumerate->tags_match_list);
  86         udev_list_init(&udev_enumerate->devices_list);
  87         return udev_enumerate;
  88 }
  89
  90 /**
  91  * udev_enumerate_ref:
  92  * @udev_enumerate: context
  93  *
  94  * Take a reference of a enumeration context.
  95  *
  96  * Returns: the passed enumeration context
  97  **/
  98 UDEV_EXPORT struct udev_enumerate *udev_enumerate_ref(struct udev_enumerate *udev_enumerate)
  99 {
 100         if (udev_enumerate == NULL)
 101                 return NULL;
 102         udev_enumerate->refcount++;
 103         return udev_enumerate;
 104 }
 105
 106 /**
 107  * udev_enumerate_unref:
 108  * @udev_enumerate: context
 109  *
 110  * Drop a reference of an enumeration context. If the refcount reaches zero,
 111  * all resources of the enumeration context will be released.
 112  **/
 113 UDEV_EXPORT void udev_enumerate_unref(struct udev_enumerate *udev_enumerate)
 114 {
 115         unsigned int i;
 116
 117         if (udev_enumerate == NULL)
 118                 return;
 119         udev_enumerate->refcount--;
 120         if (udev_enumerate->refcount > 0)
 121                 return;
 122         udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->sysattr_match_list);
 123         udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->sysattr_nomatch_list);
 124         udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->subsystem_match_list);
 125         udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->subsystem_nomatch_list);
 126         udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->sysname_match_list);
 127         udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->properties_match_list);
 128         udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->tags_match_list);
 129         udev_device_unref(udev_enumerate->parent_match);
 130         udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->devices_list);
 131         for (i = 0; i < udev_enumerate->devices_cur; i++)
 132                 free(udev_enumerate->devices[i].syspath);
 133         free(udev_enumerate->devices);
 134         free(udev_enumerate);
 135 }
 136
 137 /**
 138  * udev_enumerate_get_udev:
 139  * @udev_enumerate: context
 140  *
 141  * Returns: the udev library context.
 142  */
 143 UDEV_EXPORT struct udev *udev_enumerate_get_udev(struct udev_enumerate *udev_enumerate)
 144 {
 145         if (udev_enumerate == NULL)
 146                 return NULL;
 147         return udev_enumerate->udev;
 148 }
 149
 150 static int syspath_add(struct udev_enumerate *udev_enumerate, const char *syspath)
 151 {
 152         char *path;
 153         struct syspath *entry;
 154
 155         /* double array size if needed */
 156         if (udev_enumerate->devices_cur >= udev_enumerate->devices_max) {
 157                 struct syspath *buf;
 158                 unsigned int add;
 159
 160                 add = udev_enumerate->devices_max;
 161                 if (add < 1024)
 162                         add = 1024;
 163                 buf = realloc(udev_enumerate->devices, (udev_enumerate->devices_max + add) * sizeof(struct syspath));
 164                 if (buf == NULL)
 165                         return -ENOMEM;
 166                 udev_enumerate->devices = buf;
 167                 udev_enumerate->devices_max += add;
 168         }
 169
 170         path = strdup(syspath);
 171         if (path == NULL)
 172                 return -ENOMEM;
 173         entry = &udev_enumerate->devices[udev_enumerate->devices_cur];
 174         entry->syspath = path;
 175         entry->len = strlen(path);
 176         udev_enumerate->devices_cur++;
 177         udev_enumerate->devices_uptodate = false;
 178         return 0;
 179 }
 180
 181 static int syspath_cmp(const void *p1, const void *p2)
 182 {
 183         const struct syspath *path1 = p1;
 184         const struct syspath *path2 = p2;
 185         size_t len;
 186         int ret;
 187
 188         len = MIN(path1->len, path2->len);
 189         ret = memcmp(path1->syspath, path2->syspath, len);
 190         if (ret == 0) {
 191                 if (path1->len < path2->len)
 192                         ret = -1;
 193                 else if (path1->len > path2->len)
 194                         ret = 1;
 195         }
 196         return ret;
 197 }
 198
 199 /* For devices that should be moved to the absolute end of the list */
 200 static bool devices_delay_end(struct udev *udev, const char *syspath)
 201 {
 202         static const char *delay_device_list[] = {
 203                 "/block/md",
 204                 "/block/dm-",
 205                 NULL
 206         };
 207         size_t len;
 208         int i;
 209
 210         len = strlen(udev_get_sys_path(udev));
 211         for (i = 0; delay_device_list[i] != NULL; i++) {
 212                 if (strstr(&syspath[len], delay_device_list[i]) != NULL) {
 213                         dbg(udev, "delaying: %s\n", syspath);
 214                         return true;
 215                 }
 216         }
 217         return false;
 218 }
 219
 220 /* For devices that should just be moved a little bit later, just
 221  * before the point where some common path prefix changes. Returns the
 222  * number of characters that make up that common prefix */
 223 static size_t devices_delay_later(struct udev *udev, const char *syspath)
 224 {
 225         const char *c;
 226
 227         /* For sound cards the control device must be enumerated last
 228          * to make sure it's the final device node that gets ACLs
 229          * applied. Applications rely on this fact and use ACL changes
 230          * on the control node as an indicator that the ACL change of
 231          * the entire sound card completed. The kernel makes this
 232          * guarantee when creating those devices, and hence we should
 233          * too when enumerating them. */
 234
 235         if ((c = strstr(syspath, "/sound/card"))) {
 236                 c += 11;
 237                 c += strcspn(c, "/");
 238
 239                 if (strncmp(c, "/controlC", 9) == 0)
 240                         return c - syspath + 1;
 241         }
 242
 243         return 0;
 244 }
 245
 246 /**
 247  * udev_enumerate_get_list_entry:
 248  * @udev_enumerate: context
 249  *
 250  * Returns: the first entry of the sorted list of device paths.
 251  */
 252 UDEV_EXPORT struct udev_list_entry *udev_enumerate_get_list_entry(struct udev_enumerate *udev_enumerate)
 253 {
 254         if (udev_enumerate == NULL)
 255                 return NULL;
 256         if (!udev_enumerate->devices_uptodate) {
 257                 unsigned int i;
 258                 unsigned int max;
 259                 struct syspath *prev = NULL, *move_later = NULL;
 260                 size_t move_later_prefix = 0;
 261
 262                 udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->devices_list);
 263                 qsort(udev_enumerate->devices, udev_enumerate->devices_cur, sizeof(struct syspath), syspath_cmp);
 264
 265                 max = udev_enumerate->devices_cur;
 266                 for (i = 0; i < max; i++) {
 267                         struct syspath *entry = &udev_enumerate->devices[i];
 268
 269                         /* skip duplicated entries */
 270                         if (prev != NULL &&
 271                             entry->len == prev->len &&
 272                             memcmp(entry->syspath, prev->syspath, entry->len) == 0)
 273                                 continue;
 274                         prev = entry;
 275
 276                         /* skip to be delayed devices, and add them to the end of the list */
 277                         if (devices_delay_end(udev_enumerate->udev, entry->syspath)) {
 278                                 syspath_add(udev_enumerate, entry->syspath);
 279                                 /* need to update prev here for the case realloc() gives a different address */
 280                                 prev = &udev_enumerate->devices[i];
 281                                 continue;
 282                         }
 283
 284                         /* skip to be delayed devices, and move the to
 285                          * the point where the prefix changes. We can
 286                          * only move one item at a time. */
 287                         if (!move_later) {
 288                                 move_later_prefix = devices_delay_later(udev_enumerate->udev, entry->syspath);
 289
 290                                 if (move_later_prefix > 0) {
 291                                         move_later = entry;
 292                                         continue;
 293                                 }
 294                         }
 295
 296                         if (move_later &&
 297                             strncmp(entry->syspath, move_later->syspath, move_later_prefix) != 0) {
 298
 299                                 udev_list_entry_add(udev_enumerate->udev, &udev_enumerate->devices_list,
 300                                             move_later->syspath, NULL, 0);
 301                                 move_later = NULL;
 302                         }
 303
 304                         udev_list_entry_add(udev_enumerate->udev, &udev_enumerate->devices_list,
 305                                             entry->syspath, NULL, 0);
 306                 }
 307
 308                 if (move_later)
 309                         udev_list_entry_add(udev_enumerate->udev, &udev_enumerate->devices_list,
 310                                             move_later->syspath, NULL, 0);
 311
 312                 /* add and cleanup delayed devices from end of list */
 313                 for (i = max; i < udev_enumerate->devices_cur; i++) {
 314                         struct syspath *entry = &udev_enumerate->devices[i];
 315
 316                         udev_list_entry_add(udev_enumerate->udev, &udev_enumerate->devices_list,
 317                                             entry->syspath, NULL, 0);
 318                         free(entry->syspath);
 319                 }
 320                 udev_enumerate->devices_cur = max;
 321
 322                 udev_enumerate->devices_uptodate = true;
 323         }
 324         return udev_list_get_entry(&udev_enumerate->devices_list);
 325 }
 326
 327 /**
 328  * udev_enumerate_add_match_subsystem:
 329  * @udev_enumerate: context
 330  * @subsystem: filter for a subsystem of the device to include in the list
 331  *
 332  * Returns: 0 on success, otherwise a negative error value.
 333  */
 334 UDEV_EXPORT int udev_enumerate_add_match_subsystem(struct udev_enumerate *udev_enumerate, const char *subsystem)
 335 {
 336         if (udev_enumerate == NULL)
 337                 return -EINVAL;
 338         if (subsystem == NULL)
 339                 return 0;
 340         if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
 341                                 &udev_enumerate->subsystem_match_list, subsystem, NULL, UDEV_LIST_UNIQUE) == NULL)
 342                 return -ENOMEM;
 343         return 0;
 344 }
 345
 346 /**
 347  * udev_enumerate_add_nomatch_subsystem:
 348  * @udev_enumerate: context
 349  * @subsystem: filter for a subsystem of the device to exclude from the list
 350  *
 351  * Returns: 0 on success, otherwise a negative error value.
 352  */
 353 UDEV_EXPORT int udev_enumerate_add_nomatch_subsystem(struct udev_enumerate *udev_enumerate, const char *subsystem)
 354 {
 355         if (udev_enumerate == NULL)
 356                 return -EINVAL;
 357         if (subsystem == NULL)
 358                 return 0;
 359         if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
 360                                 &udev_enumerate->subsystem_nomatch_list, subsystem, NULL, UDEV_LIST_UNIQUE) == NULL)
 361                 return -ENOMEM;
 362         return 0;
 363 }
 364
 365 /**
 366  * udev_enumerate_add_match_sysattr:
 367  * @udev_enumerate: context
 368  * @sysattr: filter for a sys attribute at the device to include in the list
 369  * @value: optional value of the sys attribute
 370  *
 371  * Returns: 0 on success, otherwise a negative error value.
 372  */
 373 UDEV_EXPORT int udev_enumerate_add_match_sysattr(struct udev_enumerate *udev_enumerate, const char *sysattr, const char *value)
 374 {
 375         if (udev_enumerate == NULL)
 376                 return -EINVAL;
 377         if (sysattr == NULL)
 378                 return 0;
 379         if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
 380                                 &udev_enumerate->sysattr_match_list, sysattr, value, 0) == NULL)
 381                 return -ENOMEM;
 382         return 0;
 383 }
 384
 385 /**
 386  * udev_enumerate_add_nomatch_sysattr:
 387  * @udev_enumerate: context
 388  * @sysattr: filter for a sys attribute at the device to exclude from the list
 389  * @value: optional value of the sys attribute
 390  *
 391  * Returns: 0 on success, otherwise a negative error value.
 392  */
 393 UDEV_EXPORT int udev_enumerate_add_nomatch_sysattr(struct udev_enumerate *udev_enumerate, const char *sysattr, const char *value)
 394 {
 395         if (udev_enumerate == NULL)
 396                 return -EINVAL;
 397         if (sysattr == NULL)
 398                 return 0;
 399         if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
 400                            &udev_enumerate->sysattr_nomatch_list, sysattr, value, 0) == NULL)
 401                 return -ENOMEM;
 402         return 0;
 403 }
 404
 405 static int match_sysattr_value(struct udev_device *dev, const char *sysattr, const char *match_val)
 406 {
 407         const char *val = NULL;
 408         bool match = false;
 409
 410         val = udev_device_get_sysattr_value(dev, sysattr);
 411         if (val == NULL)
 412                 goto exit;
 413         if (match_val == NULL) {
 414                 match = true;
 415                 goto exit;
 416         }
 417         if (fnmatch(match_val, val, 0) == 0) {
 418                 match = true;
 419                 goto exit;
 420         }
 421 exit:
 422         return match;
 423 }
 424
 425 /**
 426  * udev_enumerate_add_match_property:
 427  * @udev_enumerate: context
 428  * @property: filter for a property of the device to include in the list
 429  * @value: value of the property
 430  *
 431  * Returns: 0 on success, otherwise a negative error value.
 432  */
 433 UDEV_EXPORT int udev_enumerate_add_match_property(struct udev_enumerate *udev_enumerate, const char *property, const char *value)
 434 {
 435         if (udev_enumerate == NULL)
 436                 return -EINVAL;
 437         if (property == NULL)
 438                 return 0;
 439         if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
 440                                 &udev_enumerate->properties_match_list, property, value, 0) == NULL)
 441                 return -ENOMEM;
 442         return 0;
 443 }
 444
 445 /**
 446  * udev_enumerate_add_match_tag:
 447  * @udev_enumerate: context
 448  * @tag: filter for a tag of the device to include in the list
 449  *
 450  * Returns: 0 on success, otherwise a negative error value.
 451  */
 452 UDEV_EXPORT int udev_enumerate_add_match_tag(struct udev_enumerate *udev_enumerate, const char *tag)
 453 {
 454         if (udev_enumerate == NULL)
 455                 return -EINVAL;
 456         if (tag == NULL)
 457                 return 0;
 458         if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
 459                                 &udev_enumerate->tags_match_list, tag, NULL, UDEV_LIST_UNIQUE) == NULL)
 460                 return -ENOMEM;
 461         return 0;
 462 }
 463
 464 /**
 465  * udev_enumerate_add_match_parent:
 466  * @udev_enumerate: context
 467  * @parent: parent device where to start searching
 468  *
 469  * Return the devices on the subtree of one given device. The parent
 470  * itself is included in the list.
 471  *
 472  * A reference for the device is held until the udev_enumerate context
 473  * is cleaned up.
 474  *
 475  * Returns: 0 on success, otherwise a negative error value.
 476  */
 477 UDEV_EXPORT int udev_enumerate_add_match_parent(struct udev_enumerate *udev_enumerate, struct udev_device *parent)
 478 {
 479         if (udev_enumerate == NULL)
 480                 return -EINVAL;
 481         if (parent == NULL)
 482                 return 0;
 483         if (udev_enumerate->parent_match != NULL)
 484                 udev_device_unref(udev_enumerate->parent_match);
 485         udev_enumerate->parent_match = udev_device_ref(parent);
 486         return 0;
 487 }
 488
 489 /**
 490  * udev_enumerate_add_match_is_initialized:
 491  * @udev_enumerate: context
 492  *
 493  * Match only devices which udev has set up already. This makes
 494  * sure, that the device node permissions and context are properly set
 495  * and that network devices are fully renamed.
 496  *
 497  * Usually, devices which are found in the kernel but not already
 498  * handled by udev, have still pending events. Services should subscribe
 499  * to monitor events and wait for these devices to become ready, instead
 500  * of using uninitialized devices.
 501  *
 502  * For now, this will not affect devices which do not have a device node
 503  * and are not network interfaces.
 504  *
 505  * Returns: 0 on success, otherwise a negative error value.
 506  */
 507 UDEV_EXPORT int udev_enumerate_add_match_is_initialized(struct udev_enumerate *udev_enumerate)
 508 {
 509         if (udev_enumerate == NULL)
 510                 return -EINVAL;
 511         udev_enumerate->match_is_initialized = true;
 512         return 0;
 513 }
 514
 515 /**
 516  * udev_enumerate_add_match_sysname:
 517  * @udev_enumerate: context
 518  * @sysname: filter for the name of the device to include in the list
 519  *
 520  * Returns: 0 on success, otherwise a negative error value.
 521  */
 522 UDEV_EXPORT int udev_enumerate_add_match_sysname(struct udev_enumerate *udev_enumerate, const char *sysname)
 523 {
 524         if (udev_enumerate == NULL)
 525                 return -EINVAL;
 526         if (sysname == NULL)
 527                 return 0;
 528         if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
 529                                 &udev_enumerate->sysname_match_list, sysname, NULL, UDEV_LIST_UNIQUE) == NULL)
 530                 return -ENOMEM;
 531         return 0;
 532 }
 533
 534 static bool match_sysattr(struct udev_enumerate *udev_enumerate, struct udev_device *dev)
 535 {
 536         struct udev_list_entry *list_entry;
 537
 538         /* skip list */
 539         udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->sysattr_nomatch_list)) {
 540                 if (match_sysattr_value(dev, udev_list_entry_get_name(list_entry),
 541                                         udev_list_entry_get_value(list_entry)))
 542                         return false;
 543         }
 544         /* include list */
 545         if (udev_list_get_entry(&udev_enumerate->sysattr_match_list) != NULL) {
 546                 udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->sysattr_match_list)) {
 547                         /* anything that does not match, will make it FALSE */
 548                         if (!match_sysattr_value(dev, udev_list_entry_get_name(list_entry),
 549                                                  udev_list_entry_get_value(list_entry)))
 550                                 return false;
 551                 }
 552                 return true;
 553         }
 554         return true;
 555 }
 556
 557 static bool match_property(struct udev_enumerate *udev_enumerate, struct udev_device *dev)
 558 {
 559         struct udev_list_entry *list_entry;
 560         bool match = false;
 561
 562         /* no match always matches */
 563         if (udev_list_get_entry(&udev_enumerate->properties_match_list) == NULL)
 564                 return true;
 565
 566         /* loop over matches */
 567         udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->properties_match_list)) {
 568                 const char *match_key = udev_list_entry_get_name(list_entry);
 569                 const char *match_value = udev_list_entry_get_value(list_entry);
 570                 struct udev_list_entry *property_entry;
 571
 572                 /* loop over device properties */
 573                 udev_list_entry_foreach(property_entry, udev_device_get_properties_list_entry(dev)) {
 574                         const char *dev_key = udev_list_entry_get_name(property_entry);
 575                         const char *dev_value = udev_list_entry_get_value(property_entry);
 576
 577                         if (fnmatch(match_key, dev_key, 0) != 0)
 578                                 continue;
 579                         if (match_value == NULL && dev_value == NULL) {
 580                                 match = true;
 581                                 goto out;
 582                         }
 583                         if (match_value == NULL || dev_value == NULL)
 584                                 continue;
 585                         if (fnmatch(match_value, dev_value, 0) == 0) {
 586                                 match = true;
 587                                 goto out;
 588                         }
 589                 }
 590         }
 591 out:
 592         return match;
 593 }
 594
 595 static bool match_tag(struct udev_enumerate *udev_enumerate, struct udev_device *dev)
 596 {
 597         struct udev_list_entry *list_entry;
 598
 599         /* no match always matches */
 600         if (udev_list_get_entry(&udev_enumerate->tags_match_list) == NULL)
 601                 return true;
 602
 603         /* loop over matches */
 604         udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->tags_match_list))
 605                 if (!udev_device_has_tag(dev, udev_list_entry_get_name(list_entry)))
 606                         return false;
 607
 608         return true;
 609 }
 610
 611 static bool match_parent(struct udev_enumerate *udev_enumerate, struct udev_device *dev)
 612 {
 613         const char *parent;
 614
 615         if (udev_enumerate->parent_match == NULL)
 616                 return true;
 617
 618         parent = udev_device_get_devpath(udev_enumerate->parent_match);
 619         return strncmp(parent, udev_device_get_devpath(dev), strlen(parent)) == 0;
 620 }
 621
 622 static bool match_sysname(struct udev_enumerate *udev_enumerate, const char *sysname)
 623 {
 624         struct udev_list_entry *list_entry;
 625
 626         if (udev_list_get_entry(&udev_enumerate->sysname_match_list) == NULL)
 627                 return true;
 628
 629         udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->sysname_match_list)) {
 630                 if (fnmatch(udev_list_entry_get_name(list_entry), sysname, 0) != 0)
 631                         continue;
 632                 return true;
 633         }
 634         return false;
 635 }
 636
 637 static int scan_dir_and_add_devices(struct udev_enumerate *udev_enumerate,
 638                                     const char *basedir, const char *subdir1, const char *subdir2)
 639 {
 640         struct udev *udev = udev_enumerate_get_udev(udev_enumerate);
 641         char path[UTIL_PATH_SIZE];
 642         size_t l;
 643         char *s;
 644         DIR *dir;
 645         struct dirent *dent;
 646
 647         s = path;
 648         l = util_strpcpyl(&s, sizeof(path), udev_get_sys_path(udev), "/", basedir, NULL);
 649         if (subdir1 != NULL)
 650                 l = util_strpcpyl(&s, l, "/", subdir1, NULL);
 651         if (subdir2 != NULL)
 652                 util_strpcpyl(&s, l, "/", subdir2, NULL);
 653         dir = opendir(path);
 654         if (dir == NULL)
 655                 return -ENOENT;
 656         for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
 657                 char syspath[UTIL_PATH_SIZE];
 658                 struct udev_device *dev;
 659
 660                 if (dent->d_name[0] == '.')
 661                         continue;
 662
 663                 if (!match_sysname(udev_enumerate, dent->d_name))
 664                         continue;
 665
 666                 util_strscpyl(syspath, sizeof(syspath), path, "/", dent->d_name, NULL);
 667                 dev = udev_device_new_from_syspath(udev_enumerate->udev, syspath);
 668                 if (dev == NULL)
 669                         continue;
 670
 671                 if (udev_enumerate->match_is_initialized) {
 672                         /*
 673                          * All devices with a device node or network interfaces
 674                          * possibly need udev to adjust the device node permission
 675                          * or context, or rename the interface before it can be
 676                          * reliably used from other processes.
 677                          *
 678                          * For now, we can only check these types of devices, we
 679                          * might not store a database, and have no way to find out
 680                          * for all other types of devices.
 681                          */
 682                         if (!udev_device_get_is_initialized(dev) &&
 683                             (major(udev_device_get_devnum(dev)) > 0 || udev_device_get_ifindex(dev) > 0))
 684                                 goto nomatch;
 685                 }
 686                 if (!match_parent(udev_enumerate, dev))
 687                         goto nomatch;
 688                 if (!match_tag(udev_enumerate, dev))
 689                         goto nomatch;
 690                 if (!match_property(udev_enumerate, dev))
 691                         goto nomatch;
 692                 if (!match_sysattr(udev_enumerate, dev))
 693                         goto nomatch;
 694
 695                 syspath_add(udev_enumerate, udev_device_get_syspath(dev));
 696 nomatch:
 697                 udev_device_unref(dev);
 698         }
 699         closedir(dir);
 700         return 0;
 701 }
 702
 703 static bool match_subsystem(struct udev_enumerate *udev_enumerate, const char *subsystem)
 704 {
 705         struct udev_list_entry *list_entry;
 706
 707         udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->subsystem_nomatch_list)) {
 708                 if (fnmatch(udev_list_entry_get_name(list_entry), subsystem, 0) == 0)
 709                         return false;
 710         }
 711         if (udev_list_get_entry(&udev_enumerate->subsystem_match_list) != NULL) {
 712                 udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->subsystem_match_list)) {
 713                         if (fnmatch(udev_list_entry_get_name(list_entry), subsystem, 0) == 0)
 714                                 return true;
 715                 }
 716                 return false;
 717         }
 718         return true;
 719 }
 720
 721 static int scan_dir(struct udev_enumerate *udev_enumerate, const char *basedir, const char *subdir, const char *subsystem)
 722 {
 723         struct udev *udev = udev_enumerate_get_udev(udev_enumerate);
 724
 725         char path[UTIL_PATH_SIZE];
 726         DIR *dir;
 727         struct dirent *dent;
 728
 729         util_strscpyl(path, sizeof(path), udev_get_sys_path(udev), "/", basedir, NULL);
 730         dir = opendir(path);
 731         if (dir == NULL)
 732                 return -1;
 733         for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
 734                 if (dent->d_name[0] == '.')
 735                         continue;
 736                 if (!match_subsystem(udev_enumerate, subsystem != NULL ? subsystem : dent->d_name))
 737                         continue;
 738                 scan_dir_and_add_devices(udev_enumerate, basedir, dent->d_name, subdir);
 739         }
 740         closedir(dir);
 741         return 0;
 742 }
 743
 744 /**
 745  * udev_enumerate_add_syspath:
 746  * @udev_enumerate: context
 747  * @syspath: path of a device
 748  *
 749  * Add a device to the list of devices, to retrieve it back sorted in dependency order.
 750  *
 751  * Returns: 0 on success, otherwise a negative error value.
 752  */
 753 UDEV_EXPORT int udev_enumerate_add_syspath(struct udev_enumerate *udev_enumerate, const char *syspath)
 754 {
 755         struct udev_device *udev_device;
 756
 757         if (udev_enumerate == NULL)
 758                 return -EINVAL;
 759         if (syspath == NULL)
 760                 return 0;
 761         /* resolve to real syspath */
 762         udev_device = udev_device_new_from_syspath(udev_enumerate->udev, syspath);
 763         if (udev_device == NULL)
 764                 return -EINVAL;
 765         syspath_add(udev_enumerate, udev_device_get_syspath(udev_device));
 766         udev_device_unref(udev_device);
 767         return 0;
 768 }
 769
 770 static int scan_devices_tags(struct udev_enumerate *udev_enumerate)
 771 {
 772         struct udev *udev = udev_enumerate_get_udev(udev_enumerate);
 773         struct udev_list_entry *list_entry;
 774
 775         /* scan only tagged devices, use tags reverse-index, instead of searching all devices in /sys */
 776         udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->tags_match_list)) {
 777                 DIR *dir;
 778                 struct dirent *dent;
 779                 char path[UTIL_PATH_SIZE];
 780
 781                 util_strscpyl(path, sizeof(path), udev_get_run_path(udev), "/tags/",
 782                               udev_list_entry_get_name(list_entry), NULL);
 783                 dir = opendir(path);
 784                 if (dir == NULL)
 785                         continue;
 786                 for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
 787                         struct udev_device *dev;
 788
 789                         if (dent->d_name[0] == '.')
 790                                 continue;
 791
 792                         dev = udev_device_new_from_id_filename(udev_enumerate->udev, dent->d_name);
 793                         if (dev == NULL)
 794                                 continue;
 795
 796                         if (!match_subsystem(udev_enumerate, udev_device_get_subsystem(dev)))
 797                                 goto nomatch;
 798                         if (!match_sysname(udev_enumerate, udev_device_get_sysname(dev)))
 799                                 goto nomatch;
 800                         if (!match_parent(udev_enumerate, dev))
 801                                 goto nomatch;
 802                         if (!match_property(udev_enumerate, dev))
 803                                 goto nomatch;
 804                         if (!match_sysattr(udev_enumerate, dev))
 805                                 goto nomatch;
 806
 807                         syspath_add(udev_enumerate, udev_device_get_syspath(dev));
 808 nomatch:
 809                         udev_device_unref(dev);
 810                 }
 811                 closedir(dir);
 812         }
 813         return 0;
 814 }
 815
 816 static int parent_add_child(struct udev_enumerate *enumerate, const char *path)
 817 {
 818         struct udev_device *dev;
 819
 820         dev = udev_device_new_from_syspath(enumerate->udev, path);
 821         if (dev == NULL)
 822                 return -ENODEV;
 823
 824         if (!match_subsystem(enumerate, udev_device_get_subsystem(dev)))
 825                 return 0;
 826         if (!match_sysname(enumerate, udev_device_get_sysname(dev)))
 827                 return 0;
 828         if (!match_property(enumerate, dev))
 829                 return 0;
 830         if (!match_sysattr(enumerate, dev))
 831                 return 0;
 832
 833         syspath_add(enumerate, udev_device_get_syspath(dev));
 834         udev_device_unref(dev);
 835         return 1;
 836 }
 837
 838 static int parent_crawl_children(struct udev_enumerate *enumerate, const char *path, int maxdepth)
 839 {
 840         DIR *d;
 841         struct dirent *dent;
 842
 843         d = opendir(path);
 844         if (d == NULL)
 845                 return -errno;
 846
 847         for (dent = readdir(d); dent != NULL; dent = readdir(d)) {
 848                 char *child;
 849
 850                 if (dent->d_name[0] == '.')
 851                         continue;
 852                 if (dent->d_type != DT_DIR)
 853                         continue;
 854                 if (asprintf(&child, "%s/%s", path, dent->d_name) < 0)
 855                         continue;
 856                 parent_add_child(enumerate, child);
 857                 if (maxdepth > 0)
 858                         parent_crawl_children(enumerate, child, maxdepth-1);
 859                 free(child);
 860         }
 861
 862         closedir(d);
 863         return 0;
 864 }
 865
 866 static int scan_devices_children(struct udev_enumerate *enumerate)
 867 {
 868         const char *path;
 869
 870         path = udev_device_get_syspath(enumerate->parent_match);
 871         parent_add_child(enumerate, path);
 872         return parent_crawl_children(enumerate, path, 256);
 873 }
 874
 875 static int scan_devices_all(struct udev_enumerate *udev_enumerate)
 876 {
 877         struct udev *udev = udev_enumerate_get_udev(udev_enumerate);
 878         char base[UTIL_PATH_SIZE];
 879         struct stat statbuf;
 880
 881         util_strscpyl(base, sizeof(base), udev_get_sys_path(udev), "/subsystem", NULL);
 882         if (stat(base, &statbuf) == 0) {
 883                 /* we have /subsystem/, forget all the old stuff */
 884                 dbg(udev, "searching '/subsystem/*/devices/*' dir\n");
 885                 scan_dir(udev_enumerate, "subsystem", "devices", NULL);
 886         } else {
 887                 dbg(udev, "searching '/bus/*/devices/*' dir\n");
 888                 scan_dir(udev_enumerate, "bus", "devices", NULL);
 889                 dbg(udev, "searching '/class/*' dir\n");
 890                 scan_dir(udev_enumerate, "class", NULL, NULL);
 891         }
 892         return 0;
 893 }
 894
 895 /**
 896  * udev_enumerate_scan_devices:
 897  * @udev_enumerate: udev enumeration context
 898  *
 899  * Returns: 0 on success, otherwise a negative error value.
 900  **/
 901 UDEV_EXPORT int udev_enumerate_scan_devices(struct udev_enumerate *udev_enumerate)
 902 {
 903         if (udev_enumerate == NULL)
 904                 return -EINVAL;
 905
 906         /* efficiently lookup tags only, we maintain a reverse-index */
 907         if (udev_list_get_entry(&udev_enumerate->tags_match_list) != NULL)
 908                 return scan_devices_tags(udev_enumerate);
 909
 910         /* walk the subtree of one parent device only */
 911         if (udev_enumerate->parent_match != NULL)
 912                 return scan_devices_children(udev_enumerate);
 913
 914         /* scan devices of all subsystems */
 915         return scan_devices_all(udev_enumerate);
 916 }
 917
 918 /**
 919  * udev_enumerate_scan_subsystems:
 920  * @udev_enumerate: udev enumeration context
 921  *
 922  * Returns: 0 on success, otherwise a negative error value.
 923  **/
 924 UDEV_EXPORT int udev_enumerate_scan_subsystems(struct udev_enumerate *udev_enumerate)
 925 {
 926         struct udev *udev = udev_enumerate_get_udev(udev_enumerate);
 927         char base[UTIL_PATH_SIZE];
 928         struct stat statbuf;
 929         const char *subsysdir;
 930
 931         if (udev_enumerate == NULL)
 932                 return -EINVAL;
 933
 934         /* all kernel modules */
 935         if (match_subsystem(udev_enumerate, "module")) {
 936                 dbg(udev, "searching '%s/modules/*' dir\n", subsysdir);
 937                 scan_dir_and_add_devices(udev_enumerate, "module", NULL, NULL);
 938         }
 939
 940         util_strscpyl(base, sizeof(base), udev_get_sys_path(udev), "/subsystem", NULL);
 941         if (stat(base, &statbuf) == 0)
 942                 subsysdir = "subsystem";
 943         else
 944                 subsysdir = "bus";
 945
 946         /* all subsystems (only buses support coldplug) */
 947         if (match_subsystem(udev_enumerate, "subsystem")) {
 948                 dbg(udev, "searching '%s/*' dir\n", subsysdir);
 949                 scan_dir_and_add_devices(udev_enumerate, subsysdir, NULL, NULL);
 950         }
 951
 952         /* all subsystem drivers */
 953         if (match_subsystem(udev_enumerate, "drivers")) {
 954                 dbg(udev, "searching '%s/*/drivers/*' dir\n", subsysdir);
 955                 scan_dir(udev_enumerate, subsysdir, "drivers", "drivers");
 956         }
 957         return 0;
 958 }