libudev/libudev-enumerate.c

   1 /*
   2  * libudev - interface to udev device information
   3  *
   4  * Copyright (C) 2008 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 <sys/stat.h>
  21
  22 #include "libudev.h"
  23 #include "libudev-private.h"
  24
  25 static int devices_sort(struct udev_enumerate *udev_enumerate);
  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 /**
  36  * udev_enumerate:
  37  *
  38  * Opaque object representing one device lookup/sort context.
  39  */
  40 struct udev_enumerate {
  41         struct udev *udev;
  42         int refcount;
  43         struct udev_list_node sysattr_match_list;
  44         struct udev_list_node sysattr_nomatch_list;
  45         struct udev_list_node subsystem_match_list;
  46         struct udev_list_node subsystem_nomatch_list;
  47         struct udev_list_node properties_match_list;
  48         struct udev_list_node devices_list;
  49         int devices_sorted;
  50 };
  51
  52 /**
  53  * udev_enumerate_new:
  54  * @udev: udev library context
  55  *
  56  * Returns: an enumeration context
  57  **/
  58 struct udev_enumerate *udev_enumerate_new(struct udev *udev)
  59 {
  60         struct udev_enumerate *udev_enumerate;
  61
  62         udev_enumerate = calloc(1, sizeof(struct udev_enumerate));
  63         if (udev_enumerate == NULL)
  64                 return NULL;
  65         udev_enumerate->refcount = 1;
  66         udev_enumerate->udev = udev;
  67         udev_list_init(&udev_enumerate->devices_list);
  68         udev_list_init(&udev_enumerate->sysattr_match_list);
  69         udev_list_init(&udev_enumerate->sysattr_nomatch_list);
  70         udev_list_init(&udev_enumerate->subsystem_match_list);
  71         udev_list_init(&udev_enumerate->subsystem_nomatch_list);
  72         udev_list_init(&udev_enumerate->properties_match_list);
  73         return udev_enumerate;
  74 }
  75
  76 /**
  77  * udev_enumerate_ref:
  78  * @udev_enumerate: context
  79  *
  80  * Take a reference of a enumeration context.
  81  *
  82  * Returns: the passed enumeration context
  83  **/
  84 struct udev_enumerate *udev_enumerate_ref(struct udev_enumerate *udev_enumerate)
  85 {
  86         if (udev_enumerate == NULL)
  87                 return NULL;
  88         udev_enumerate->refcount++;
  89         return udev_enumerate;
  90 }
  91
  92 /**
  93  * udev_enumerate_unref:
  94  * @udev_enumerate: context
  95  *
  96  * Drop a reference of an enumeration context. If the refcount reaches zero,
  97  * all resources of the enumeration context will be released.
  98  **/
  99 void udev_enumerate_unref(struct udev_enumerate *udev_enumerate)
 100 {
 101         if (udev_enumerate == NULL)
 102                 return;
 103         udev_enumerate->refcount--;
 104         if (udev_enumerate->refcount > 0)
 105                 return;
 106         udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->devices_list);
 107         udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->sysattr_match_list);
 108         udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->sysattr_nomatch_list);
 109         udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->subsystem_match_list);
 110         udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->subsystem_nomatch_list);
 111         udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->properties_match_list);
 112         free(udev_enumerate);
 113 }
 114
 115 /**
 116  * udev_enumerate_get_udev:
 117  * @udev_enumerate: context
 118  *
 119  * Returns: the udev library context.
 120  */
 121 struct udev *udev_enumerate_get_udev(struct udev_enumerate *udev_enumerate)
 122 {
 123         if (udev_enumerate == NULL)
 124                 return NULL;
 125         return udev_enumerate->udev;
 126 }
 127
 128 /**
 129  * udev_enumerate_get_list_entry:
 130  * @udev_enumerate: context
 131  *
 132  * Returns: the first entry of the sorted list of device paths.
 133  */
 134 struct udev_list_entry *udev_enumerate_get_list_entry(struct udev_enumerate *udev_enumerate)
 135 {
 136         if (udev_enumerate == NULL)
 137                 return NULL;
 138         if (!udev_enumerate->devices_sorted)
 139                 devices_sort(udev_enumerate);
 140         return udev_list_get_entry(&udev_enumerate->devices_list);
 141 }
 142
 143 /**
 144  * udev_enumerate_add_match_subsystem:
 145  * @udev_enumerate: context
 146  * @subsystem: filter for a subsystem of the device to include in the list
 147  *
 148  * Returns: 0 on success, otherwise a negative error value.
 149  */
 150 int udev_enumerate_add_match_subsystem(struct udev_enumerate *udev_enumerate, const char *subsystem)
 151 {
 152         if (udev_enumerate == NULL)
 153                 return -EINVAL;
 154         if (subsystem == NULL)
 155                 return 0;
 156         if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
 157                                 &udev_enumerate->subsystem_match_list, subsystem, NULL, 1, 0) == NULL)
 158                 return -ENOMEM;
 159         return 0;
 160 }
 161
 162 /**
 163  * udev_enumerate_add_nomatch_subsystem:
 164  * @udev_enumerate: context
 165  * @subsystem: filter for a subsystem of the device to exclude from the list
 166  *
 167  * Returns: 0 on success, otherwise a negative error value.
 168  */
 169 int udev_enumerate_add_nomatch_subsystem(struct udev_enumerate *udev_enumerate, const char *subsystem)
 170 {
 171         if (udev_enumerate == NULL)
 172                 return -EINVAL;
 173         if (subsystem == NULL)
 174                 return 0;
 175         if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
 176                                 &udev_enumerate->subsystem_nomatch_list, subsystem, NULL, 1, 0) == NULL)
 177                 return -ENOMEM;
 178         return 0;
 179 }
 180
 181 /**
 182  * udev_enumerate_add_match_sysattr:
 183  * @udev_enumerate: context
 184  * @sysattr: filter for a sys attribute at the device to include in the list
 185  * @value: optional value of the sys attribute
 186  *
 187  * Returns: 0 on success, otherwise a negative error value.
 188  */
 189 int udev_enumerate_add_match_sysattr(struct udev_enumerate *udev_enumerate, const char *sysattr, const char *value)
 190 {
 191         if (udev_enumerate == NULL)
 192                 return -EINVAL;
 193         if (sysattr == NULL)
 194                 return 0;
 195         if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
 196                            &udev_enumerate->sysattr_match_list, sysattr, value, 0, 0) == NULL)
 197                 return -ENOMEM;
 198         return 0;
 199 }
 200
 201 /**
 202  * udev_enumerate_add_nomatch_sysattr:
 203  * @udev_enumerate: context
 204  * @sysattr: filter for a sys attribute at the device to exclude from the list
 205  * @value: optional value of the sys attribute
 206  *
 207  * Returns: 0 on success, otherwise a negative error value.
 208  */
 209 int udev_enumerate_add_nomatch_sysattr(struct udev_enumerate *udev_enumerate, const char *sysattr, const char *value)
 210 {
 211         if (udev_enumerate == NULL)
 212                 return -EINVAL;
 213         if (sysattr == NULL)
 214                 return 0;
 215         if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
 216                            &udev_enumerate->sysattr_nomatch_list, sysattr, value, 0, 0) == NULL)
 217                 return -ENOMEM;
 218         return 0;
 219 }
 220
 221 static int match_sysattr_value(struct udev *udev, const char *syspath, const char *sysattr, const char *match_val)
 222 {
 223         struct udev_device *device;
 224         const char *val = NULL;
 225         int match = 0;
 226
 227         device = udev_device_new_from_syspath(udev, syspath);
 228         if (device == NULL)
 229                 return -EINVAL;
 230         val = udev_device_get_sysattr_value(device, sysattr);
 231         if (val == NULL)
 232                 goto exit;
 233         if (match_val == NULL) {
 234                 match = 1;
 235                 goto exit;
 236         }
 237         if (fnmatch(match_val, val, 0) == 0) {
 238                 match = 1;
 239                 goto exit;
 240         }
 241 exit:
 242         udev_device_unref(device);
 243         return match;
 244 }
 245
 246 /**
 247  * udev_enumerate_add_match_property:
 248  * @udev_enumerate: context
 249  * @property: filter for a property of the device to include in the list
 250  * @value: value of the property
 251  *
 252  * Returns: 0 on success, otherwise a negative error value.
 253  */
 254 int udev_enumerate_add_match_property(struct udev_enumerate *udev_enumerate, const char *property, const char *value)
 255 {
 256         if (udev_enumerate == NULL)
 257                 return -EINVAL;
 258         if (property == NULL)
 259                 return 0;
 260         if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
 261                                 &udev_enumerate->properties_match_list, property, value, 0, 0) == NULL)
 262                 return -ENOMEM;
 263         return 0;
 264 }
 265
 266 static int match_sysattr(struct udev_enumerate *udev_enumerate, const char *syspath)
 267 {
 268         struct udev *udev = udev_enumerate_get_udev(udev_enumerate);
 269         struct udev_list_entry *list_entry;
 270
 271         /* skip list */
 272         udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->sysattr_nomatch_list)) {
 273                 if (match_sysattr_value(udev, syspath,
 274                                      udev_list_entry_get_name(list_entry),
 275                                      udev_list_entry_get_value(list_entry)))
 276                         return 0;
 277         }
 278         /* include list */
 279         if (udev_list_get_entry(&udev_enumerate->sysattr_match_list) != NULL) {
 280                 udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->sysattr_match_list)) {
 281                         /* anything that does not match, will make it FALSE */
 282                         if (!match_sysattr_value(udev, syspath,
 283                                               udev_list_entry_get_name(list_entry),
 284                                               udev_list_entry_get_value(list_entry)))
 285                                 return 0;
 286                 }
 287                 return 1;
 288         }
 289         return 1;
 290 }
 291
 292 static int match_property(struct udev_enumerate *udev_enumerate, const char *syspath)
 293 {
 294         struct udev_device *dev;
 295         struct udev_list_entry *list_entry;
 296         int match = 0;
 297
 298         /* no match always matches */
 299         if (udev_list_get_entry(&udev_enumerate->properties_match_list) == NULL)
 300                 return 1;
 301
 302         /* no device does not match */
 303         dev = udev_device_new_from_syspath(udev_enumerate->udev, syspath);
 304         if (dev == NULL)
 305                 return 0;
 306
 307         /* loop over matches */
 308         udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->properties_match_list)) {
 309                 const char *match_key = udev_list_entry_get_name(list_entry);
 310                 const char *match_value = udev_list_entry_get_value(list_entry);
 311                 struct udev_list_entry *property_entry;
 312
 313                 /* loop over device properties */
 314                 udev_list_entry_foreach(property_entry, udev_device_get_properties_list_entry(dev)) {
 315                         const char *dev_key = udev_list_entry_get_name(property_entry);
 316                         const char *dev_value = udev_list_entry_get_value(property_entry);
 317
 318                         if (fnmatch(match_key, dev_key, 0) != 0)
 319                                 continue;
 320                         if (match_value == NULL && dev_value == NULL) {
 321                                 match = 1;
 322                                 goto out;
 323                         }
 324                         if (match_value == NULL || dev_value == NULL)
 325                                 continue;
 326                         if (fnmatch(match_value, dev_value, 0) == 0) {
 327                                 match = 1;
 328                                 goto out;
 329                         }
 330                 }
 331         }
 332 out:
 333         udev_device_unref(dev);
 334         return match;
 335 }
 336
 337 static int scan_dir_and_add_devices(struct udev_enumerate *udev_enumerate,
 338                                     const char *basedir, const char *subdir1, const char *subdir2)
 339 {
 340         struct udev *udev = udev_enumerate_get_udev(udev_enumerate);
 341         char path[UTIL_PATH_SIZE];
 342         size_t l;
 343         char *s;
 344         DIR *dir;
 345         struct dirent *dent;
 346
 347         s = path;
 348         l = util_strpcpyl(&s, sizeof(path), udev_get_sys_path(udev), "/", basedir, NULL);
 349         if (subdir1 != NULL)
 350                 l = util_strpcpyl(&s, l, "/", subdir1, NULL);
 351         if (subdir2 != NULL)
 352                 l = util_strpcpyl(&s, l, "/", subdir2, NULL);
 353         dir = opendir(path);
 354         if (dir == NULL)
 355                 return -1;
 356         for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
 357                 char syspath[UTIL_PATH_SIZE];
 358                 char filename[UTIL_PATH_SIZE];
 359                 struct stat statbuf;
 360
 361                 if (dent->d_name[0] == '.')
 362                         continue;
 363                 util_strscpyl(syspath, sizeof(syspath), path, "/", dent->d_name, NULL);
 364                 if (lstat(syspath, &statbuf) != 0)
 365                         continue;
 366                 if (S_ISREG(statbuf.st_mode))
 367                         continue;
 368                 if (S_ISLNK(statbuf.st_mode))
 369                         util_resolve_sys_link(udev, syspath, sizeof(syspath));
 370
 371                 util_strscpyl(filename, sizeof(filename), syspath, "/uevent", NULL);
 372                 if (stat(filename, &statbuf) != 0)
 373                         continue;
 374                 if (!match_sysattr(udev_enumerate, syspath))
 375                         continue;
 376                 if (!match_property(udev_enumerate, syspath))
 377                         continue;
 378                 udev_list_entry_add(udev, &udev_enumerate->devices_list, syspath, NULL, 1, 1);
 379         }
 380         closedir(dir);
 381         return 0;
 382 }
 383
 384 static int match_subsystem(struct udev_enumerate *udev_enumerate, const char *subsystem)
 385 {
 386         struct udev_list_entry *list_entry;
 387
 388         udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->subsystem_nomatch_list)) {
 389                 if (fnmatch(udev_list_entry_get_name(list_entry), subsystem, 0) == 0)
 390                         return 0;
 391         }
 392         if (udev_list_get_entry(&udev_enumerate->subsystem_match_list) != NULL) {
 393                 udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->subsystem_match_list)) {
 394                         if (fnmatch(udev_list_entry_get_name(list_entry), subsystem, 0) == 0)
 395                                 return 1;
 396                 }
 397                 return 0;
 398         }
 399         return 1;
 400 }
 401
 402 static int scan_dir(struct udev_enumerate *udev_enumerate, const char *basedir, const char *subdir, const char *subsystem)
 403 {
 404         struct udev *udev = udev_enumerate_get_udev(udev_enumerate);
 405
 406         char path[UTIL_PATH_SIZE];
 407         DIR *dir;
 408         struct dirent *dent;
 409
 410         util_strscpyl(path, sizeof(path), udev_get_sys_path(udev), "/", basedir, NULL);
 411         dir = opendir(path);
 412         if (dir == NULL)
 413                 return -1;
 414         for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
 415                 if (dent->d_name[0] == '.')
 416                         continue;
 417                 if (!match_subsystem(udev_enumerate, subsystem != NULL ? subsystem : dent->d_name))
 418                         continue;
 419                 scan_dir_and_add_devices(udev_enumerate, basedir, dent->d_name, subdir);
 420         }
 421         closedir(dir);
 422         return 0;
 423 }
 424
 425 static int devices_delay(struct udev *udev, const char *syspath)
 426 {
 427         static const char *delay_device_list[] = {
 428                 "/block/md",
 429                 "/block/dm-",
 430                 NULL
 431         };
 432         size_t len;
 433         int i;
 434
 435         len = strlen(udev_get_sys_path(udev));
 436         for (i = 0; delay_device_list[i] != NULL; i++) {
 437                 if (strstr(&syspath[len], delay_device_list[i]) != NULL) {
 438                         dbg(udev, "delaying: %s\n", syspath);
 439                         return 1;
 440                 }
 441         }
 442         return 0;
 443 }
 444
 445 /* sort delayed devices to the end of the list */
 446 static int devices_sort(struct udev_enumerate *udev_enumerate)
 447 {
 448         struct udev_list_entry *entry_loop;
 449         struct udev_list_entry *entry_tmp;
 450         struct udev_list_node devices_list;
 451
 452         udev_list_init(&devices_list);
 453         /* move delayed to delay list */
 454         udev_list_entry_foreach_safe(entry_loop, entry_tmp, udev_list_get_entry(&udev_enumerate->devices_list)) {
 455                 if (devices_delay(udev_enumerate->udev, udev_list_entry_get_name(entry_loop))) {
 456                         udev_list_entry_remove(entry_loop);
 457                         udev_list_entry_append(entry_loop, &devices_list);
 458                 }
 459         }
 460         /* move delayed back to end of list */
 461         udev_list_entry_foreach_safe(entry_loop, entry_tmp, udev_list_get_entry(&devices_list)) {
 462                 udev_list_entry_remove(entry_loop);
 463                 udev_list_entry_append(entry_loop, &udev_enumerate->devices_list);
 464         }
 465         udev_enumerate->devices_sorted = 1;
 466         return 0;
 467 }
 468
 469 /**
 470  * udev_enumerate_add_syspath:
 471  * @udev_enumerate: context
 472  * @syspath: path of a device
 473  *
 474  * Add a device to the list of devices, to retrieve it back sorted in dependency order.
 475  *
 476  * Returns: 0 on success, otherwise a negative error value.
 477  */
 478 int udev_enumerate_add_syspath(struct udev_enumerate *udev_enumerate, const char *syspath)
 479 {
 480         struct udev *udev = udev_enumerate_get_udev(udev_enumerate);
 481         struct udev_device *udev_device;
 482
 483         if (udev_enumerate == NULL)
 484                 return -EINVAL;
 485         if (syspath == NULL)
 486                 return 0;
 487         /* resolve to real syspath */
 488         udev_device = udev_device_new_from_syspath(udev_enumerate->udev, syspath);
 489         if (udev_device == NULL)
 490                 return -EINVAL;
 491         udev_list_entry_add(udev, &udev_enumerate->devices_list,
 492                             udev_device_get_syspath(udev_device), NULL, 1, 1);
 493         udev_device_unref(udev_device);
 494         return 0;
 495 }
 496
 497 /**
 498  * udev_enumerate_scan_devices:
 499  * @udev_enumerate: udev enumeration context
 500  *
 501  * Returns: 0 on success, otherwise a negative error value.
 502  **/
 503 int udev_enumerate_scan_devices(struct udev_enumerate *udev_enumerate)
 504 {
 505         struct udev *udev = udev_enumerate_get_udev(udev_enumerate);
 506         char base[UTIL_PATH_SIZE];
 507         struct stat statbuf;
 508
 509         if (udev_enumerate == NULL)
 510                 return -EINVAL;
 511         util_strscpyl(base, sizeof(base), udev_get_sys_path(udev), "/subsystem", NULL);
 512         if (stat(base, &statbuf) == 0) {
 513                 /* we have /subsystem/, forget all the old stuff */
 514                 dbg(udev, "searching '/subsystem/*/devices/*' dir\n");
 515                 scan_dir(udev_enumerate, "subsystem", "devices", NULL);
 516         } else {
 517                 dbg(udev, "searching '/bus/*/devices/*' dir\n");
 518                 scan_dir(udev_enumerate, "bus", "devices", NULL);
 519                 dbg(udev, "searching '/class/*' dir\n");
 520                 scan_dir(udev_enumerate, "class", NULL, NULL);
 521                 /* if block isn't a class, scan /block/ */
 522                 util_strscpyl(base, sizeof(base), udev_get_sys_path(udev), "/class/block", NULL);
 523                 if (stat(base, &statbuf) != 0) {
 524                         if (match_subsystem(udev_enumerate, "block")) {
 525                                 dbg(udev, "searching '/block/*' dir\n");
 526                                 /* scan disks */
 527                                 scan_dir_and_add_devices(udev_enumerate, "block", NULL, NULL);
 528                                 /* scan partitions */
 529                                 dbg(udev, "searching '/block/*/*' dir\n");
 530                                 scan_dir(udev_enumerate, "block", NULL, "block");
 531                         }
 532                 }
 533         }
 534         return 0;
 535 }
 536
 537 /**
 538  * udev_enumerate_scan_subsystems:
 539  * @udev_enumerate: udev enumeration context
 540  *
 541  * Returns: 0 on success, otherwise a negative error value.
 542  **/
 543 int udev_enumerate_scan_subsystems(struct udev_enumerate *udev_enumerate)
 544 {
 545         struct udev *udev = udev_enumerate_get_udev(udev_enumerate);
 546         char base[UTIL_PATH_SIZE];
 547         struct stat statbuf;
 548         const char *subsysdir;
 549
 550         if (udev_enumerate == NULL)
 551                 return -EINVAL;
 552         util_strscpyl(base, sizeof(base), udev_get_sys_path(udev), "/subsystem", NULL);
 553         if (stat(base, &statbuf) == 0)
 554                 subsysdir = "subsystem";
 555         else
 556                 subsysdir = "bus";
 557         if (match_subsystem(udev_enumerate, "subsystem")) {
 558                 dbg(udev, "searching '%s/*' dir\n", subsysdir);
 559                 scan_dir_and_add_devices(udev_enumerate, subsysdir, NULL, NULL);
 560         }
 561         if (match_subsystem(udev_enumerate, "drivers")) {
 562                 dbg(udev, "searching '%s/*/drivers/*' dir\n", subsysdir);
 563                 scan_dir(udev_enumerate, subsysdir, "drivers", "drivers");
 564         }
 565         return 0;
 566 }