src/libudev/libudev-device.c

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