src/udev/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), udev_get_sys_path(udev_device->udev), &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), udev_get_run_path(udev_device->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), udev_get_dev_path(udev_device->udev), "/", 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         size_t len;
 628         const char *subdir;
 629         char path[UTIL_PATH_SIZE];
 630         char *pos;
 631         struct stat statbuf;
 632         struct udev_device *udev_device;
 633
 634         if (udev == NULL)
 635                 return NULL;
 636         if (syspath == NULL)
 637                 return NULL;
 638
 639         /* path starts in sys */
 640         len = strlen(udev_get_sys_path(udev));
 641         if (strncmp(syspath, udev_get_sys_path(udev), len) != 0) {
 642                 dbg(udev, "not in sys :%s\n", syspath);
 643                 return NULL;
 644         }
 645
 646         /* path is not a root directory */
 647         subdir = &syspath[len+1];
 648         pos = strrchr(subdir, '/');
 649         if (pos == NULL || pos[1] == '\0' || pos < &subdir[2])
 650                 return NULL;
 651
 652         /* resolve possible symlink to real path */
 653         util_strscpy(path, sizeof(path), syspath);
 654         util_resolve_sys_link(udev, path, sizeof(path));
 655
 656         if (strncmp(&path[len], "/devices/", 9) == 0) {
 657                 char file[UTIL_PATH_SIZE];
 658
 659                 /* all "devices" require a "uevent" file */
 660                 util_strscpyl(file, sizeof(file), path, "/uevent", NULL);
 661                 if (stat(file, &statbuf) != 0)
 662                         return NULL;
 663         } else {
 664                 /* everything else just needs to be a directory */
 665                 if (stat(path, &statbuf) != 0 || !S_ISDIR(statbuf.st_mode))
 666                         return NULL;
 667         }
 668
 669         udev_device = udev_device_new(udev);
 670         if (udev_device == NULL)
 671                 return NULL;
 672
 673         udev_device_set_syspath(udev_device, path);
 674         dbg(udev, "device %p has devpath '%s'\n", udev_device, udev_device_get_devpath(udev_device));
 675
 676         return udev_device;
 677 }
 678
 679 /**
 680  * udev_device_new_from_devnum:
 681  * @udev: udev library context
 682  * @type: char or block device
 683  * @devnum: device major/minor number
 684  *
 685  * Create new udev device, and fill in information from the sys
 686  * device and the udev database entry. The device is looked-up
 687  * by its major/minor number and type. Character and block device
 688  * numbers are not unique across the two types.
 689  *
 690  * The initial refcount is 1, and needs to be decremented to
 691  * release the resources of the udev device.
 692  *
 693  * Returns: a new udev device, or #NULL, if it does not exist
 694  **/
 695 _public_ struct udev_device *udev_device_new_from_devnum(struct udev *udev, char type, dev_t devnum)
 696 {
 697         char path[UTIL_PATH_SIZE];
 698         const char *type_str;
 699
 700         if (type == 'b')
 701                 type_str = "block";
 702         else if (type == 'c')
 703                 type_str = "char";
 704         else
 705                 return NULL;
 706
 707         /* use /sys/dev/{block,char}/<maj>:<min> link */
 708         snprintf(path, sizeof(path), "%s/dev/%s/%u:%u",
 709                  udev_get_sys_path(udev), type_str, major(devnum), minor(devnum));
 710         return udev_device_new_from_syspath(udev, path);
 711 }
 712
 713 struct udev_device *udev_device_new_from_id_filename(struct udev *udev, char *id)
 714 {
 715         char type;
 716         int maj, min;
 717         char subsys[UTIL_PATH_SIZE];
 718         char *sysname;
 719
 720         switch(id[0]) {
 721         case 'b':
 722         case 'c':
 723                 if (sscanf(id, "%c%i:%i", &type, &maj, &min) != 3)
 724                         return NULL;
 725                 return udev_device_new_from_devnum(udev, type, makedev(maj, min));
 726         case 'n': {
 727                 int sk;
 728                 struct ifreq ifr;
 729                 struct udev_device *dev;
 730                 int ifindex;
 731
 732                 ifindex = strtoul(&id[1], NULL, 10);
 733                 if (ifindex <= 0)
 734                         return NULL;
 735
 736                 sk = socket(PF_INET, SOCK_DGRAM, 0);
 737                 if (sk < 0)
 738                         return NULL;
 739                 memset(&ifr, 0x00, sizeof(struct ifreq));
 740                 ifr.ifr_ifindex = ifindex;
 741                 if (ioctl(sk, SIOCGIFNAME, &ifr) != 0) {
 742                         close(sk);
 743                         return NULL;
 744                 }
 745                 close(sk);
 746
 747                 dev = udev_device_new_from_subsystem_sysname(udev, "net", ifr.ifr_name);
 748                 if (dev == NULL)
 749                         return NULL;
 750                 if (udev_device_get_ifindex(dev) == ifindex)
 751                         return dev;
 752                 udev_device_unref(dev);
 753                 return NULL;
 754         }
 755         case '+':
 756                 util_strscpy(subsys, sizeof(subsys), &id[1]);
 757                 sysname = strchr(subsys, ':');
 758                 if (sysname == NULL)
 759                         return NULL;
 760                 sysname[0] = '\0';
 761                 sysname = &sysname[1];
 762                 return udev_device_new_from_subsystem_sysname(udev, subsys, sysname);
 763         default:
 764                 return NULL;
 765         }
 766 }
 767
 768 /**
 769  * udev_device_new_from_subsystem_sysname:
 770  * @udev: udev library context
 771  * @subsystem: the subsystem of the device
 772  * @sysname: the name of the device
 773  *
 774  * Create new udev device, and fill in information from the sys device
 775  * and the udev database entry. The device is looked up by the subsystem
 776  * and name string of the device, like "mem" / "zero", or "block" / "sda".
 777  *
 778  * The initial refcount is 1, and needs to be decremented to
 779  * release the resources of the udev device.
 780  *
 781  * Returns: a new udev device, or #NULL, if it does not exist
 782  **/
 783 _public_ struct udev_device *udev_device_new_from_subsystem_sysname(struct udev *udev, const char *subsystem, const char *sysname)
 784 {
 785         char path_full[UTIL_PATH_SIZE];
 786         char *path;
 787         size_t l;
 788         struct stat statbuf;
 789
 790         path = path_full;
 791         l = util_strpcpyl(&path, sizeof(path_full), udev_get_sys_path(udev), NULL);
 792
 793         if (strcmp(subsystem, "subsystem") == 0) {
 794                 util_strscpyl(path, l, "/subsystem/", sysname, NULL);
 795                 if (stat(path_full, &statbuf) == 0)
 796                         goto found;
 797
 798                 util_strscpyl(path, l, "/bus/", sysname, NULL);
 799                 if (stat(path_full, &statbuf) == 0)
 800                         goto found;
 801
 802                 util_strscpyl(path, l, "/class/", sysname, NULL);
 803                 if (stat(path_full, &statbuf) == 0)
 804                         goto found;
 805                 goto out;
 806         }
 807
 808         if (strcmp(subsystem, "module") == 0) {
 809                 util_strscpyl(path, l, "/module/", sysname, NULL);
 810                 if (stat(path_full, &statbuf) == 0)
 811                         goto found;
 812                 goto out;
 813         }
 814
 815         if (strcmp(subsystem, "drivers") == 0) {
 816                 char subsys[UTIL_NAME_SIZE];
 817                 char *driver;
 818
 819                 util_strscpy(subsys, sizeof(subsys), sysname);
 820                 driver = strchr(subsys, ':');
 821                 if (driver != NULL) {
 822                         driver[0] = '\0';
 823                         driver = &driver[1];
 824
 825                         util_strscpyl(path, l, "/subsystem/", subsys, "/drivers/", driver, NULL);
 826                         if (stat(path_full, &statbuf) == 0)
 827                                 goto found;
 828
 829                         util_strscpyl(path, l, "/bus/", subsys, "/drivers/", driver, NULL);
 830                         if (stat(path_full, &statbuf) == 0)
 831                                 goto found;
 832                 }
 833                 goto out;
 834         }
 835
 836         util_strscpyl(path, l, "/subsystem/", subsystem, "/devices/", sysname, NULL);
 837         if (stat(path_full, &statbuf) == 0)
 838                 goto found;
 839
 840         util_strscpyl(path, l, "/bus/", subsystem, "/devices/", sysname, NULL);
 841         if (stat(path_full, &statbuf) == 0)
 842                 goto found;
 843
 844         util_strscpyl(path, l, "/class/", subsystem, "/", sysname, NULL);
 845         if (stat(path_full, &statbuf) == 0)
 846                 goto found;
 847 out:
 848         return NULL;
 849 found:
 850         return udev_device_new_from_syspath(udev, path_full);
 851 }
 852
 853 /**
 854  * udev_device_new_from_environment
 855  * @udev: udev library context
 856  *
 857  * Create new udev device, and fill in information from the
 858  * current process environment. This only works reliable if
 859  * the process is called from a udev rule. It is usually used
 860  * for tools executed from IMPORT= rules.
 861  *
 862  * The initial refcount is 1, and needs to be decremented to
 863  * release the resources of the udev device.
 864  *
 865  * Returns: a new udev device, or #NULL, if it does not exist
 866  **/
 867 _public_ struct udev_device *udev_device_new_from_environment(struct udev *udev)
 868 {
 869         int i;
 870         struct udev_device *udev_device;
 871
 872         udev_device = udev_device_new(udev);
 873         if (udev_device == NULL)
 874                 return NULL;
 875         udev_device_set_info_loaded(udev_device);
 876
 877         for (i = 0; environ[i] != NULL; i++)
 878                 udev_device_add_property_from_string_parse(udev_device, environ[i]);
 879
 880         if (udev_device_add_property_from_string_parse_finish(udev_device) < 0) {
 881                 dbg(udev, "missing values, invalid device\n");
 882                 udev_device_unref(udev_device);
 883                 udev_device = NULL;
 884         }
 885
 886         return udev_device;
 887 }
 888
 889 static struct udev_device *device_new_from_parent(struct udev_device *udev_device)
 890 {
 891         struct udev_device *udev_device_parent = NULL;
 892         char path[UTIL_PATH_SIZE];
 893         const char *subdir;
 894
 895         util_strscpy(path, sizeof(path), udev_device->syspath);
 896         subdir = &path[strlen(udev_get_sys_path(udev_device->udev))+1];
 897         for (;;) {
 898                 char *pos;
 899
 900                 pos = strrchr(subdir, '/');
 901                 if (pos == NULL || pos < &subdir[2])
 902                         break;
 903                 pos[0] = '\0';
 904                 udev_device_parent = udev_device_new_from_syspath(udev_device->udev, path);
 905                 if (udev_device_parent != NULL)
 906                         return udev_device_parent;
 907         }
 908         return NULL;
 909 }
 910
 911 /**
 912  * udev_device_get_parent:
 913  * @udev_device: the device to start searching from
 914  *
 915  * Find the next parent device, and fill in information from the sys
 916  * device and the udev database entry.
 917  *
 918  * The returned the device is not referenced. It is attached to the
 919  * child device, and will be cleaned up when the child device
 920  * is cleaned up.
 921  *
 922  * It is not necessarily just the upper level directory, empty or not
 923  * recognized sys directories are ignored.
 924  *
 925  * It can be called as many times as needed, without caring about
 926  * references.
 927  *
 928  * Returns: a new udev device, or #NULL, if it no parent exist.
 929  **/
 930 _public_ struct udev_device *udev_device_get_parent(struct udev_device *udev_device)
 931 {
 932         if (udev_device == NULL)
 933                 return NULL;
 934         if (!udev_device->parent_set) {
 935                 udev_device->parent_set = true;
 936                 udev_device->parent_device = device_new_from_parent(udev_device);
 937         }
 938         return udev_device->parent_device;
 939 }
 940
 941 /**
 942  * udev_device_get_parent_with_subsystem_devtype:
 943  * @udev_device: udev device to start searching from
 944  * @subsystem: the subsystem of the device
 945  * @devtype: the type (DEVTYPE) of the device
 946  *
 947  * Find the next parent device, with a matching subsystem and devtype
 948  * value, and fill in information from the sys device and the udev
 949  * database entry.
 950  *
 951  * If devtype is #NULL, only subsystem is checked, and any devtype will
 952  * match.
 953  *
 954  * The returned the device is not referenced. It is attached to the
 955  * child device, and will be cleaned up when the child device
 956  * is cleaned up.
 957  *
 958  * It can be called as many times as needed, without caring about
 959  * references.
 960  *
 961  * Returns: a new udev device, or #NULL if no matching parent exists.
 962  **/
 963 _public_ struct udev_device *udev_device_get_parent_with_subsystem_devtype(struct udev_device *udev_device, const char *subsystem, const char *devtype)
 964 {
 965         struct udev_device *parent;
 966
 967         if (subsystem == NULL)
 968                 return NULL;
 969
 970         parent = udev_device_get_parent(udev_device);
 971         while (parent != NULL) {
 972                 const char *parent_subsystem;
 973                 const char *parent_devtype;
 974
 975                 parent_subsystem = udev_device_get_subsystem(parent);
 976                 if (parent_subsystem != NULL && strcmp(parent_subsystem, subsystem) == 0) {
 977                         if (devtype == NULL)
 978                                 break;
 979                         parent_devtype = udev_device_get_devtype(parent);
 980                         if (parent_devtype != NULL && strcmp(parent_devtype, devtype) == 0)
 981                                 break;
 982                 }
 983                 parent = udev_device_get_parent(parent);
 984         }
 985         return parent;
 986 }
 987
 988 /**
 989  * udev_device_get_udev:
 990  * @udev_device: udev device
 991  *
 992  * Retrieve the udev library context the device was created with.
 993  *
 994  * Returns: the udev library context
 995  **/
 996 _public_ struct udev *udev_device_get_udev(struct udev_device *udev_device)
 997 {
 998         if (udev_device == NULL)
 999                 return NULL;
1000         return udev_device->udev;
1001 }
1002
1003 /**
1004  * udev_device_ref:
1005  * @udev_device: udev device
1006  *
1007  * Take a reference of a udev device.
1008  *
1009  * Returns: the passed udev device
1010  **/
1011 _public_ struct udev_device *udev_device_ref(struct udev_device *udev_device)
1012 {
1013         if (udev_device == NULL)
1014                 return NULL;
1015         udev_device->refcount++;
1016         return udev_device;
1017 }
1018
1019 /**
1020  * udev_device_unref:
1021  * @udev_device: udev device
1022  *
1023  * Drop a reference of a udev device. If the refcount reaches zero,
1024  * the resources of the device will be released.
1025  *
1026  **/
1027 _public_ void udev_device_unref(struct udev_device *udev_device)
1028 {
1029         if (udev_device == NULL)
1030                 return;
1031         udev_device->refcount--;
1032         if (udev_device->refcount > 0)
1033                 return;
1034         if (udev_device->parent_device != NULL)
1035                 udev_device_unref(udev_device->parent_device);
1036         free(udev_device->syspath);
1037         free(udev_device->sysname);
1038         free(udev_device->devnode);
1039         free(udev_device->subsystem);
1040         free(udev_device->devtype);
1041         udev_list_cleanup(&udev_device->devlinks_list);
1042         udev_list_cleanup(&udev_device->properties_list);
1043         udev_list_cleanup(&udev_device->sysattr_value_list);
1044         udev_list_cleanup(&udev_device->sysattr_list);
1045         udev_list_cleanup(&udev_device->tags_list);
1046         free(udev_device->action);
1047         free(udev_device->driver);
1048         free(udev_device->devpath_old);
1049         free(udev_device->id_filename);
1050         free(udev_device->envp);
1051         free(udev_device->monitor_buf);
1052         free(udev_device);
1053 }
1054
1055 /**
1056  * udev_device_get_devpath:
1057  * @udev_device: udev device
1058  *
1059  * Retrieve the kernel devpath value of the udev device. The path
1060  * does not contain the sys mount point, and starts with a '/'.
1061  *
1062  * Returns: the devpath of the udev device
1063  **/
1064 _public_ const char *udev_device_get_devpath(struct udev_device *udev_device)
1065 {
1066         if (udev_device == NULL)
1067                 return NULL;
1068         return udev_device->devpath;
1069 }
1070
1071 /**
1072  * udev_device_get_syspath:
1073  * @udev_device: udev device
1074  *
1075  * Retrieve the sys path of the udev device. The path is an
1076  * absolute path and starts with the sys mount point.
1077  *
1078  * Returns: the sys path of the udev device
1079  **/
1080 _public_ const char *udev_device_get_syspath(struct udev_device *udev_device)
1081 {
1082         if (udev_device == NULL)
1083                 return NULL;
1084         return udev_device->syspath;
1085 }
1086
1087 /**
1088  * udev_device_get_sysname:
1089  * @udev_device: udev device
1090  *
1091  * Returns: the sys name of the device device
1092  **/
1093 _public_ const char *udev_device_get_sysname(struct udev_device *udev_device)
1094 {
1095         if (udev_device == NULL)
1096                 return NULL;
1097         return udev_device->sysname;
1098 }
1099
1100 /**
1101  * udev_device_get_sysnum:
1102  * @udev_device: udev device
1103  *
1104  * Returns: the trailing number of of the device name
1105  **/
1106 _public_ const char *udev_device_get_sysnum(struct udev_device *udev_device)
1107 {
1108         if (udev_device == NULL)
1109                 return NULL;
1110         return udev_device->sysnum;
1111 }
1112
1113 /**
1114  * udev_device_get_devnode:
1115  * @udev_device: udev device
1116  *
1117  * Retrieve the device node file name belonging to the udev device.
1118  * The path is an absolute path, and starts with the device directory.
1119  *
1120  * Returns: the device node file name of the udev device, or #NULL if no device node exists
1121  **/
1122 _public_ const char *udev_device_get_devnode(struct udev_device *udev_device)
1123 {
1124         if (udev_device == NULL)
1125                 return NULL;
1126         if (udev_device->devnode != NULL)
1127                 return udev_device->devnode;
1128         if (!udev_device->info_loaded)
1129                 udev_device_read_uevent_file(udev_device);
1130         return udev_device->devnode;
1131 }
1132
1133 /**
1134  * udev_device_get_devlinks_list_entry:
1135  * @udev_device: udev device
1136  *
1137  * Retrieve the list of device links pointing to the device file of
1138  * the udev device. The next list entry can be retrieved with
1139  * udev_list_entry_next(), which returns #NULL if no more entries exist.
1140  * The devlink path can be retrieved from the list entry by
1141  * udev_list_entry_get_name(). The path is an absolute path, and starts with
1142  * the device directory.
1143  *
1144  * Returns: the first entry of the device node link list
1145  **/
1146 _public_ struct udev_list_entry *udev_device_get_devlinks_list_entry(struct udev_device *udev_device)
1147 {
1148         if (udev_device == NULL)
1149                 return NULL;
1150         if (!udev_device->info_loaded)
1151                 udev_device_read_db(udev_device, NULL);
1152         return udev_list_get_entry(&udev_device->devlinks_list);
1153 }
1154
1155 void udev_device_cleanup_devlinks_list(struct udev_device *udev_device)
1156 {
1157         udev_device->devlinks_uptodate = false;
1158         udev_list_cleanup(&udev_device->devlinks_list);
1159 }
1160
1161 /**
1162  * udev_device_get_properties_list_entry:
1163  * @udev_device: udev device
1164  *
1165  * Retrieve the list of key/value device properties of the udev
1166  * device. The next list entry can be retrieved with udev_list_entry_next(),
1167  * which returns #NULL if no more entries exist. The property name
1168  * can be retrieved from the list entry by udev_list_get_name(),
1169  * the property value by udev_list_get_value().
1170  *
1171  * Returns: the first entry of the property list
1172  **/
1173 _public_ struct udev_list_entry *udev_device_get_properties_list_entry(struct udev_device *udev_device)
1174 {
1175         if (udev_device == NULL)
1176                 return NULL;
1177         if (!udev_device->info_loaded) {
1178                 udev_device_read_uevent_file(udev_device);
1179                 udev_device_read_db(udev_device, NULL);
1180         }
1181         if (!udev_device->devlinks_uptodate) {
1182                 char symlinks[UTIL_PATH_SIZE];
1183                 struct udev_list_entry *list_entry;
1184
1185                 udev_device->devlinks_uptodate = true;
1186                 list_entry = udev_device_get_devlinks_list_entry(udev_device);
1187                 if (list_entry != NULL) {
1188                         char *s;
1189                         size_t l;
1190
1191                         s = symlinks;
1192                         l = util_strpcpyl(&s, sizeof(symlinks), udev_list_entry_get_name(list_entry), NULL);
1193                         udev_list_entry_foreach(list_entry, udev_list_entry_get_next(list_entry))
1194                                 l = util_strpcpyl(&s, l, " ", udev_list_entry_get_name(list_entry), NULL);
1195                         udev_device_add_property(udev_device, "DEVLINKS", symlinks);
1196                 }
1197         }
1198         if (!udev_device->tags_uptodate) {
1199                 udev_device->tags_uptodate = true;
1200                 if (udev_device_get_tags_list_entry(udev_device) != NULL) {
1201                         char tags[UTIL_PATH_SIZE];
1202                         struct udev_list_entry *list_entry;
1203                         char *s;
1204                         size_t l;
1205
1206                         s = tags;
1207                         l = util_strpcpyl(&s, sizeof(tags), ":", NULL);
1208                         udev_list_entry_foreach(list_entry, udev_device_get_tags_list_entry(udev_device))
1209                                 l = util_strpcpyl(&s, l, udev_list_entry_get_name(list_entry), ":", NULL);
1210                         udev_device_add_property(udev_device, "TAGS", tags);
1211                 }
1212         }
1213         return udev_list_get_entry(&udev_device->properties_list);
1214 }
1215
1216 /**
1217  * udev_device_get_action:
1218  * @udev_device: udev device
1219  *
1220  * This is only valid if the device was received through a monitor. Devices read from
1221  * sys do not have an action string. Usual actions are: add, remove, change, online,
1222  * offline.
1223  *
1224  * Returns: the kernel action value, or #NULL if there is no action value available.
1225  **/
1226 _public_ const char *udev_device_get_action(struct udev_device *udev_device)
1227 {
1228         if (udev_device == NULL)
1229                 return NULL;
1230         return udev_device->action;
1231 }
1232
1233 /**
1234  * udev_device_get_usec_since_initialized:
1235  * @udev_device: udev device
1236  *
1237  * Return the number of microseconds passed since udev set up the
1238  * device for the first time.
1239  *
1240  * This is only implemented for devices with need to store properties
1241  * in the udev database. All other devices return 0 here.
1242  *
1243  * Returns: the number of microseconds since the device was first seen.
1244  **/
1245 _public_ unsigned long long int udev_device_get_usec_since_initialized(struct udev_device *udev_device)
1246 {
1247         unsigned long long now;
1248
1249         if (udev_device == NULL)
1250                 return 0;
1251         if (!udev_device->info_loaded)
1252                 udev_device_read_db(udev_device, NULL);
1253         if (udev_device->usec_initialized == 0)
1254                 return 0;
1255         now = now_usec();
1256         if (now == 0)
1257                 return 0;
1258         return now - udev_device->usec_initialized;
1259 }
1260
1261 unsigned long long udev_device_get_usec_initialized(struct udev_device *udev_device)
1262 {
1263         return udev_device->usec_initialized;
1264 }
1265
1266 void udev_device_set_usec_initialized(struct udev_device *udev_device, unsigned long long usec_initialized)
1267 {
1268         char num[32];
1269
1270         udev_device->usec_initialized = usec_initialized;
1271         snprintf(num, sizeof(num), "%llu", usec_initialized);
1272         udev_device_add_property(udev_device, "USEC_INITIALIZED", num);
1273 }
1274
1275 /**
1276  * udev_device_get_sysattr_value:
1277  * @udev_device: udev device
1278  * @sysattr: attribute name
1279  *
1280  * The retrieved value is cached in the device. Repeated calls will return the same
1281  * value and not open the attribute again.
1282  *
1283  * Returns: the content of a sys attribute file, or #NULL if there is no sys attribute value.
1284  **/
1285 _public_ const char *udev_device_get_sysattr_value(struct udev_device *udev_device, const char *sysattr)
1286 {
1287         struct udev_list_entry *list_entry;
1288         char path[UTIL_PATH_SIZE];
1289         char value[4096];
1290         struct stat statbuf;
1291         int fd;
1292         ssize_t size;
1293         const char *val = NULL;
1294
1295         if (udev_device == NULL)
1296                 return NULL;
1297         if (sysattr == NULL)
1298                 return NULL;
1299
1300         /* look for possibly already cached result */
1301         list_entry = udev_list_get_entry(&udev_device->sysattr_value_list);
1302         list_entry = udev_list_entry_get_by_name(list_entry, sysattr);
1303         if (list_entry != NULL)
1304                 return udev_list_entry_get_value(list_entry);
1305
1306         util_strscpyl(path, sizeof(path), udev_device_get_syspath(udev_device), "/", sysattr, NULL);
1307         if (lstat(path, &statbuf) != 0) {
1308                 udev_list_entry_add(&udev_device->sysattr_value_list, sysattr, NULL);
1309                 goto out;
1310         }
1311
1312         if (S_ISLNK(statbuf.st_mode)) {
1313                 struct udev_device *dev;
1314
1315                 /*
1316                  * Some core links return only the last element of the target path,
1317                  * these are just values, the paths should not be exposed.
1318                  */
1319                 if (strcmp(sysattr, "driver") == 0 ||
1320                     strcmp(sysattr, "subsystem") == 0 ||
1321                     strcmp(sysattr, "module") == 0) {
1322                         if (util_get_sys_core_link_value(udev_device->udev, sysattr,
1323                                                          udev_device->syspath, value, sizeof(value)) < 0)
1324                                 return NULL;
1325                         list_entry = udev_list_entry_add(&udev_device->sysattr_value_list, sysattr, value);
1326                         val = udev_list_entry_get_value(list_entry);
1327                         goto out;
1328                 }
1329
1330                 /* resolve link to a device and return its syspath */
1331                 util_strscpyl(path, sizeof(path), udev_device->syspath, "/", sysattr, NULL);
1332                 dev = udev_device_new_from_syspath(udev_device->udev, path);
1333                 if (dev != NULL) {
1334                         list_entry = udev_list_entry_add(&udev_device->sysattr_value_list, sysattr,
1335                                                          udev_device_get_syspath(dev));
1336                         val = udev_list_entry_get_value(list_entry);
1337                         udev_device_unref(dev);
1338                 }
1339
1340                 goto out;
1341         }
1342
1343         /* skip directories */
1344         if (S_ISDIR(statbuf.st_mode))
1345                 goto out;
1346
1347         /* skip non-readable files */
1348         if ((statbuf.st_mode & S_IRUSR) == 0)
1349                 goto out;
1350
1351         /* read attribute value */
1352         fd = open(path, O_RDONLY|O_CLOEXEC);
1353         if (fd < 0)
1354                 goto out;
1355         size = read(fd, value, sizeof(value));
1356         close(fd);
1357         if (size < 0)
1358                 goto out;
1359         if (size == sizeof(value))
1360                 goto out;
1361
1362         /* got a valid value, store it in cache and return it */
1363         value[size] = '\0';
1364         util_remove_trailing_chars(value, '\n');
1365         list_entry = udev_list_entry_add(&udev_device->sysattr_value_list, sysattr, value);
1366         val = udev_list_entry_get_value(list_entry);
1367 out:
1368         return val;
1369 }
1370
1371 static int udev_device_sysattr_list_read(struct udev_device *udev_device)
1372 {
1373         struct dirent *dent;
1374         DIR *dir;
1375         int num = 0;
1376
1377         if (udev_device == NULL)
1378                 return -1;
1379         if (udev_device->sysattr_list_read)
1380                 return 0;
1381
1382         dir = opendir(udev_device_get_syspath(udev_device));
1383         if (!dir)
1384                 return -1;
1385
1386         for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
1387                 char path[UTIL_PATH_SIZE];
1388                 struct stat statbuf;
1389
1390                 /* only handle symlinks and regular files */
1391                 if (dent->d_type != DT_LNK && dent->d_type != DT_REG)
1392                         continue;
1393
1394                 util_strscpyl(path, sizeof(path), udev_device_get_syspath(udev_device), "/", dent->d_name, NULL);
1395                 if (lstat(path, &statbuf) != 0)
1396                         continue;
1397                 if ((statbuf.st_mode & S_IRUSR) == 0)
1398                         continue;
1399
1400                 udev_list_entry_add(&udev_device->sysattr_list, dent->d_name, NULL);
1401                 num++;
1402         }
1403
1404         closedir(dir);
1405         udev_device->sysattr_list_read = true;
1406
1407         return num;
1408 }
1409
1410 /**
1411  * udev_device_get_sysattr_list_entry:
1412  * @udev_device: udev device
1413  *
1414  * Retrieve the list of available sysattrs, with value being empty;
1415  * This just return all available sysfs attributes for a particular
1416  * device without reading their values.
1417  *
1418  * Returns: the first entry of the property list
1419  **/
1420 _public_ struct udev_list_entry *udev_device_get_sysattr_list_entry(struct udev_device *udev_device)
1421 {
1422         if (!udev_device->sysattr_list_read) {
1423                 int ret;
1424                 ret = udev_device_sysattr_list_read(udev_device);
1425                 if (0 > ret)
1426                         return NULL;
1427         }
1428
1429         return udev_list_get_entry(&udev_device->sysattr_list);
1430 }
1431
1432 int udev_device_set_syspath(struct udev_device *udev_device, const char *syspath)
1433 {
1434         const char *pos;
1435         size_t len;
1436
1437         free(udev_device->syspath);
1438         udev_device->syspath = strdup(syspath);
1439         if (udev_device->syspath ==  NULL)
1440                 return -ENOMEM;
1441         udev_device->devpath = &udev_device->syspath[strlen(udev_get_sys_path(udev_device->udev))];
1442         udev_device_add_property(udev_device, "DEVPATH", udev_device->devpath);
1443
1444         pos = strrchr(udev_device->syspath, '/');
1445         if (pos == NULL)
1446                 return -EINVAL;
1447         udev_device->sysname = strdup(&pos[1]);
1448         if (udev_device->sysname == NULL)
1449                 return -ENOMEM;
1450
1451         /* some devices have '!' in their name, change that to '/' */
1452         len = 0;
1453         while (udev_device->sysname[len] != '\0') {
1454                 if (udev_device->sysname[len] == '!')
1455                         udev_device->sysname[len] = '/';
1456                 len++;
1457         }
1458
1459         /* trailing number */
1460         while (len > 0 && isdigit(udev_device->sysname[--len]))
1461                 udev_device->sysnum = &udev_device->sysname[len];
1462
1463         /* sysname is completely numeric */
1464         if (len == 0)
1465                 udev_device->sysnum = NULL;
1466
1467         return 0;
1468 }
1469
1470 int udev_device_set_devnode(struct udev_device *udev_device, const char *devnode)
1471 {
1472         free(udev_device->devnode);
1473         if (devnode[0] != '/') {
1474                 if (asprintf(&udev_device->devnode, "%s/%s", udev_get_dev_path(udev_device->udev), devnode) < 0)
1475                         udev_device->devnode = NULL;
1476         } else {
1477                 udev_device->devnode = strdup(devnode);
1478         }
1479         if (udev_device->devnode == NULL)
1480                 return -ENOMEM;
1481         udev_device_add_property(udev_device, "DEVNAME", udev_device->devnode);
1482         return 0;
1483 }
1484
1485 int udev_device_add_devlink(struct udev_device *udev_device, const char *devlink, int unique)
1486 {
1487         struct udev_list_entry *list_entry;
1488
1489         udev_device->devlinks_uptodate = false;
1490         list_entry = udev_list_entry_add(&udev_device->devlinks_list, devlink, NULL);
1491         if (list_entry == NULL)
1492                 return -ENOMEM;
1493         if (unique)
1494                 udev_list_entry_set_num(list_entry, true);
1495         return 0;
1496 }
1497
1498 const char *udev_device_get_id_filename(struct udev_device *udev_device)
1499 {
1500         if (udev_device->id_filename == NULL) {
1501                 if (udev_device_get_subsystem(udev_device) == NULL)
1502                         return NULL;
1503
1504                 if (major(udev_device_get_devnum(udev_device)) > 0) {
1505                         /* use dev_t -- b259:131072, c254:0 */
1506                         if (asprintf(&udev_device->id_filename, "%c%u:%u",
1507                                      strcmp(udev_device_get_subsystem(udev_device), "block") == 0 ? 'b' : 'c',
1508                                      major(udev_device_get_devnum(udev_device)),
1509                                      minor(udev_device_get_devnum(udev_device))) < 0)
1510                                 udev_device->id_filename = NULL;
1511                 } else if (udev_device_get_ifindex(udev_device) > 0) {
1512                         /* use netdev ifindex -- n3 */
1513                         if (asprintf(&udev_device->id_filename, "n%u", udev_device_get_ifindex(udev_device)) < 0)
1514                                 udev_device->id_filename = NULL;
1515                 } else {
1516                         /*
1517                          * use $subsys:$syname -- pci:0000:00:1f.2
1518                          * sysname() has '!' translated, get it from devpath
1519                          */
1520                         const char *sysname;
1521                         sysname = strrchr(udev_device->devpath, '/');
1522                         if (sysname == NULL)
1523                                 return NULL;
1524                         sysname = &sysname[1];
1525                         if (asprintf(&udev_device->id_filename, "+%s:%s", udev_device_get_subsystem(udev_device), sysname) < 0)
1526                                 udev_device->id_filename = NULL;
1527                 }
1528         }
1529         return udev_device->id_filename;
1530 }
1531
1532 /**
1533  * udev_device_get_is_initialized:
1534  * @udev_device: udev device
1535  *
1536  * Check if udev has already handled the device and has set up
1537  * device node permissions and context, or has renamed a network
1538  * device.
1539  *
1540  * This is only implemented for devices with a device node
1541  * or network interfaces. All other devices return 1 here.
1542  *
1543  * Returns: 1 if the device is set up. 0 otherwise.
1544  **/
1545 _public_ int udev_device_get_is_initialized(struct udev_device *udev_device)
1546 {
1547         if (!udev_device->info_loaded)
1548                 udev_device_read_db(udev_device, NULL);
1549         return udev_device->is_initialized;
1550 }
1551
1552 void udev_device_set_is_initialized(struct udev_device *udev_device)
1553 {
1554         udev_device->is_initialized = true;
1555 }
1556
1557 int udev_device_add_tag(struct udev_device *udev_device, const char *tag)
1558 {
1559         if (strchr(tag, ':') != NULL || strchr(tag, ' ') != NULL)
1560                 return -EINVAL;
1561         udev_device->tags_uptodate = false;
1562         if (udev_list_entry_add(&udev_device->tags_list, tag, NULL) != NULL)
1563                 return 0;
1564         return -ENOMEM;
1565 }
1566
1567 void udev_device_cleanup_tags_list(struct udev_device *udev_device)
1568 {
1569         udev_device->tags_uptodate = false;
1570         udev_list_cleanup(&udev_device->tags_list);
1571 }
1572
1573 /**
1574  * udev_device_get_tags_list_entry:
1575  * @udev_device: udev device
1576  *
1577  * Retrieve the list of tags attached to the udev device. The next
1578  * list entry can be retrieved with udev_list_entry_next(),
1579  * which returns #NULL if no more entries exist. The tag string
1580  * can be retrieved from the list entry by udev_list_get_name().
1581  *
1582  * Returns: the first entry of the tag list
1583  **/
1584 _public_ struct udev_list_entry *udev_device_get_tags_list_entry(struct udev_device *udev_device)
1585 {
1586         if (udev_device == NULL)
1587                 return NULL;
1588         if (!udev_device->info_loaded)
1589                 udev_device_read_db(udev_device, NULL);
1590         return udev_list_get_entry(&udev_device->tags_list);
1591 }
1592
1593 _public_ int udev_device_has_tag(struct udev_device *udev_device, const char *tag)
1594 {
1595         struct udev_list_entry *list_entry;
1596
1597         if (udev_device == NULL)
1598                 return false;
1599         if (!udev_device->info_loaded)
1600                 udev_device_read_db(udev_device, NULL);
1601         list_entry = udev_device_get_tags_list_entry(udev_device);
1602         if (udev_list_entry_get_by_name(list_entry, tag) != NULL)
1603                 return true;
1604         return false;
1605 }
1606
1607 #define ENVP_SIZE                        128
1608 #define MONITOR_BUF_SIZE                4096
1609 static int update_envp_monitor_buf(struct udev_device *udev_device)
1610 {
1611         struct udev_list_entry *list_entry;
1612         char *s;
1613         size_t l;
1614         unsigned int i;
1615
1616         /* monitor buffer of property strings */
1617         free(udev_device->monitor_buf);
1618         udev_device->monitor_buf_len = 0;
1619         udev_device->monitor_buf = malloc(MONITOR_BUF_SIZE);
1620         if (udev_device->monitor_buf == NULL)
1621                 return -ENOMEM;
1622
1623         /* envp array, strings will point into monitor buffer */
1624         if (udev_device->envp == NULL)
1625                 udev_device->envp = malloc(sizeof(char *) * ENVP_SIZE);
1626         if (udev_device->envp == NULL)
1627                 return -ENOMEM;
1628
1629         i = 0;
1630         s = udev_device->monitor_buf;
1631         l = MONITOR_BUF_SIZE;
1632         udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(udev_device)) {
1633                 const char *key;
1634
1635                 key = udev_list_entry_get_name(list_entry);
1636                 /* skip private variables */
1637                 if (key[0] == '.')
1638                         continue;
1639
1640                 /* add string to envp array */
1641                 udev_device->envp[i++] = s;
1642                 if (i+1 >= ENVP_SIZE)
1643                         return -EINVAL;
1644
1645                 /* add property string to monitor buffer */
1646                 l = util_strpcpyl(&s, l, key, "=", udev_list_entry_get_value(list_entry), NULL);
1647                 if (l == 0)
1648                         return -EINVAL;
1649                 /* advance past the trailing '\0' that util_strpcpyl() guarantees */
1650                 s++;
1651                 l--;
1652         }
1653         udev_device->envp[i] = NULL;
1654         udev_device->monitor_buf_len = s - udev_device->monitor_buf;
1655         udev_device->envp_uptodate = true;
1656         return 0;
1657 }
1658
1659 char **udev_device_get_properties_envp(struct udev_device *udev_device)
1660 {
1661         if (!udev_device->envp_uptodate)
1662                 if (update_envp_monitor_buf(udev_device) != 0)
1663                         return NULL;
1664         return udev_device->envp;
1665 }
1666
1667 ssize_t udev_device_get_properties_monitor_buf(struct udev_device *udev_device, const char **buf)
1668 {
1669         if (!udev_device->envp_uptodate)
1670                 if (update_envp_monitor_buf(udev_device) != 0)
1671                         return -EINVAL;
1672         *buf = udev_device->monitor_buf;
1673         return udev_device->monitor_buf_len;
1674 }
1675
1676 int udev_device_set_action(struct udev_device *udev_device, const char *action)
1677 {
1678         free(udev_device->action);
1679         udev_device->action = strdup(action);
1680         if (udev_device->action == NULL)
1681                 return -ENOMEM;
1682         udev_device_add_property(udev_device, "ACTION", udev_device->action);
1683         return 0;
1684 }
1685
1686 int udev_device_get_devlink_priority(struct udev_device *udev_device)
1687 {
1688         if (!udev_device->info_loaded)
1689                 udev_device_read_db(udev_device, NULL);
1690         return udev_device->devlink_priority;
1691 }
1692
1693 int udev_device_set_devlink_priority(struct udev_device *udev_device, int prio)
1694 {
1695          udev_device->devlink_priority = prio;
1696         return 0;
1697 }
1698
1699 int udev_device_get_watch_handle(struct udev_device *udev_device)
1700 {
1701         if (!udev_device->info_loaded)
1702                 udev_device_read_db(udev_device, NULL);
1703         return udev_device->watch_handle;
1704 }
1705
1706 int udev_device_set_watch_handle(struct udev_device *udev_device, int handle)
1707 {
1708         udev_device->watch_handle = handle;
1709         return 0;
1710 }
1711
1712 bool udev_device_get_db_persist(struct udev_device *udev_device)
1713 {
1714         return udev_device->db_persist;
1715 }
1716
1717 void udev_device_set_db_persist(struct udev_device *udev_device)
1718 {
1719         udev_device->db_persist = true;
1720 }