src/libudev/libudev-device.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 <stdbool.h>
  17 #include <errno.h>
  18 #include <string.h>
  19 #include <dirent.h>
  20 #include <fcntl.h>
  21 #include <ctype.h>
  22 #include <net/if.h>
  23 #include <sys/stat.h>
  24 #include <sys/ioctl.h>
  25 #include <sys/socket.h>
  26 #include <linux/sockios.h>
  27
  28 #include "libudev.h"
  29 #include "libudev-private.h"
  30
  31 /**
  32  * SECTION:libudev-device
  33  * @short_description: kernel sys devices
  34  *
  35  * Representation of kernel sys devices. Devices are uniquely identified
  36  * by their syspath, every device has exactly one path in the kernel sys
  37  * filesystem. Devices usually belong to a kernel subsystem, and and have
  38  * a unique name inside that subsystem.
  39  */
  40
  41 /**
  42  * udev_device:
  43  *
  44  * Opaque object representing one kernel sys device.
  45  */
  46 struct udev_device {
  47         struct udev *udev;
  48         struct udev_device *parent_device;
  49         char *syspath;
  50         const char *devpath;
  51         char *sysname;
  52         const char *sysnum;
  53         char *devnode;
  54         mode_t devnode_mode;
  55         char *subsystem;
  56         char *devtype;
  57         char *driver;
  58         char *action;
  59         char *devpath_old;
  60         char *id_filename;
  61         char **envp;
  62         char *monitor_buf;
  63         size_t monitor_buf_len;
  64         struct udev_list devlinks_list;
  65         struct udev_list properties_list;
  66         struct udev_list sysattr_value_list;
  67         struct udev_list sysattr_list;
  68         struct udev_list tags_list;
  69         unsigned long long int seqnum;
  70         unsigned long long int usec_initialized;
  71         int devlink_priority;
  72         int refcount;
  73         dev_t devnum;
  74         int ifindex;
  75         int watch_handle;
  76         int maj, min;
  77         bool parent_set;
  78         bool subsystem_set;
  79         bool devtype_set;
  80         bool devlinks_uptodate;
  81         bool envp_uptodate;
  82         bool tags_uptodate;
  83         bool driver_set;
  84         bool info_loaded;
  85         bool db_loaded;
  86         bool uevent_loaded;
  87         bool is_initialized;
  88         bool sysattr_list_read;
  89         bool db_persist;
  90 };
  91
  92 /**
  93  * udev_device_get_seqnum:
  94  * @udev_device: udev device
  95  *
  96  * This is only valid if the device was received through a monitor. Devices read from
  97  * sys do not have a sequence number.
  98  *
  99  * Returns: the kernel event sequence number, or 0 if there is no sequence number available.
 100  **/
 101 _public_ unsigned long long int udev_device_get_seqnum(struct udev_device *udev_device)
 102 {
 103         if (udev_device == NULL)
 104                 return 0;
 105         return udev_device->seqnum;
 106 }
 107
 108 static int udev_device_set_seqnum(struct udev_device *udev_device, unsigned long long int seqnum)
 109 {
 110         char num[32];
 111
 112         udev_device->seqnum = seqnum;
 113         snprintf(num, sizeof(num), "%llu", seqnum);
 114         udev_device_add_property(udev_device, "SEQNUM", num);
 115         return 0;
 116 }
 117
 118 int udev_device_get_ifindex(struct udev_device *udev_device)
 119 {
 120         if (!udev_device->info_loaded)
 121                 udev_device_read_uevent_file(udev_device);
 122         return udev_device->ifindex;
 123 }
 124
 125 static int udev_device_set_ifindex(struct udev_device *udev_device, int ifindex)
 126 {
 127         char num[32];
 128
 129         udev_device->ifindex = ifindex;
 130         snprintf(num, sizeof(num), "%u", ifindex);
 131         udev_device_add_property(udev_device, "IFINDEX", num);
 132         return 0;
 133 }
 134
 135 /**
 136  * udev_device_get_devnum:
 137  * @udev_device: udev device
 138  *
 139  * Returns: the device major/minor number.
 140  **/
 141 _public_ dev_t udev_device_get_devnum(struct udev_device *udev_device)
 142 {
 143         if (udev_device == NULL)
 144                 return makedev(0, 0);
 145         if (!udev_device->info_loaded)
 146                 udev_device_read_uevent_file(udev_device);
 147         return udev_device->devnum;
 148 }
 149
 150 static int udev_device_set_devnum(struct udev_device *udev_device, dev_t devnum)
 151 {
 152         char num[32];
 153
 154         udev_device->devnum = devnum;
 155
 156         snprintf(num, sizeof(num), "%u", major(devnum));
 157         udev_device_add_property(udev_device, "MAJOR", num);
 158         snprintf(num, sizeof(num), "%u", minor(devnum));
 159         udev_device_add_property(udev_device, "MINOR", num);
 160         return 0;
 161 }
 162
 163 const char *udev_device_get_devpath_old(struct udev_device *udev_device)
 164 {
 165         return udev_device->devpath_old;
 166 }
 167
 168 static int udev_device_set_devpath_old(struct udev_device *udev_device, const char *devpath_old)
 169 {
 170         const char *pos;
 171
 172         free(udev_device->devpath_old);
 173         udev_device->devpath_old = strdup(devpath_old);
 174         if (udev_device->devpath_old == NULL)
 175                 return -ENOMEM;
 176         udev_device_add_property(udev_device, "DEVPATH_OLD", udev_device->devpath_old);
 177
 178         pos = strrchr(udev_device->devpath_old, '/');
 179         if (pos == NULL)
 180                 return -EINVAL;
 181         return 0;
 182 }
 183
 184 /**
 185  * udev_device_get_driver:
 186  * @udev_device: udev device
 187  *
 188  * Returns: the driver string, or #NULL if there is no driver attached.
 189  **/
 190 _public_ const char *udev_device_get_driver(struct udev_device *udev_device)
 191 {
 192         char driver[UTIL_NAME_SIZE];
 193
 194         if (udev_device == NULL)
 195                 return NULL;
 196         if (!udev_device->driver_set) {
 197                 udev_device->driver_set = true;
 198                 if (util_get_sys_core_link_value(udev_device->udev, "driver", udev_device->syspath, driver, sizeof(driver)) > 0)
 199                         udev_device->driver = strdup(driver);
 200         }
 201         return udev_device->driver;
 202 }
 203
 204 static int udev_device_set_driver(struct udev_device *udev_device, const char *driver)
 205 {
 206         free(udev_device->driver);
 207         udev_device->driver = strdup(driver);
 208         if (udev_device->driver == NULL)
 209                 return -ENOMEM;
 210         udev_device->driver_set = true;
 211         udev_device_add_property(udev_device, "DRIVER", udev_device->driver);
 212         return 0;
 213 }
 214
 215 /**
 216  * udev_device_get_devtype:
 217  * @udev_device: udev device
 218  *
 219  * Retrieve the devtype string of the udev device.
 220  *
 221  * Returns: the devtype name of the udev device, or #NULL if it can not be determined
 222  **/
 223 _public_ const char *udev_device_get_devtype(struct udev_device *udev_device)
 224 {
 225         if (udev_device == NULL)
 226                 return NULL;
 227         if (!udev_device->devtype_set) {
 228                 udev_device->devtype_set = true;
 229                 udev_device_read_uevent_file(udev_device);
 230         }
 231         return udev_device->devtype;
 232 }
 233
 234 static int udev_device_set_devtype(struct udev_device *udev_device, const char *devtype)
 235 {
 236         free(udev_device->devtype);
 237         udev_device->devtype = strdup(devtype);
 238         if (udev_device->devtype == NULL)
 239                 return -ENOMEM;
 240         udev_device->devtype_set = true;
 241         udev_device_add_property(udev_device, "DEVTYPE", udev_device->devtype);
 242         return 0;
 243 }
 244
 245 static int udev_device_set_subsystem(struct udev_device *udev_device, const char *subsystem)
 246 {
 247         free(udev_device->subsystem);
 248         udev_device->subsystem = strdup(subsystem);
 249         if (udev_device->subsystem == NULL)
 250                 return -ENOMEM;
 251         udev_device->subsystem_set = true;
 252         udev_device_add_property(udev_device, "SUBSYSTEM", udev_device->subsystem);
 253         return 0;
 254 }
 255
 256 /**
 257  * udev_device_get_subsystem:
 258  * @udev_device: udev device
 259  *
 260  * Retrieve the subsystem string of the udev device. The string does not
 261  * contain any "/".
 262  *
 263  * Returns: the subsystem name of the udev device, or #NULL if it can not be determined
 264  **/
 265 _public_ const char *udev_device_get_subsystem(struct udev_device *udev_device)
 266 {
 267         char subsystem[UTIL_NAME_SIZE];
 268
 269         if (udev_device == NULL)
 270                 return NULL;
 271         if (!udev_device->subsystem_set) {
 272                 udev_device->subsystem_set = true;
 273                 /* read "subsystem" link */
 274                 if (util_get_sys_core_link_value(udev_device->udev, "subsystem", udev_device->syspath, subsystem, sizeof(subsystem)) > 0) {
 275                         udev_device_set_subsystem(udev_device, subsystem);
 276                         return udev_device->subsystem;
 277                 }
 278                 /* implicit names */
 279                 if (strncmp(udev_device->devpath, "/module/", 8) == 0) {
 280                         udev_device_set_subsystem(udev_device, "module");
 281                         return udev_device->subsystem;
 282                 }
 283                 if (strstr(udev_device->devpath, "/drivers/") != NULL) {
 284                         udev_device_set_subsystem(udev_device, "drivers");
 285                         return udev_device->subsystem;
 286                 }
 287                 if (strncmp(udev_device->devpath, "/subsystem/", 11) == 0 ||
 288                     strncmp(udev_device->devpath, "/class/", 7) == 0 ||
 289                     strncmp(udev_device->devpath, "/bus/", 5) == 0) {
 290                         udev_device_set_subsystem(udev_device, "subsystem");
 291                         return udev_device->subsystem;
 292                 }
 293         }
 294         return udev_device->subsystem;
 295 }
 296
 297 mode_t udev_device_get_devnode_mode(struct udev_device *udev_device)
 298 {
 299         if (!udev_device->info_loaded)
 300                 udev_device_read_uevent_file(udev_device);
 301         return udev_device->devnode_mode;
 302 }
 303
 304 static int udev_device_set_devnode_mode(struct udev_device *udev_device, mode_t mode)
 305 {
 306         char num[32];
 307
 308         udev_device->devnode_mode = mode;
 309         snprintf(num, sizeof(num), "%#o", mode);
 310         udev_device_add_property(udev_device, "DEVMODE", num);
 311         return 0;
 312 }
 313
 314 struct udev_list_entry *udev_device_add_property(struct udev_device *udev_device, const char *key, const char *value)
 315 {
 316         udev_device->envp_uptodate = false;
 317         if (value == NULL) {
 318                 struct udev_list_entry *list_entry;
 319
 320                 list_entry = udev_device_get_properties_list_entry(udev_device);
 321                 list_entry = udev_list_entry_get_by_name(list_entry, key);
 322                 if (list_entry != NULL)
 323                         udev_list_entry_delete(list_entry);
 324                 return NULL;
 325         }
 326         return udev_list_entry_add(&udev_device->properties_list, key, value);
 327 }
 328
 329 static struct udev_list_entry *udev_device_add_property_from_string(struct udev_device *udev_device, const char *property)
 330 {
 331         char name[UTIL_LINE_SIZE];
 332         char *val;
 333
 334         util_strscpy(name, sizeof(name), property);
 335         val = strchr(name, '=');
 336         if (val == NULL)
 337                 return NULL;
 338         val[0] = '\0';
 339         val = &val[1];
 340         if (val[0] == '\0')
 341                 val = NULL;
 342         return udev_device_add_property(udev_device, name, val);
 343 }
 344
 345 /*
 346  * parse property string, and if needed, update internal values accordingly
 347  *
 348  * udev_device_add_property_from_string_parse_finish() needs to be
 349  * called after adding properties, and its return value checked
 350  *
 351  * udev_device_set_info_loaded() needs to be set, to avoid trying
 352  * to use a device without a DEVPATH set
 353  */
 354 void udev_device_add_property_from_string_parse(struct udev_device *udev_device, const char *property)
 355 {
 356         if (strncmp(property, "DEVPATH=", 8) == 0) {
 357                 char path[UTIL_PATH_SIZE];
 358
 359                 util_strscpyl(path, sizeof(path), TEST_PREFIX "/sys", &property[8], NULL);
 360                 udev_device_set_syspath(udev_device, path);
 361         } else if (strncmp(property, "SUBSYSTEM=", 10) == 0) {
 362                 udev_device_set_subsystem(udev_device, &property[10]);
 363         } else if (strncmp(property, "DEVTYPE=", 8) == 0) {
 364                 udev_device_set_devtype(udev_device, &property[8]);
 365         } else if (strncmp(property, "DEVNAME=", 8) == 0) {
 366                 udev_device_set_devnode(udev_device, &property[8]);
 367         } else if (strncmp(property, "DEVLINKS=", 9) == 0) {
 368                 char devlinks[UTIL_PATH_SIZE];
 369                 char *slink;
 370                 char *next;
 371
 372                 util_strscpy(devlinks, sizeof(devlinks), &property[9]);
 373                 slink = devlinks;
 374                 next = strchr(slink, ' ');
 375                 while (next != NULL) {
 376                         next[0] = '\0';
 377                         udev_device_add_devlink(udev_device, slink, 0);
 378                         slink = &next[1];
 379                         next = strchr(slink, ' ');
 380                 }
 381                 if (slink[0] != '\0')
 382                         udev_device_add_devlink(udev_device, slink, 0);
 383         } else if (strncmp(property, "TAGS=", 5) == 0) {
 384                 char tags[UTIL_PATH_SIZE];
 385                 char *next;
 386
 387                 util_strscpy(tags, sizeof(tags), &property[5]);
 388                 next = strchr(tags, ':');
 389                 if (next != NULL) {
 390                         next++;
 391                         while (next[0] != '\0') {
 392                                 char *tag;
 393
 394                                 tag = next;
 395                                 next = strchr(tag, ':');
 396                                 if (next == NULL)
 397                                         break;
 398                                 next[0] = '\0';
 399                                 next++;
 400                                 udev_device_add_tag(udev_device, tag);
 401                         }
 402                 }
 403         } else if (strncmp(property, "USEC_INITIALIZED=", 19) == 0) {
 404                 udev_device_set_usec_initialized(udev_device, strtoull(&property[19], NULL, 10));
 405         } else if (strncmp(property, "DRIVER=", 7) == 0) {
 406                 udev_device_set_driver(udev_device, &property[7]);
 407         } else if (strncmp(property, "ACTION=", 7) == 0) {
 408                 udev_device_set_action(udev_device, &property[7]);
 409         } else if (strncmp(property, "MAJOR=", 6) == 0) {
 410                 udev_device->maj = strtoull(&property[6], NULL, 10);
 411         } else if (strncmp(property, "MINOR=", 6) == 0) {
 412                 udev_device->min = strtoull(&property[6], NULL, 10);
 413         } else if (strncmp(property, "DEVPATH_OLD=", 12) == 0) {
 414                 udev_device_set_devpath_old(udev_device, &property[12]);
 415         } else if (strncmp(property, "SEQNUM=", 7) == 0) {
 416                 udev_device_set_seqnum(udev_device, strtoull(&property[7], NULL, 10));
 417         } else if (strncmp(property, "IFINDEX=", 8) == 0) {
 418                 udev_device_set_ifindex(udev_device, strtoull(&property[8], NULL, 10));
 419         } else if (strncmp(property, "DEVMODE=", 8) == 0) {
 420                 udev_device_set_devnode_mode(udev_device, strtoul(&property[8], NULL, 8));
 421         } else {
 422                 udev_device_add_property_from_string(udev_device, property);
 423         }
 424 }
 425
 426 int udev_device_add_property_from_string_parse_finish(struct udev_device *udev_device)
 427 {
 428         if (udev_device->maj > 0)
 429                 udev_device_set_devnum(udev_device, makedev(udev_device->maj, udev_device->min));
 430         udev_device->maj = 0;
 431         udev_device->min = 0;
 432
 433         if (udev_device->devpath == NULL || udev_device->subsystem == NULL)
 434                 return -EINVAL;
 435         return 0;
 436 }
 437
 438 /**
 439  * udev_device_get_property_value:
 440  * @udev_device: udev device
 441  * @key: property name
 442  *
 443  * Returns: the value of a device property, or #NULL if there is no such property.
 444  **/
 445 _public_ const char *udev_device_get_property_value(struct udev_device *udev_device, const char *key)
 446 {
 447         struct udev_list_entry *list_entry;
 448
 449         if (udev_device == NULL)
 450                 return NULL;
 451         if (key == NULL)
 452                 return NULL;
 453
 454         list_entry = udev_device_get_properties_list_entry(udev_device);
 455         list_entry = udev_list_entry_get_by_name(list_entry, key);
 456         return udev_list_entry_get_value(list_entry);
 457 }
 458
 459 int udev_device_read_db(struct udev_device *udev_device, const char *dbfile)
 460 {
 461         char filename[UTIL_PATH_SIZE];
 462         char line[UTIL_LINE_SIZE];
 463         FILE *f;
 464
 465         /* providing a database file will always force-load it */
 466         if (dbfile == NULL) {
 467                 const char *id;
 468
 469                 if (udev_device->db_loaded)
 470                         return 0;
 471                 udev_device->db_loaded = true;
 472
 473                 id = udev_device_get_id_filename(udev_device);
 474                 if (id == NULL)
 475                         return -1;
 476                 util_strscpyl(filename, sizeof(filename), TEST_PREFIX "/run/udev/data/", id, NULL);
 477                 dbfile = filename;
 478         }
 479
 480         f = fopen(dbfile, "re");
 481         if (f == NULL) {
 482                 dbg(udev_device->udev, "no db file to read %s: %m\n", dbfile);
 483                 return -1;
 484         }
 485         udev_device->is_initialized = true;
 486
 487         while (fgets(line, sizeof(line), f)) {
 488                 ssize_t len;
 489                 const char *val;
 490                 struct udev_list_entry *entry;
 491
 492                 len = strlen(line);
 493                 if (len < 4)
 494                         break;
 495                 line[len-1] = '\0';
 496                 val = &line[2];
 497                 switch(line[0]) {
 498                 case 'S':
 499                         util_strscpyl(filename, sizeof(filename), TEST_PREFIX "/dev/", val, NULL);
 500                         udev_device_add_devlink(udev_device, filename, 0);
 501                         break;
 502                 case 'L':
 503                         udev_device_set_devlink_priority(udev_device, atoi(val));
 504                         break;
 505                 case 'E':
 506                         entry = udev_device_add_property_from_string(udev_device, val);
 507                         udev_list_entry_set_num(entry, true);
 508                         break;
 509                 case 'G':
 510                         udev_device_add_tag(udev_device, val);
 511                         break;
 512                 case 'W':
 513                         udev_device_set_watch_handle(udev_device, atoi(val));
 514                         break;
 515                 case 'I':
 516                         udev_device_set_usec_initialized(udev_device, strtoull(val, NULL, 10));
 517                         break;
 518                 }
 519         }
 520         fclose(f);
 521
 522         dbg(udev_device->udev, "device %p filled with db file data\n", udev_device);
 523         return 0;
 524 }
 525
 526 int udev_device_read_uevent_file(struct udev_device *udev_device)
 527 {
 528         char filename[UTIL_PATH_SIZE];
 529         FILE *f;
 530         char line[UTIL_LINE_SIZE];
 531         int maj = 0;
 532         int min = 0;
 533
 534         if (udev_device->uevent_loaded)
 535                 return 0;
 536
 537         util_strscpyl(filename, sizeof(filename), udev_device->syspath, "/uevent", NULL);
 538         f = fopen(filename, "re");
 539         if (f == NULL)
 540                 return -1;
 541         udev_device->uevent_loaded = true;
 542
 543         while (fgets(line, sizeof(line), f)) {
 544                 char *pos;
 545
 546                 pos = strchr(line, '\n');
 547                 if (pos == NULL)
 548                         continue;
 549                 pos[0] = '\0';
 550
 551                 if (strncmp(line, "DEVTYPE=", 8) == 0) {
 552                         udev_device_set_devtype(udev_device, &line[8]);
 553                         continue;
 554                 }
 555                 if (strncmp(line, "IFINDEX=", 8) == 0) {
 556                         udev_device_set_ifindex(udev_device, strtoull(&line[8], NULL, 10));
 557                         continue;
 558                 }
 559                 if (strncmp(line, "DEVNAME=", 8) == 0) {
 560                         udev_device_set_devnode(udev_device, &line[8]);
 561                         continue;
 562                 }
 563
 564                 if (strncmp(line, "MAJOR=", 6) == 0)
 565                         maj = strtoull(&line[6], NULL, 10);
 566                 else if (strncmp(line, "MINOR=", 6) == 0)
 567                         min = strtoull(&line[6], NULL, 10);
 568                 else if (strncmp(line, "DEVMODE=", 8) == 0)
 569                         udev_device->devnode_mode = strtoul(&line[8], NULL, 8);
 570
 571                 udev_device_add_property_from_string(udev_device, line);
 572         }
 573
 574         udev_device->devnum = makedev(maj, min);
 575         fclose(f);
 576         return 0;
 577 }
 578
 579 void udev_device_set_info_loaded(struct udev_device *device)
 580 {
 581         device->info_loaded = true;
 582 }
 583
 584 struct udev_device *udev_device_new(struct udev *udev)
 585 {
 586         struct udev_device *udev_device;
 587         struct udev_list_entry *list_entry;
 588
 589         if (udev == NULL)
 590                 return NULL;
 591
 592         udev_device = calloc(1, sizeof(struct udev_device));
 593         if (udev_device == NULL)
 594                 return NULL;
 595         udev_device->refcount = 1;
 596         udev_device->udev = udev;
 597         udev_list_init(udev, &udev_device->devlinks_list, true);
 598         udev_list_init(udev, &udev_device->properties_list, true);
 599         udev_list_init(udev, &udev_device->sysattr_value_list, true);
 600         udev_list_init(udev, &udev_device->sysattr_list, false);
 601         udev_list_init(udev, &udev_device->tags_list, true);
 602         udev_device->watch_handle = -1;
 603         /* copy global properties */
 604         udev_list_entry_foreach(list_entry, udev_get_properties_list_entry(udev))
 605                 udev_device_add_property(udev_device,
 606                                          udev_list_entry_get_name(list_entry),
 607                                          udev_list_entry_get_value(list_entry));
 608         return udev_device;
 609 }
 610
 611 /**
 612  * udev_device_new_from_syspath:
 613  * @udev: udev library context
 614  * @syspath: sys device path including sys directory
 615  *
 616  * Create new udev device, and fill in information from the sys
 617  * device and the udev database entry. The syspath is the absolute
 618  * path to the device, including the sys mount point.
 619  *
 620  * The initial refcount is 1, and needs to be decremented to
 621  * release the resources of the udev device.
 622  *
 623  * Returns: a new udev device, or #NULL, if it does not exist
 624  **/
 625 _public_ struct udev_device *udev_device_new_from_syspath(struct udev *udev, const char *syspath)
 626 {
 627         const char *subdir;
 628         char path[UTIL_PATH_SIZE];
 629         char *pos;
 630         struct stat statbuf;
 631         struct udev_device *udev_device;
 632
 633         if (udev == NULL)
 634                 return NULL;
 635         if (syspath == NULL)
 636                 return NULL;
 637
 638         /* path starts in sys */
 639         if (strncmp(syspath, TEST_PREFIX "/sys", strlen(TEST_PREFIX "/sys")) != 0) {
 640                 dbg(udev, "not in sys :%s\n", syspath);
 641                 return NULL;
 642         }
 643
 644         /* path is not a root directory */
 645         subdir = syspath + strlen(TEST_PREFIX "/sys");
 646         pos = strrchr(subdir, '/');
 647         if (pos == NULL || pos[1] == '\0' || pos < &subdir[2])
 648                 return NULL;
 649
 650         /* resolve possible symlink to real path */
 651         util_strscpy(path, sizeof(path), syspath);
 652         util_resolve_sys_link(udev, path, sizeof(path));
 653
 654         if (strncmp(path + strlen(TEST_PREFIX "/sys"), "/devices/", 9) == 0) {
 655                 char file[UTIL_PATH_SIZE];
 656
 657                 /* all "devices" require a "uevent" file */
 658                 util_strscpyl(file, sizeof(file), path, "/uevent", NULL);
 659                 if (stat(file, &statbuf) != 0)
 660                         return NULL;
 661         } else {
 662                 /* everything else just needs to be a directory */
 663                 if (stat(path, &statbuf) != 0 || !S_ISDIR(statbuf.st_mode))
 664                         return NULL;
 665         }
 666
 667         udev_device = udev_device_new(udev);
 668         if (udev_device == NULL)
 669                 return NULL;
 670
 671         udev_device_set_syspath(udev_device, path);
 672         dbg(udev, "device %p has devpath '%s'\n", udev_device, udev_device_get_devpath(udev_device));
 673
 674         return udev_device;
 675 }
 676
 677 /**
 678  * udev_device_new_from_devnum:
 679  * @udev: udev library context
 680  * @type: char or block device
 681  * @devnum: device major/minor number
 682  *
 683  * Create new udev device, and fill in information from the sys
 684  * device and the udev database entry. The device is looked-up
 685  * by its major/minor number and type. Character and block device
 686  * numbers are not unique across the two types.
 687  *
 688  * The initial refcount is 1, and needs to be decremented to
 689  * release the resources of the udev device.
 690  *
 691  * Returns: a new udev device, or #NULL, if it does not exist
 692  **/
 693 _public_ struct udev_device *udev_device_new_from_devnum(struct udev *udev, char type, dev_t devnum)
 694 {
 695         char path[UTIL_PATH_SIZE];
 696         const char *type_str;
 697
 698         if (type == 'b')
 699                 type_str = "block";
 700         else if (type == 'c')
 701                 type_str = "char";
 702         else
 703                 return NULL;
 704
 705         /* use /sys/dev/{block,char}/<maj>:<min> link */
 706         snprintf(path, sizeof(path), TEST_PREFIX "/sys/dev/%s/%u:%u",
 707                  type_str, major(devnum), minor(devnum));
 708         return udev_device_new_from_syspath(udev, path);
 709 }
 710
 711 struct udev_device *udev_device_new_from_id_filename(struct udev *udev, char *id)
 712 {
 713         char type;
 714         int maj, min;
 715         char subsys[UTIL_PATH_SIZE];
 716         char *sysname;
 717
 718         switch(id[0]) {
 719         case 'b':
 720         case 'c':
 721                 if (sscanf(id, "%c%i:%i", &type, &maj, &min) != 3)
 722                         return NULL;
 723                 return udev_device_new_from_devnum(udev, type, makedev(maj, min));
 724         case 'n': {
 725                 int sk;
 726                 struct ifreq ifr;
 727                 struct udev_device *dev;
 728                 int ifindex;
 729
 730                 ifindex = strtoul(&id[1], NULL, 10);
 731                 if (ifindex <= 0)
 732                         return NULL;
 733
 734                 sk = socket(PF_INET, SOCK_DGRAM, 0);
 735                 if (sk < 0)
 736                         return NULL;
 737                 memset(&ifr, 0x00, sizeof(struct ifreq));
 738                 ifr.ifr_ifindex = ifindex;
 739                 if (ioctl(sk, SIOCGIFNAME, &ifr) != 0) {
 740                         close(sk);
 741                         return NULL;
 742                 }
 743                 close(sk);
 744
 745                 dev = udev_device_new_from_subsystem_sysname(udev, "net", ifr.ifr_name);
 746                 if (dev == NULL)
 747                         return NULL;
 748                 if (udev_device_get_ifindex(dev) == ifindex)
 749                         return dev;
 750                 udev_device_unref(dev);
 751                 return NULL;
 752         }
 753         case '+':
 754                 util_strscpy(subsys, sizeof(subsys), &id[1]);
 755                 sysname = strchr(subsys, ':');
 756                 if (sysname == NULL)
 757                         return NULL;
 758                 sysname[0] = '\0';
 759                 sysname = &sysname[1];
 760                 return udev_device_new_from_subsystem_sysname(udev, subsys, sysname);
 761         default:
 762                 return NULL;
 763         }
 764 }
 765
 766 /**
 767  * udev_device_new_from_subsystem_sysname:
 768  * @udev: udev library context
 769  * @subsystem: the subsystem of the device
 770  * @sysname: the name of the device
 771  *
 772  * Create new udev device, and fill in information from the sys device
 773  * and the udev database entry. The device is looked up by the subsystem
 774  * and name string of the device, like "mem" / "zero", or "block" / "sda".
 775  *
 776  * The initial refcount is 1, and needs to be decremented to
 777  * release the resources of the udev device.
 778  *
 779  * Returns: a new udev device, or #NULL, if it does not exist
 780  **/
 781 _public_ struct udev_device *udev_device_new_from_subsystem_sysname(struct udev *udev, const char *subsystem, const char *sysname)
 782 {
 783         char path[UTIL_PATH_SIZE];
 784         struct stat statbuf;
 785
 786         if (strcmp(subsystem, "subsystem") == 0) {
 787                 util_strscpyl(path, sizeof(path), TEST_PREFIX "/sys/subsystem/", sysname, NULL);
 788                 if (stat(path, &statbuf) == 0)
 789                         goto found;
 790
 791                 util_strscpyl(path, sizeof(path), TEST_PREFIX "/sys/bus/", sysname, NULL);
 792                 if (stat(path, &statbuf) == 0)
 793                         goto found;
 794
 795                 util_strscpyl(path, sizeof(path), TEST_PREFIX "/sys/class/", sysname, NULL);
 796                 if (stat(path, &statbuf) == 0)
 797                         goto found;
 798                 goto out;
 799         }
 800
 801         if (strcmp(subsystem, "module") == 0) {
 802                 util_strscpyl(path, sizeof(path), TEST_PREFIX "/sys/module/", sysname, NULL);
 803                 if (stat(path, &statbuf) == 0)
 804                         goto found;
 805                 goto out;
 806         }
 807
 808         if (strcmp(subsystem, "drivers") == 0) {
 809                 char subsys[UTIL_NAME_SIZE];
 810                 char *driver;
 811
 812                 util_strscpy(subsys, sizeof(subsys), sysname);
 813                 driver = strchr(subsys, ':');
 814                 if (driver != NULL) {
 815                         driver[0] = '\0';
 816                         driver = &driver[1];
 817
 818                         util_strscpyl(path, sizeof(path), TEST_PREFIX "/sys/subsystem/", subsys, "/drivers/", driver, NULL);
 819                         if (stat(path, &statbuf) == 0)
 820                                 goto found;
 821
 822                         util_strscpyl(path, sizeof(path), TEST_PREFIX "/sys/bus/", subsys, "/drivers/", driver, NULL);
 823                         if (stat(path, &statbuf) == 0)
 824                                 goto found;
 825                 }
 826                 goto out;
 827         }
 828
 829         util_strscpyl(path, sizeof(path), TEST_PREFIX "/sys/subsystem/", subsystem, "/devices/", sysname, NULL);
 830         if (stat(path, &statbuf) == 0)
 831                 goto found;
 832
 833         util_strscpyl(path, sizeof(path), TEST_PREFIX "/sys/bus/", subsystem, "/devices/", sysname, NULL);
 834         if (stat(path, &statbuf) == 0)
 835                 goto found;
 836
 837         util_strscpyl(path, sizeof(path), TEST_PREFIX "/sys/class/", subsystem, "/", sysname, NULL);
 838         if (stat(path, &statbuf) == 0)
 839                 goto found;
 840 out:
 841         return NULL;
 842 found:
 843         return udev_device_new_from_syspath(udev, path);
 844 }
 845
 846 /**
 847  * udev_device_new_from_environment
 848  * @udev: udev library context
 849  *
 850  * Create new udev device, and fill in information from the
 851  * current process environment. This only works reliable if
 852  * the process is called from a udev rule. It is usually used
 853  * for tools executed from IMPORT= rules.
 854  *
 855  * The initial refcount is 1, and needs to be decremented to
 856  * release the resources of the udev device.
 857  *
 858  * Returns: a new udev device, or #NULL, if it does not exist
 859  **/
 860 _public_ struct udev_device *udev_device_new_from_environment(struct udev *udev)
 861 {
 862         int i;
 863         struct udev_device *udev_device;
 864
 865         udev_device = udev_device_new(udev);
 866         if (udev_device == NULL)
 867                 return NULL;
 868         udev_device_set_info_loaded(udev_device);
 869
 870         for (i = 0; environ[i] != NULL; i++)
 871                 udev_device_add_property_from_string_parse(udev_device, environ[i]);
 872
 873         if (udev_device_add_property_from_string_parse_finish(udev_device) < 0) {
 874                 dbg(udev, "missing values, invalid device\n");
 875                 udev_device_unref(udev_device);
 876                 udev_device = NULL;
 877         }
 878
 879         return udev_device;
 880 }
 881
 882 static struct udev_device *device_new_from_parent(struct udev_device *udev_device)
 883 {
 884         struct udev_device *udev_device_parent = NULL;
 885         char path[UTIL_PATH_SIZE];
 886         const char *subdir;
 887
 888         util_strscpy(path, sizeof(path), udev_device->syspath);
 889         subdir = path + strlen(TEST_PREFIX "/sys/");
 890         for (;;) {
 891                 char *pos;
 892
 893                 pos = strrchr(subdir, '/');
 894                 if (pos == NULL || pos < &subdir[2])
 895                         break;
 896                 pos[0] = '\0';
 897                 udev_device_parent = udev_device_new_from_syspath(udev_device->udev, path);
 898                 if (udev_device_parent != NULL)
 899                         return udev_device_parent;
 900         }
 901         return NULL;
 902 }
 903
 904 /**
 905  * udev_device_get_parent:
 906  * @udev_device: the device to start searching from
 907  *
 908  * Find the next parent device, and fill in information from the sys
 909  * device and the udev database entry.
 910  *
 911  * The returned the device is not referenced. It is attached to the
 912  * child device, and will be cleaned up when the child device
 913  * is cleaned up.
 914  *
 915  * It is not necessarily just the upper level directory, empty or not
 916  * recognized sys directories are ignored.
 917  *
 918  * It can be called as many times as needed, without caring about
 919  * references.
 920  *
 921  * Returns: a new udev device, or #NULL, if it no parent exist.
 922  **/
 923 _public_ struct udev_device *udev_device_get_parent(struct udev_device *udev_device)
 924 {
 925         if (udev_device == NULL)
 926                 return NULL;
 927         if (!udev_device->parent_set) {
 928                 udev_device->parent_set = true;
 929                 udev_device->parent_device = device_new_from_parent(udev_device);
 930         }
 931         return udev_device->parent_device;
 932 }
 933
 934 /**
 935  * udev_device_get_parent_with_subsystem_devtype:
 936  * @udev_device: udev device to start searching from
 937  * @subsystem: the subsystem of the device
 938  * @devtype: the type (DEVTYPE) of the device
 939  *
 940  * Find the next parent device, with a matching subsystem and devtype
 941  * value, and fill in information from the sys device and the udev
 942  * database entry.
 943  *
 944  * If devtype is #NULL, only subsystem is checked, and any devtype will
 945  * match.
 946  *
 947  * The returned the device is not referenced. It is attached to the
 948  * child device, and will be cleaned up when the child device
 949  * is cleaned up.
 950  *
 951  * It can be called as many times as needed, without caring about
 952  * references.
 953  *
 954  * Returns: a new udev device, or #NULL if no matching parent exists.
 955  **/
 956 _public_ struct udev_device *udev_device_get_parent_with_subsystem_devtype(struct udev_device *udev_device, const char *subsystem, const char *devtype)
 957 {
 958         struct udev_device *parent;
 959
 960         if (subsystem == NULL)
 961                 return NULL;
 962
 963         parent = udev_device_get_parent(udev_device);
 964         while (parent != NULL) {
 965                 const char *parent_subsystem;
 966                 const char *parent_devtype;
 967
 968                 parent_subsystem = udev_device_get_subsystem(parent);
 969                 if (parent_subsystem != NULL && strcmp(parent_subsystem, subsystem) == 0) {
 970                         if (devtype == NULL)
 971                                 break;
 972                         parent_devtype = udev_device_get_devtype(parent);
 973                         if (parent_devtype != NULL && strcmp(parent_devtype, devtype) == 0)
 974                                 break;
 975                 }
 976                 parent = udev_device_get_parent(parent);
 977         }
 978         return parent;
 979 }
 980
 981 /**
 982  * udev_device_get_udev:
 983  * @udev_device: udev device
 984  *
 985  * Retrieve the udev library context the device was created with.
 986  *
 987  * Returns: the udev library context
 988  **/
 989 _public_ struct udev *udev_device_get_udev(struct udev_device *udev_device)
 990 {
 991         if (udev_device == NULL)
 992                 return NULL;
 993         return udev_device->udev;
 994 }
 995
 996 /**
 997  * udev_device_ref:
 998  * @udev_device: udev device
 999  *
1000  * Take a reference of a udev device.
1001  *
1002  * Returns: the passed udev device
1003  **/
1004 _public_ struct udev_device *udev_device_ref(struct udev_device *udev_device)
1005 {
1006         if (udev_device == NULL)
1007                 return NULL;
1008         udev_device->refcount++;
1009         return udev_device;
1010 }
1011
1012 /**
1013  * udev_device_unref:
1014  * @udev_device: udev device
1015  *
1016  * Drop a reference of a udev device. If the refcount reaches zero,
1017  * the resources of the device will be released.
1018  *
1019  **/
1020 _public_ void udev_device_unref(struct udev_device *udev_device)
1021 {
1022         if (udev_device == NULL)
1023                 return;
1024         udev_device->refcount--;
1025         if (udev_device->refcount > 0)
1026                 return;
1027         if (udev_device->parent_device != NULL)
1028                 udev_device_unref(udev_device->parent_device);
1029         free(udev_device->syspath);
1030         free(udev_device->sysname);
1031         free(udev_device->devnode);
1032         free(udev_device->subsystem);
1033         free(udev_device->devtype);
1034         udev_list_cleanup(&udev_device->devlinks_list);
1035         udev_list_cleanup(&udev_device->properties_list);
1036         udev_list_cleanup(&udev_device->sysattr_value_list);
1037         udev_list_cleanup(&udev_device->sysattr_list);
1038         udev_list_cleanup(&udev_device->tags_list);
1039         free(udev_device->action);
1040         free(udev_device->driver);
1041         free(udev_device->devpath_old);
1042         free(udev_device->id_filename);
1043         free(udev_device->envp);
1044         free(udev_device->monitor_buf);
1045         free(udev_device);
1046 }
1047
1048 /**
1049  * udev_device_get_devpath:
1050  * @udev_device: udev device
1051  *
1052  * Retrieve the kernel devpath value of the udev device. The path
1053  * does not contain the sys mount point, and starts with a '/'.
1054  *
1055  * Returns: the devpath of the udev device
1056  **/
1057 _public_ const char *udev_device_get_devpath(struct udev_device *udev_device)
1058 {
1059         if (udev_device == NULL)
1060                 return NULL;
1061         return udev_device->devpath;
1062 }
1063
1064 /**
1065  * udev_device_get_syspath:
1066  * @udev_device: udev device
1067  *
1068  * Retrieve the sys path of the udev device. The path is an
1069  * absolute path and starts with the sys mount point.
1070  *
1071  * Returns: the sys path of the udev device
1072  **/
1073 _public_ const char *udev_device_get_syspath(struct udev_device *udev_device)
1074 {
1075         if (udev_device == NULL)
1076                 return NULL;
1077         return udev_device->syspath;
1078 }
1079
1080 /**
1081  * udev_device_get_sysname:
1082  * @udev_device: udev device
1083  *
1084  * Returns: the sys name of the device device
1085  **/
1086 _public_ const char *udev_device_get_sysname(struct udev_device *udev_device)
1087 {
1088         if (udev_device == NULL)
1089                 return NULL;
1090         return udev_device->sysname;
1091 }
1092
1093 /**
1094  * udev_device_get_sysnum:
1095  * @udev_device: udev device
1096  *
1097  * Returns: the trailing number of of the device name
1098  **/
1099 _public_ const char *udev_device_get_sysnum(struct udev_device *udev_device)
1100 {
1101         if (udev_device == NULL)
1102                 return NULL;
1103         return udev_device->sysnum;
1104 }
1105
1106 /**
1107  * udev_device_get_devnode:
1108  * @udev_device: udev device
1109  *
1110  * Retrieve the device node file name belonging to the udev device.
1111  * The path is an absolute path, and starts with the device directory.
1112  *
1113  * Returns: the device node file name of the udev device, or #NULL if no device node exists
1114  **/
1115 _public_ const char *udev_device_get_devnode(struct udev_device *udev_device)
1116 {
1117         if (udev_device == NULL)
1118                 return NULL;
1119         if (udev_device->devnode != NULL)
1120                 return udev_device->devnode;
1121         if (!udev_device->info_loaded)
1122                 udev_device_read_uevent_file(udev_device);
1123         return udev_device->devnode;
1124 }
1125
1126 /**
1127  * udev_device_get_devlinks_list_entry:
1128  * @udev_device: udev device
1129  *
1130  * Retrieve the list of device links pointing to the device file of
1131  * the udev device. The next list entry can be retrieved with
1132  * udev_list_entry_get_next(), which returns #NULL if no more entries exist.
1133  * The devlink path can be retrieved from the list entry by
1134  * udev_list_entry_get_name(). The path is an absolute path, and starts with
1135  * the device directory.
1136  *
1137  * Returns: the first entry of the device node link list
1138  **/
1139 _public_ struct udev_list_entry *udev_device_get_devlinks_list_entry(struct udev_device *udev_device)
1140 {
1141         if (udev_device == NULL)
1142                 return NULL;
1143         if (!udev_device->info_loaded)
1144                 udev_device_read_db(udev_device, NULL);
1145         return udev_list_get_entry(&udev_device->devlinks_list);
1146 }
1147
1148 void udev_device_cleanup_devlinks_list(struct udev_device *udev_device)
1149 {
1150         udev_device->devlinks_uptodate = false;
1151         udev_list_cleanup(&udev_device->devlinks_list);
1152 }
1153
1154 /**
1155  * udev_device_get_properties_list_entry:
1156  * @udev_device: udev device
1157  *
1158  * Retrieve the list of key/value device properties of the udev
1159  * device. The next list entry can be retrieved with udev_list_entry_get_next(),
1160  * which returns #NULL if no more entries exist. The property name
1161  * can be retrieved from the list entry by udev_list_entry_get_name(),
1162  * the property value by udev_list_entry_get_value().
1163  *
1164  * Returns: the first entry of the property list
1165  **/
1166 _public_ struct udev_list_entry *udev_device_get_properties_list_entry(struct udev_device *udev_device)
1167 {
1168         if (udev_device == NULL)
1169                 return NULL;
1170         if (!udev_device->info_loaded) {
1171                 udev_device_read_uevent_file(udev_device);
1172                 udev_device_read_db(udev_device, NULL);
1173         }
1174         if (!udev_device->devlinks_uptodate) {
1175                 char symlinks[UTIL_PATH_SIZE];
1176                 struct udev_list_entry *list_entry;
1177
1178                 udev_device->devlinks_uptodate = true;
1179                 list_entry = udev_device_get_devlinks_list_entry(udev_device);
1180                 if (list_entry != NULL) {
1181                         char *s;
1182                         size_t l;
1183
1184                         s = symlinks;
1185                         l = util_strpcpyl(&s, sizeof(symlinks), udev_list_entry_get_name(list_entry), NULL);
1186                         udev_list_entry_foreach(list_entry, udev_list_entry_get_next(list_entry))
1187                                 l = util_strpcpyl(&s, l, " ", udev_list_entry_get_name(list_entry), NULL);
1188                         udev_device_add_property(udev_device, "DEVLINKS", symlinks);
1189                 }
1190         }
1191         if (!udev_device->tags_uptodate) {
1192                 udev_device->tags_uptodate = true;
1193                 if (udev_device_get_tags_list_entry(udev_device) != NULL) {
1194                         char tags[UTIL_PATH_SIZE];
1195                         struct udev_list_entry *list_entry;
1196                         char *s;
1197                         size_t l;
1198
1199                         s = tags;
1200                         l = util_strpcpyl(&s, sizeof(tags), ":", NULL);
1201                         udev_list_entry_foreach(list_entry, udev_device_get_tags_list_entry(udev_device))
1202                                 l = util_strpcpyl(&s, l, udev_list_entry_get_name(list_entry), ":", NULL);
1203                         udev_device_add_property(udev_device, "TAGS", tags);
1204                 }
1205         }
1206         return udev_list_get_entry(&udev_device->properties_list);
1207 }
1208
1209 /**
1210  * udev_device_get_action:
1211  * @udev_device: udev device
1212  *
1213  * This is only valid if the device was received through a monitor. Devices read from
1214  * sys do not have an action string. Usual actions are: add, remove, change, online,
1215  * offline.
1216  *
1217  * Returns: the kernel action value, or #NULL if there is no action value available.
1218  **/
1219 _public_ const char *udev_device_get_action(struct udev_device *udev_device)
1220 {
1221         if (udev_device == NULL)
1222                 return NULL;
1223         return udev_device->action;
1224 }
1225
1226 /**
1227  * udev_device_get_usec_since_initialized:
1228  * @udev_device: udev device
1229  *
1230  * Return the number of microseconds passed since udev set up the
1231  * device for the first time.
1232  *
1233  * This is only implemented for devices with need to store properties
1234  * in the udev database. All other devices return 0 here.
1235  *
1236  * Returns: the number of microseconds since the device was first seen.
1237  **/
1238 _public_ unsigned long long int udev_device_get_usec_since_initialized(struct udev_device *udev_device)
1239 {
1240         unsigned long long now;
1241
1242         if (udev_device == NULL)
1243                 return 0;
1244         if (!udev_device->info_loaded)
1245                 udev_device_read_db(udev_device, NULL);
1246         if (udev_device->usec_initialized == 0)
1247                 return 0;
1248         now = now_usec();
1249         if (now == 0)
1250                 return 0;
1251         return now - udev_device->usec_initialized;
1252 }
1253
1254 unsigned long long udev_device_get_usec_initialized(struct udev_device *udev_device)
1255 {
1256         return udev_device->usec_initialized;
1257 }
1258
1259 void udev_device_set_usec_initialized(struct udev_device *udev_device, unsigned long long usec_initialized)
1260 {
1261         char num[32];
1262
1263         udev_device->usec_initialized = usec_initialized;
1264         snprintf(num, sizeof(num), "%llu", usec_initialized);
1265         udev_device_add_property(udev_device, "USEC_INITIALIZED", num);
1266 }
1267
1268 /**
1269  * udev_device_get_sysattr_value:
1270  * @udev_device: udev device
1271  * @sysattr: attribute name
1272  *
1273  * The retrieved value is cached in the device. Repeated calls will return the same
1274  * value and not open the attribute again.
1275  *
1276  * Returns: the content of a sys attribute file, or #NULL if there is no sys attribute value.
1277  **/
1278 _public_ const char *udev_device_get_sysattr_value(struct udev_device *udev_device, const char *sysattr)
1279 {
1280         struct udev_list_entry *list_entry;
1281         char path[UTIL_PATH_SIZE];
1282         char value[4096];
1283         struct stat statbuf;
1284         int fd;
1285         ssize_t size;
1286         const char *val = NULL;
1287
1288         if (udev_device == NULL)
1289                 return NULL;
1290         if (sysattr == NULL)
1291                 return NULL;
1292
1293         /* look for possibly already cached result */
1294         list_entry = udev_list_get_entry(&udev_device->sysattr_value_list);
1295         list_entry = udev_list_entry_get_by_name(list_entry, sysattr);
1296         if (list_entry != NULL)
1297                 return udev_list_entry_get_value(list_entry);
1298
1299         util_strscpyl(path, sizeof(path), udev_device_get_syspath(udev_device), "/", sysattr, NULL);
1300         if (lstat(path, &statbuf) != 0) {
1301                 udev_list_entry_add(&udev_device->sysattr_value_list, sysattr, NULL);
1302                 goto out;
1303         }
1304
1305         if (S_ISLNK(statbuf.st_mode)) {
1306                 struct udev_device *dev;
1307
1308                 /*
1309                  * Some core links return only the last element of the target path,
1310                  * these are just values, the paths should not be exposed.
1311                  */
1312                 if (strcmp(sysattr, "driver") == 0 ||
1313                     strcmp(sysattr, "subsystem") == 0 ||
1314                     strcmp(sysattr, "module") == 0) {
1315                         if (util_get_sys_core_link_value(udev_device->udev, sysattr,
1316                                                          udev_device->syspath, value, sizeof(value)) < 0)
1317                                 return NULL;
1318                         list_entry = udev_list_entry_add(&udev_device->sysattr_value_list, sysattr, value);
1319                         val = udev_list_entry_get_value(list_entry);
1320                         goto out;
1321                 }
1322
1323                 /* resolve link to a device and return its syspath */
1324                 util_strscpyl(path, sizeof(path), udev_device->syspath, "/", sysattr, NULL);
1325                 dev = udev_device_new_from_syspath(udev_device->udev, path);
1326                 if (dev != NULL) {
1327                         list_entry = udev_list_entry_add(&udev_device->sysattr_value_list, sysattr,
1328                                                          udev_device_get_syspath(dev));
1329                         val = udev_list_entry_get_value(list_entry);
1330                         udev_device_unref(dev);
1331                 }
1332
1333                 goto out;
1334         }
1335
1336         /* skip directories */
1337         if (S_ISDIR(statbuf.st_mode))
1338                 goto out;
1339
1340         /* skip non-readable files */
1341         if ((statbuf.st_mode & S_IRUSR) == 0)
1342                 goto out;
1343
1344         /* read attribute value */
1345         fd = open(path, O_RDONLY|O_CLOEXEC);
1346         if (fd < 0)
1347                 goto out;
1348         size = read(fd, value, sizeof(value));
1349         close(fd);
1350         if (size < 0)
1351                 goto out;
1352         if (size == sizeof(value))
1353                 goto out;
1354
1355         /* got a valid value, store it in cache and return it */
1356         value[size] = '\0';
1357         util_remove_trailing_chars(value, '\n');
1358         list_entry = udev_list_entry_add(&udev_device->sysattr_value_list, sysattr, value);
1359         val = udev_list_entry_get_value(list_entry);
1360 out:
1361         return val;
1362 }
1363
1364 static int udev_device_sysattr_list_read(struct udev_device *udev_device)
1365 {
1366         struct dirent *dent;
1367         DIR *dir;
1368         int num = 0;
1369
1370         if (udev_device == NULL)
1371                 return -1;
1372         if (udev_device->sysattr_list_read)
1373                 return 0;
1374
1375         dir = opendir(udev_device_get_syspath(udev_device));
1376         if (!dir)
1377                 return -1;
1378
1379         for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
1380                 char path[UTIL_PATH_SIZE];
1381                 struct stat statbuf;
1382
1383                 /* only handle symlinks and regular files */
1384                 if (dent->d_type != DT_LNK && dent->d_type != DT_REG)
1385                         continue;
1386
1387                 util_strscpyl(path, sizeof(path), udev_device_get_syspath(udev_device), "/", dent->d_name, NULL);
1388                 if (lstat(path, &statbuf) != 0)
1389                         continue;
1390                 if ((statbuf.st_mode & S_IRUSR) == 0)
1391                         continue;
1392
1393                 udev_list_entry_add(&udev_device->sysattr_list, dent->d_name, NULL);
1394                 num++;
1395         }
1396
1397         closedir(dir);
1398         udev_device->sysattr_list_read = true;
1399
1400         return num;
1401 }
1402
1403 /**
1404  * udev_device_get_sysattr_list_entry:
1405  * @udev_device: udev device
1406  *
1407  * Retrieve the list of available sysattrs, with value being empty;
1408  * This just return all available sysfs attributes for a particular
1409  * device without reading their values.
1410  *
1411  * Returns: the first entry of the property list
1412  **/
1413 _public_ struct udev_list_entry *udev_device_get_sysattr_list_entry(struct udev_device *udev_device)
1414 {
1415         if (!udev_device->sysattr_list_read) {
1416                 int ret;
1417                 ret = udev_device_sysattr_list_read(udev_device);
1418                 if (0 > ret)
1419                         return NULL;
1420         }
1421
1422         return udev_list_get_entry(&udev_device->sysattr_list);
1423 }
1424
1425 int udev_device_set_syspath(struct udev_device *udev_device, const char *syspath)
1426 {
1427         const char *pos;
1428         size_t len;
1429
1430         free(udev_device->syspath);
1431         udev_device->syspath = strdup(syspath);
1432         if (udev_device->syspath ==  NULL)
1433                 return -ENOMEM;
1434         udev_device->devpath = udev_device->syspath + strlen(TEST_PREFIX "/sys");
1435         udev_device_add_property(udev_device, "DEVPATH", udev_device->devpath);
1436
1437         pos = strrchr(udev_device->syspath, '/');
1438         if (pos == NULL)
1439                 return -EINVAL;
1440         udev_device->sysname = strdup(&pos[1]);
1441         if (udev_device->sysname == NULL)
1442                 return -ENOMEM;
1443
1444         /* some devices have '!' in their name, change that to '/' */
1445         len = 0;
1446         while (udev_device->sysname[len] != '\0') {
1447                 if (udev_device->sysname[len] == '!')
1448                         udev_device->sysname[len] = '/';
1449                 len++;
1450         }
1451
1452         /* trailing number */
1453         while (len > 0 && isdigit(udev_device->sysname[--len]))
1454                 udev_device->sysnum = &udev_device->sysname[len];
1455
1456         /* sysname is completely numeric */
1457         if (len == 0)
1458                 udev_device->sysnum = NULL;
1459
1460         return 0;
1461 }
1462
1463 int udev_device_set_devnode(struct udev_device *udev_device, const char *devnode)
1464 {
1465         free(udev_device->devnode);
1466         if (devnode[0] != '/') {
1467                 if (asprintf(&udev_device->devnode, TEST_PREFIX "/dev/%s", devnode) < 0)
1468                         udev_device->devnode = NULL;
1469         } else {
1470                 udev_device->devnode = strdup(devnode);
1471         }
1472         if (udev_device->devnode == NULL)
1473                 return -ENOMEM;
1474         udev_device_add_property(udev_device, "DEVNAME", udev_device->devnode);
1475         return 0;
1476 }
1477
1478 int udev_device_add_devlink(struct udev_device *udev_device, const char *devlink, int unique)
1479 {
1480         struct udev_list_entry *list_entry;
1481
1482         udev_device->devlinks_uptodate = false;
1483         list_entry = udev_list_entry_add(&udev_device->devlinks_list, devlink, NULL);
1484         if (list_entry == NULL)
1485                 return -ENOMEM;
1486         if (unique)
1487                 udev_list_entry_set_num(list_entry, true);
1488         return 0;
1489 }
1490
1491 const char *udev_device_get_id_filename(struct udev_device *udev_device)
1492 {
1493         if (udev_device->id_filename == NULL) {
1494                 if (udev_device_get_subsystem(udev_device) == NULL)
1495                         return NULL;
1496
1497                 if (major(udev_device_get_devnum(udev_device)) > 0) {
1498                         /* use dev_t -- b259:131072, c254:0 */
1499                         if (asprintf(&udev_device->id_filename, "%c%u:%u",
1500                                      strcmp(udev_device_get_subsystem(udev_device), "block") == 0 ? 'b' : 'c',
1501                                      major(udev_device_get_devnum(udev_device)),
1502                                      minor(udev_device_get_devnum(udev_device))) < 0)
1503                                 udev_device->id_filename = NULL;
1504                 } else if (udev_device_get_ifindex(udev_device) > 0) {
1505                         /* use netdev ifindex -- n3 */
1506                         if (asprintf(&udev_device->id_filename, "n%u", udev_device_get_ifindex(udev_device)) < 0)
1507                                 udev_device->id_filename = NULL;
1508                 } else {
1509                         /*
1510                          * use $subsys:$syname -- pci:0000:00:1f.2
1511                          * sysname() has '!' translated, get it from devpath
1512                          */
1513                         const char *sysname;
1514                         sysname = strrchr(udev_device->devpath, '/');
1515                         if (sysname == NULL)
1516                                 return NULL;
1517                         sysname = &sysname[1];
1518                         if (asprintf(&udev_device->id_filename, "+%s:%s", udev_device_get_subsystem(udev_device), sysname) < 0)
1519                                 udev_device->id_filename = NULL;
1520                 }
1521         }
1522         return udev_device->id_filename;
1523 }
1524
1525 /**
1526  * udev_device_get_is_initialized:
1527  * @udev_device: udev device
1528  *
1529  * Check if udev has already handled the device and has set up
1530  * device node permissions and context, or has renamed a network
1531  * device.
1532  *
1533  * This is only implemented for devices with a device node
1534  * or network interfaces. All other devices return 1 here.
1535  *
1536  * Returns: 1 if the device is set up. 0 otherwise.
1537  **/
1538 _public_ int udev_device_get_is_initialized(struct udev_device *udev_device)
1539 {
1540         if (!udev_device->info_loaded)
1541                 udev_device_read_db(udev_device, NULL);
1542         return udev_device->is_initialized;
1543 }
1544
1545 void udev_device_set_is_initialized(struct udev_device *udev_device)
1546 {
1547         udev_device->is_initialized = true;
1548 }
1549
1550 int udev_device_add_tag(struct udev_device *udev_device, const char *tag)
1551 {
1552         if (strchr(tag, ':') != NULL || strchr(tag, ' ') != NULL)
1553                 return -EINVAL;
1554         udev_device->tags_uptodate = false;
1555         if (udev_list_entry_add(&udev_device->tags_list, tag, NULL) != NULL)
1556                 return 0;
1557         return -ENOMEM;
1558 }
1559
1560 void udev_device_cleanup_tags_list(struct udev_device *udev_device)
1561 {
1562         udev_device->tags_uptodate = false;
1563         udev_list_cleanup(&udev_device->tags_list);
1564 }
1565
1566 /**
1567  * udev_device_get_tags_list_entry:
1568  * @udev_device: udev device
1569  *
1570  * Retrieve the list of tags attached to the udev device. The next
1571  * list entry can be retrieved with udev_list_entry_get_next(),
1572  * which returns #NULL if no more entries exist. The tag string
1573  * can be retrieved from the list entry by udev_list_entry_get_name().
1574  *
1575  * Returns: the first entry of the tag list
1576  **/
1577 _public_ struct udev_list_entry *udev_device_get_tags_list_entry(struct udev_device *udev_device)
1578 {
1579         if (udev_device == NULL)
1580                 return NULL;
1581         if (!udev_device->info_loaded)
1582                 udev_device_read_db(udev_device, NULL);
1583         return udev_list_get_entry(&udev_device->tags_list);
1584 }
1585
1586 _public_ int udev_device_has_tag(struct udev_device *udev_device, const char *tag)
1587 {
1588         struct udev_list_entry *list_entry;
1589
1590         if (udev_device == NULL)
1591                 return false;
1592         if (!udev_device->info_loaded)
1593                 udev_device_read_db(udev_device, NULL);
1594         list_entry = udev_device_get_tags_list_entry(udev_device);
1595         if (udev_list_entry_get_by_name(list_entry, tag) != NULL)
1596                 return true;
1597         return false;
1598 }
1599
1600 #define ENVP_SIZE                        128
1601 #define MONITOR_BUF_SIZE                4096
1602 static int update_envp_monitor_buf(struct udev_device *udev_device)
1603 {
1604         struct udev_list_entry *list_entry;
1605         char *s;
1606         size_t l;
1607         unsigned int i;
1608
1609         /* monitor buffer of property strings */
1610         free(udev_device->monitor_buf);
1611         udev_device->monitor_buf_len = 0;
1612         udev_device->monitor_buf = malloc(MONITOR_BUF_SIZE);
1613         if (udev_device->monitor_buf == NULL)
1614                 return -ENOMEM;
1615
1616         /* envp array, strings will point into monitor buffer */
1617         if (udev_device->envp == NULL)
1618                 udev_device->envp = malloc(sizeof(char *) * ENVP_SIZE);
1619         if (udev_device->envp == NULL)
1620                 return -ENOMEM;
1621
1622         i = 0;
1623         s = udev_device->monitor_buf;
1624         l = MONITOR_BUF_SIZE;
1625         udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(udev_device)) {
1626                 const char *key;
1627
1628                 key = udev_list_entry_get_name(list_entry);
1629                 /* skip private variables */
1630                 if (key[0] == '.')
1631                         continue;
1632
1633                 /* add string to envp array */
1634                 udev_device->envp[i++] = s;
1635                 if (i+1 >= ENVP_SIZE)
1636                         return -EINVAL;
1637
1638                 /* add property string to monitor buffer */
1639                 l = util_strpcpyl(&s, l, key, "=", udev_list_entry_get_value(list_entry), NULL);
1640                 if (l == 0)
1641                         return -EINVAL;
1642                 /* advance past the trailing '\0' that util_strpcpyl() guarantees */
1643                 s++;
1644                 l--;
1645         }
1646         udev_device->envp[i] = NULL;
1647         udev_device->monitor_buf_len = s - udev_device->monitor_buf;
1648         udev_device->envp_uptodate = true;
1649         return 0;
1650 }
1651
1652 char **udev_device_get_properties_envp(struct udev_device *udev_device)
1653 {
1654         if (!udev_device->envp_uptodate)
1655                 if (update_envp_monitor_buf(udev_device) != 0)
1656                         return NULL;
1657         return udev_device->envp;
1658 }
1659
1660 ssize_t udev_device_get_properties_monitor_buf(struct udev_device *udev_device, const char **buf)
1661 {
1662         if (!udev_device->envp_uptodate)
1663                 if (update_envp_monitor_buf(udev_device) != 0)
1664                         return -EINVAL;
1665         *buf = udev_device->monitor_buf;
1666         return udev_device->monitor_buf_len;
1667 }
1668
1669 int udev_device_set_action(struct udev_device *udev_device, const char *action)
1670 {
1671         free(udev_device->action);
1672         udev_device->action = strdup(action);
1673         if (udev_device->action == NULL)
1674                 return -ENOMEM;
1675         udev_device_add_property(udev_device, "ACTION", udev_device->action);
1676         return 0;
1677 }
1678
1679 int udev_device_get_devlink_priority(struct udev_device *udev_device)
1680 {
1681         if (!udev_device->info_loaded)
1682                 udev_device_read_db(udev_device, NULL);
1683         return udev_device->devlink_priority;
1684 }
1685
1686 int udev_device_set_devlink_priority(struct udev_device *udev_device, int prio)
1687 {
1688          udev_device->devlink_priority = prio;
1689         return 0;
1690 }
1691
1692 int udev_device_get_watch_handle(struct udev_device *udev_device)
1693 {
1694         if (!udev_device->info_loaded)
1695                 udev_device_read_db(udev_device, NULL);
1696         return udev_device->watch_handle;
1697 }
1698
1699 int udev_device_set_watch_handle(struct udev_device *udev_device, int handle)
1700 {
1701         udev_device->watch_handle = handle;
1702         return 0;
1703 }
1704
1705 bool udev_device_get_db_persist(struct udev_device *udev_device)
1706 {
1707         return udev_device->db_persist;
1708 }
1709
1710 void udev_device_set_db_persist(struct udev_device *udev_device)
1711 {
1712         udev_device->db_persist = true;
1713 }