src/libudev/libudev-device.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2008-2012 Kay Sievers <kay@vrfy.org>
   5   Copyright 2015 Tom Gundersen <teg@jklm.no>
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <stddef.h>
  24 #include <unistd.h>
  25 #include <stdbool.h>
  26 #include <errno.h>
  27 #include <string.h>
  28 #include <dirent.h>
  29 #include <fcntl.h>
  30 #include <ctype.h>
  31 #include <net/if.h>
  32 #include <sys/stat.h>
  33 #include <sys/ioctl.h>
  34 #include <sys/socket.h>
  35 #include <linux/sockios.h>
  36
  37 #include "sd-device.h"
  38 #include "device-util.h"
  39 #include "device-private.h"
  40
  41 #include "libudev.h"
  42 #include "libudev-private.h"
  43 #include "libudev-device-internal.h"
  44
  45 /**
  46  * SECTION:libudev-device
  47  * @short_description: kernel sys devices
  48  *
  49  * Representation of kernel sys devices. Devices are uniquely identified
  50  * by their syspath, every device has exactly one path in the kernel sys
  51  * filesystem. Devices usually belong to a kernel subsystem, and have
  52  * a unique name inside that subsystem.
  53  */
  54
  55 /**
  56  * udev_device_get_seqnum:
  57  * @udev_device: udev device
  58  *
  59  * This is only valid if the device was received through a monitor. Devices read from
  60  * sys do not have a sequence number.
  61  *
  62  * Returns: the kernel event sequence number, or 0 if there is no sequence number available.
  63  **/
  64 _public_ unsigned long long int udev_device_get_seqnum(struct udev_device *udev_device)
  65 {
  66         const char *seqnum;
  67         unsigned long long ret;
  68         int r;
  69
  70         assert_return_errno(udev_device, 0, EINVAL);
  71
  72         r = sd_device_get_property_value(udev_device->device, "SEQNUM", &seqnum);
  73         if (r == -ENOENT)
  74                 return 0;
  75         else if (r < 0) {
  76                 errno = -r;
  77                 return 0;
  78         }
  79
  80         r = safe_atollu(seqnum, &ret);
  81         if (r < 0) {
  82                 errno = -r;
  83                 return 0;
  84         }
  85
  86         return ret;
  87 }
  88
  89 /**
  90  * udev_device_get_devnum:
  91  * @udev_device: udev device
  92  *
  93  * Get the device major/minor number.
  94  *
  95  * Returns: the dev_t number.
  96  **/
  97 _public_ dev_t udev_device_get_devnum(struct udev_device *udev_device)
  98 {
  99         dev_t devnum;
 100         int r;
 101
 102         assert_return_errno(udev_device, makedev(0, 0), EINVAL);
 103
 104         r = sd_device_get_devnum(udev_device->device, &devnum);
 105         if (r < 0) {
 106                 errno = -r;
 107                 return makedev(0, 0);
 108         }
 109
 110         return devnum;
 111 }
 112
 113 /**
 114  * udev_device_get_driver:
 115  * @udev_device: udev device
 116  *
 117  * Get the kernel driver name.
 118  *
 119  * Returns: the driver name string, or #NULL if there is no driver attached.
 120  **/
 121 _public_ const char *udev_device_get_driver(struct udev_device *udev_device)
 122 {
 123         const char *driver;
 124         int r;
 125
 126         assert_return_errno(udev_device, NULL, EINVAL);
 127
 128         r = sd_device_get_driver(udev_device->device, &driver);
 129         if (r < 0) {
 130                 errno = -r;
 131                 return NULL;
 132         }
 133
 134         return driver;
 135 }
 136
 137 /**
 138  * udev_device_get_devtype:
 139  * @udev_device: udev device
 140  *
 141  * Retrieve the devtype string of the udev device.
 142  *
 143  * Returns: the devtype name of the udev device, or #NULL if it can not be determined
 144  **/
 145 _public_ const char *udev_device_get_devtype(struct udev_device *udev_device)
 146 {
 147         const char *devtype;
 148         int r;
 149
 150         assert_return_errno(udev_device, NULL, EINVAL);
 151
 152         r = sd_device_get_devtype(udev_device->device, &devtype);
 153         if (r < 0) {
 154                 errno = -r;
 155                 return NULL;
 156         }
 157
 158         return devtype;
 159 }
 160
 161 /**
 162  * udev_device_get_subsystem:
 163  * @udev_device: udev device
 164  *
 165  * Retrieve the subsystem string of the udev device. The string does not
 166  * contain any "/".
 167  *
 168  * Returns: the subsystem name of the udev device, or #NULL if it can not be determined
 169  **/
 170 _public_ const char *udev_device_get_subsystem(struct udev_device *udev_device)
 171 {
 172         const char *subsystem;
 173         int r;
 174
 175         assert_return_errno(udev_device, NULL, EINVAL);
 176
 177         r = sd_device_get_subsystem(udev_device->device, &subsystem);
 178         if (r < 0) {
 179                 errno = -r;
 180                 return NULL;
 181         }
 182
 183         return subsystem;
 184 }
 185
 186 /**
 187  * udev_device_get_property_value:
 188  * @udev_device: udev device
 189  * @key: property name
 190  *
 191  * Get the value of a given property.
 192  *
 193  * Returns: the property string, or #NULL if there is no such property.
 194  **/
 195 _public_ const char *udev_device_get_property_value(struct udev_device *udev_device, const char *key)
 196 {
 197         const char *value = NULL;
 198         int r;
 199
 200         assert_return_errno(udev_device && key, NULL, EINVAL);
 201
 202         r = sd_device_get_property_value(udev_device->device, key, &value);
 203         if (r < 0) {
 204                 errno = -r;
 205                 return NULL;
 206         }
 207
 208         return value;
 209 }
 210
 211 struct udev_device *udev_device_new(struct udev *udev) {
 212         struct udev_device *udev_device;
 213
 214         assert_return_errno(udev, NULL, EINVAL);
 215
 216         udev_device = new0(struct udev_device, 1);
 217         if (!udev_device) {
 218                 errno = ENOMEM;
 219                 return NULL;
 220         }
 221         udev_device->refcount = 1;
 222         udev_device->udev = udev;
 223         udev_list_init(udev, &udev_device->properties, true);
 224         udev_list_init(udev, &udev_device->tags, true);
 225         udev_list_init(udev, &udev_device->sysattrs, true);
 226         udev_list_init(udev, &udev_device->devlinks, true);
 227
 228         return udev_device;
 229 }
 230
 231 /**
 232  * udev_device_new_from_syspath:
 233  * @udev: udev library context
 234  * @syspath: sys device path including sys directory
 235  *
 236  * Create new udev device, and fill in information from the sys
 237  * device and the udev database entry. The syspath is the absolute
 238  * path to the device, including the sys mount point.
 239  *
 240  * The initial refcount is 1, and needs to be decremented to
 241  * release the resources of the udev device.
 242  *
 243  * Returns: a new udev device, or #NULL, if it does not exist
 244  **/
 245 _public_ struct udev_device *udev_device_new_from_syspath(struct udev *udev, const char *syspath) {
 246         struct udev_device *udev_device;
 247         int r;
 248
 249         udev_device = udev_device_new(udev);
 250         if (!udev_device)
 251                 return NULL;
 252
 253         r = sd_device_new_from_syspath(&udev_device->device, syspath);
 254         if (r < 0) {
 255                 errno = -r;
 256                 udev_device_unref(udev_device);
 257                 return NULL;
 258         }
 259
 260         return udev_device;
 261 }
 262
 263 /**
 264  * udev_device_new_from_devnum:
 265  * @udev: udev library context
 266  * @type: char or block device
 267  * @devnum: device major/minor number
 268  *
 269  * Create new udev device, and fill in information from the sys
 270  * device and the udev database entry. The device is looked-up
 271  * by its major/minor number and type. Character and block device
 272  * numbers are not unique across the two types.
 273  *
 274  * The initial refcount is 1, and needs to be decremented to
 275  * release the resources of the udev device.
 276  *
 277  * Returns: a new udev device, or #NULL, if it does not exist
 278  **/
 279 _public_ struct udev_device *udev_device_new_from_devnum(struct udev *udev, char type, dev_t devnum)
 280 {
 281         struct udev_device *udev_device;
 282         int r;
 283
 284         udev_device = udev_device_new(udev);
 285         if (!udev_device)
 286                 return NULL;
 287
 288         r = sd_device_new_from_devnum(&udev_device->device, type, devnum);
 289         if (r < 0) {
 290                 errno = -r;
 291                 udev_device_unref(udev_device);
 292                 return NULL;
 293         }
 294
 295         return udev_device;
 296 }
 297
 298 /**
 299  * udev_device_new_from_device_id:
 300  * @udev: udev library context
 301  * @id: text string identifying a kernel device
 302  *
 303  * Create new udev device, and fill in information from the sys
 304  * device and the udev database entry. The device is looked-up
 305  * by a special string:
 306  *   b8:2          - block device major:minor
 307  *   c128:1        - char device major:minor
 308  *   n3            - network device ifindex
 309  *   +sound:card29 - kernel driver core subsystem:device name
 310  *
 311  * The initial refcount is 1, and needs to be decremented to
 312  * release the resources of the udev device.
 313  *
 314  * Returns: a new udev device, or #NULL, if it does not exist
 315  **/
 316 _public_ struct udev_device *udev_device_new_from_device_id(struct udev *udev, const char *id)
 317 {
 318         struct udev_device *udev_device;
 319         int r;
 320
 321         udev_device = udev_device_new(udev);
 322         if (!udev_device)
 323                 return NULL;
 324
 325         r = sd_device_new_from_device_id(&udev_device->device, id);
 326         if (r < 0) {
 327                 errno = -r;
 328                 udev_device_unref(udev_device);
 329                 return NULL;
 330         }
 331
 332         return udev_device;
 333 }
 334
 335 /**
 336  * udev_device_new_from_subsystem_sysname:
 337  * @udev: udev library context
 338  * @subsystem: the subsystem of the device
 339  * @sysname: the name of the device
 340  *
 341  * Create new udev device, and fill in information from the sys device
 342  * and the udev database entry. The device is looked up by the subsystem
 343  * and name string of the device, like "mem" / "zero", or "block" / "sda".
 344  *
 345  * The initial refcount is 1, and needs to be decremented to
 346  * release the resources of the udev device.
 347  *
 348  * Returns: a new udev device, or #NULL, if it does not exist
 349  **/
 350 _public_ struct udev_device *udev_device_new_from_subsystem_sysname(struct udev *udev, const char *subsystem, const char *sysname)
 351 {
 352         struct udev_device *udev_device;
 353         int r;
 354
 355         udev_device = udev_device_new(udev);
 356         if (!udev_device)
 357                 return NULL;
 358
 359         r = sd_device_new_from_subsystem_sysname(&udev_device->device, subsystem, sysname);
 360         if (r < 0) {
 361                 errno = -r;
 362                 udev_device_unref(udev_device);
 363                 return NULL;
 364         }
 365
 366         return udev_device;
 367 }
 368
 369 /**
 370  * udev_device_new_from_environment
 371  * @udev: udev library context
 372  *
 373  * Create new udev device, and fill in information from the
 374  * current process environment. This only works reliable if
 375  * the process is called from a udev rule. It is usually used
 376  * for tools executed from IMPORT= rules.
 377  *
 378  * The initial refcount is 1, and needs to be decremented to
 379  * release the resources of the udev device.
 380  *
 381  * Returns: a new udev device, or #NULL, if it does not exist
 382  **/
 383 _public_ struct udev_device *udev_device_new_from_environment(struct udev *udev)
 384 {
 385         struct udev_device *udev_device;
 386         int r;
 387
 388         udev_device = udev_device_new(udev);
 389         if (!udev_device)
 390                 return NULL;
 391
 392         r = device_new_from_strv(&udev_device->device, environ);
 393         if (r < 0) {
 394                 errno = -r;
 395                 udev_device_unref(udev_device);
 396                 return NULL;
 397         }
 398
 399         return udev_device;
 400 }
 401
 402 static struct udev_device *device_new_from_parent(struct udev_device *child)
 403 {
 404         struct udev_device *parent;
 405         int r;
 406
 407         assert_return_errno(child, NULL, EINVAL);
 408
 409         parent = udev_device_new(child->udev);
 410         if (!parent)
 411                 return NULL;
 412
 413         r = sd_device_get_parent(child->device, &parent->device);
 414         if (r < 0) {
 415                 errno = -r;
 416                 udev_device_unref(parent);
 417                 return NULL;
 418         }
 419
 420         /* the parent is unref'ed with the child, so take a ref from libudev as well */
 421         sd_device_ref(parent->device);
 422
 423         return parent;
 424 }
 425
 426 /**
 427  * udev_device_get_parent:
 428  * @udev_device: the device to start searching from
 429  *
 430  * Find the next parent device, and fill in information from the sys
 431  * device and the udev database entry.
 432  *
 433  * Returned device is not referenced. It is attached to the child
 434  * device, and will be cleaned up when the child device is cleaned up.
 435  *
 436  * It is not necessarily just the upper level directory, empty or not
 437  * recognized sys directories are ignored.
 438  *
 439  * It can be called as many times as needed, without caring about
 440  * references.
 441  *
 442  * Returns: a new udev device, or #NULL, if it no parent exist.
 443  **/
 444 _public_ struct udev_device *udev_device_get_parent(struct udev_device *udev_device)
 445 {
 446         assert_return_errno(udev_device, NULL, EINVAL);
 447
 448         if (!udev_device->parent_set) {
 449                 udev_device->parent_set = true;
 450                 udev_device->parent = device_new_from_parent(udev_device);
 451         }
 452
 453         /* TODO: errno will differ here in case parent == NULL */
 454         return udev_device->parent;
 455 }
 456
 457 /**
 458  * udev_device_get_parent_with_subsystem_devtype:
 459  * @udev_device: udev device to start searching from
 460  * @subsystem: the subsystem of the device
 461  * @devtype: the type (DEVTYPE) of the device
 462  *
 463  * Find the next parent device, with a matching subsystem and devtype
 464  * value, and fill in information from the sys device and the udev
 465  * database entry.
 466  *
 467  * If devtype is #NULL, only subsystem is checked, and any devtype will
 468  * match.
 469  *
 470  * Returned device is not referenced. It is attached to the child
 471  * device, and will be cleaned up when the child device is cleaned up.
 472  *
 473  * It can be called as many times as needed, without caring about
 474  * references.
 475  *
 476  * Returns: a new udev device, or #NULL if no matching parent exists.
 477  **/
 478 _public_ struct udev_device *udev_device_get_parent_with_subsystem_devtype(struct udev_device *udev_device, const char *subsystem, const char *devtype)
 479 {
 480         sd_device *parent;
 481         int r;
 482
 483         assert_return_errno(udev_device, NULL, EINVAL);
 484
 485         /* this relies on the fact that finding the subdevice of a parent or the
 486            parent of a subdevice commute */
 487
 488         /* first find the correct sd_device */
 489         r = sd_device_get_parent_with_subsystem_devtype(udev_device->device, subsystem, devtype, &parent);
 490         if (r < 0) {
 491                 errno = -r;
 492                 return NULL;
 493         }
 494
 495         /* then walk the chain of udev_device parents until the correspanding
 496            one is found */
 497         while ((udev_device = udev_device_get_parent(udev_device))) {
 498                 if (udev_device->device == parent)
 499                         return udev_device;
 500         }
 501
 502         errno = ENOENT;
 503         return NULL;
 504 }
 505
 506 /**
 507  * udev_device_get_udev:
 508  * @udev_device: udev device
 509  *
 510  * Retrieve the udev library context the device was created with.
 511  *
 512  * Returns: the udev library context
 513  **/
 514 _public_ struct udev *udev_device_get_udev(struct udev_device *udev_device)
 515 {
 516         assert_return_errno(udev_device, NULL, EINVAL);
 517
 518         return udev_device->udev;
 519 }
 520
 521 /**
 522  * udev_device_ref:
 523  * @udev_device: udev device
 524  *
 525  * Take a reference of a udev device.
 526  *
 527  * Returns: the passed udev device
 528  **/
 529 _public_ struct udev_device *udev_device_ref(struct udev_device *udev_device)
 530 {
 531         if (udev_device)
 532                 udev_device->refcount++;
 533
 534         return udev_device;
 535 }
 536
 537 /**
 538  * udev_device_unref:
 539  * @udev_device: udev device
 540  *
 541  * Drop a reference of a udev device. If the refcount reaches zero,
 542  * the resources of the device will be released.
 543  *
 544  * Returns: #NULL
 545  **/
 546 _public_ struct udev_device *udev_device_unref(struct udev_device *udev_device)
 547 {
 548         if (udev_device && (-- udev_device->refcount) == 0) {
 549                 sd_device_unref(udev_device->device);
 550                 udev_device_unref(udev_device->parent);
 551
 552                 udev_list_cleanup(&udev_device->properties);
 553                 udev_list_cleanup(&udev_device->sysattrs);
 554                 udev_list_cleanup(&udev_device->tags);
 555                 udev_list_cleanup(&udev_device->devlinks);
 556
 557                 free(udev_device);
 558         }
 559
 560         return NULL;
 561 }
 562
 563 /**
 564  * udev_device_get_devpath:
 565  * @udev_device: udev device
 566  *
 567  * Retrieve the kernel devpath value of the udev device. The path
 568  * does not contain the sys mount point, and starts with a '/'.
 569  *
 570  * Returns: the devpath of the udev device
 571  **/
 572 _public_ const char *udev_device_get_devpath(struct udev_device *udev_device)
 573 {
 574         const char *devpath;
 575         int r;
 576
 577         assert_return_errno(udev_device, NULL, EINVAL);
 578
 579         r = sd_device_get_devpath(udev_device->device, &devpath);
 580         if (r < 0) {
 581                 errno = -r;
 582                 return NULL;
 583         }
 584
 585         return devpath;
 586 }
 587
 588 /**
 589  * udev_device_get_syspath:
 590  * @udev_device: udev device
 591  *
 592  * Retrieve the sys path of the udev device. The path is an
 593  * absolute path and starts with the sys mount point.
 594  *
 595  * Returns: the sys path of the udev device
 596  **/
 597 _public_ const char *udev_device_get_syspath(struct udev_device *udev_device)
 598 {
 599         const char *syspath;
 600         int r;
 601
 602         assert_return_errno(udev_device, NULL, EINVAL);
 603
 604         r = sd_device_get_syspath(udev_device->device, &syspath);
 605         if (r < 0) {
 606                 errno = -r;
 607                 return NULL;
 608         }
 609
 610         return syspath;
 611 }
 612
 613 /**
 614  * udev_device_get_sysname:
 615  * @udev_device: udev device
 616  *
 617  * Get the kernel device name in /sys.
 618  *
 619  * Returns: the name string of the device device
 620  **/
 621 _public_ const char *udev_device_get_sysname(struct udev_device *udev_device)
 622 {
 623         const char *sysname;
 624         int r;
 625
 626         assert_return_errno(udev_device, NULL, EINVAL);
 627
 628         r = sd_device_get_sysname(udev_device->device, &sysname);
 629         if (r < 0) {
 630                 errno = -r;
 631                 return NULL;
 632         }
 633
 634         return sysname;
 635 }
 636
 637 /**
 638  * udev_device_get_sysnum:
 639  * @udev_device: udev device
 640  *
 641  * Get the instance number of the device.
 642  *
 643  * Returns: the trailing number string of the device name
 644  **/
 645 _public_ const char *udev_device_get_sysnum(struct udev_device *udev_device)
 646 {
 647         const char *sysnum;
 648         int r;
 649
 650         assert_return_errno(udev_device, NULL, EINVAL);
 651
 652         r = sd_device_get_sysnum(udev_device->device, &sysnum);
 653         if (r < 0) {
 654                 errno = -r;
 655                 return NULL;
 656         }
 657
 658         return sysnum;
 659 }
 660
 661 /**
 662  * udev_device_get_devnode:
 663  * @udev_device: udev device
 664  *
 665  * Retrieve the device node file name belonging to the udev device.
 666  * The path is an absolute path, and starts with the device directory.
 667  *
 668  * Returns: the device node file name of the udev device, or #NULL if no device node exists
 669  **/
 670 _public_ const char *udev_device_get_devnode(struct udev_device *udev_device)
 671 {
 672         const char *devnode;
 673         int r;
 674
 675         assert_return_errno(udev_device, NULL, EINVAL);
 676
 677         r = sd_device_get_devname(udev_device->device, &devnode);
 678         if (r < 0) {
 679                 errno = -r;
 680                 return NULL;
 681         }
 682
 683         return devnode;
 684 }
 685
 686 /**
 687  * udev_device_get_devlinks_list_entry:
 688  * @udev_device: udev device
 689  *
 690  * Retrieve the list of device links pointing to the device file of
 691  * the udev device. The next list entry can be retrieved with
 692  * udev_list_entry_get_next(), which returns #NULL if no more entries exist.
 693  * The devlink path can be retrieved from the list entry by
 694  * udev_list_entry_get_name(). The path is an absolute path, and starts with
 695  * the device directory.
 696  *
 697  * Returns: the first entry of the device node link list
 698  **/
 699 _public_ struct udev_list_entry *udev_device_get_devlinks_list_entry(struct udev_device *udev_device)
 700 {
 701         assert_return_errno(udev_device, NULL, EINVAL);
 702
 703         if (device_get_devlinks_generation(udev_device->device) != udev_device->devlinks_generation ||
 704             !udev_device->devlinks_read) {
 705                 const char *devlink;
 706
 707                 udev_list_cleanup(&udev_device->devlinks);
 708
 709                 FOREACH_DEVICE_DEVLINK(udev_device->device, devlink)
 710                         udev_list_entry_add(&udev_device->devlinks, devlink, NULL);
 711
 712                 udev_device->devlinks_read = true;
 713                 udev_device->devlinks_generation = device_get_devlinks_generation(udev_device->device);
 714         }
 715
 716         return udev_list_get_entry(&udev_device->devlinks);
 717 }
 718
 719 /**
 720  * udev_device_get_event_properties_entry:
 721  * @udev_device: udev device
 722  *
 723  * Retrieve the list of key/value device properties of the udev
 724  * device. The next list entry can be retrieved with udev_list_entry_get_next(),
 725  * which returns #NULL if no more entries exist. The property name
 726  * can be retrieved from the list entry by udev_list_entry_get_name(),
 727  * the property value by udev_list_entry_get_value().
 728  *
 729  * Returns: the first entry of the property list
 730  **/
 731 _public_ struct udev_list_entry *udev_device_get_properties_list_entry(struct udev_device *udev_device)
 732 {
 733         assert_return_errno(udev_device, NULL, EINVAL);
 734
 735         if (device_get_properties_generation(udev_device->device) != udev_device->properties_generation ||
 736             !udev_device->properties_read) {
 737                 const char *key, *value;
 738
 739                 udev_list_cleanup(&udev_device->properties);
 740
 741                 FOREACH_DEVICE_PROPERTY(udev_device->device, key, value)
 742                         udev_list_entry_add(&udev_device->properties, key, value);
 743
 744                 udev_device->properties_read = true;
 745                 udev_device->properties_generation = device_get_properties_generation(udev_device->device);
 746         }
 747
 748         return udev_list_get_entry(&udev_device->properties);
 749 }
 750
 751 /**
 752  * udev_device_get_action:
 753  * @udev_device: udev device
 754  *
 755  * This is only valid if the device was received through a monitor. Devices read from
 756  * sys do not have an action string. Usual actions are: add, remove, change, online,
 757  * offline.
 758  *
 759  * Returns: the kernel action value, or #NULL if there is no action value available.
 760  **/
 761 _public_ const char *udev_device_get_action(struct udev_device *udev_device) {
 762         const char *action = NULL;
 763         int r;
 764
 765         assert_return_errno(udev_device, NULL, EINVAL);
 766
 767         r = sd_device_get_property_value(udev_device->device, "ACTION", &action);
 768         if (r < 0 && r != -ENOENT) {
 769                 errno = -r;
 770                 return NULL;
 771         }
 772
 773         return action;
 774 }
 775
 776 /**
 777  * udev_device_get_usec_since_initialized:
 778  * @udev_device: udev device
 779  *
 780  * Return the number of microseconds passed since udev set up the
 781  * device for the first time.
 782  *
 783  * This is only implemented for devices with need to store properties
 784  * in the udev database. All other devices return 0 here.
 785  *
 786  * Returns: the number of microseconds since the device was first seen.
 787  **/
 788 _public_ unsigned long long int udev_device_get_usec_since_initialized(struct udev_device *udev_device)
 789 {
 790         usec_t ts;
 791         int r;
 792
 793         assert_return(udev_device, -EINVAL);
 794
 795         r = sd_device_get_usec_since_initialized(udev_device->device, &ts);
 796         if (r < 0) {
 797                 errno = EINVAL;
 798                 return 0;
 799         }
 800
 801         return ts;
 802 }
 803
 804 /**
 805  * udev_device_get_sysattr_value:
 806  * @udev_device: udev device
 807  * @sysattr: attribute name
 808  *
 809  * The retrieved value is cached in the device. Repeated calls will return the same
 810  * value and not open the attribute again.
 811  *
 812  * Returns: the content of a sys attribute file, or #NULL if there is no sys attribute value.
 813  **/
 814 _public_ const char *udev_device_get_sysattr_value(struct udev_device *udev_device, const char *sysattr)
 815 {
 816         const char *value;
 817         int r;
 818
 819         assert_return_errno(udev_device, NULL, EINVAL);
 820
 821         r = sd_device_get_sysattr_value(udev_device->device, sysattr, &value);
 822         if (r < 0) {
 823                 errno = -r;
 824                 return NULL;
 825         }
 826
 827         return value;
 828 }
 829
 830 /**
 831  * udev_device_set_sysattr_value:
 832  * @udev_device: udev device
 833  * @sysattr: attribute name
 834  * @value: new value to be set
 835  *
 836  * Update the contents of the sys attribute and the cached value of the device.
 837  *
 838  * Returns: Negative error code on failure or 0 on success.
 839  **/
 840 _public_ int udev_device_set_sysattr_value(struct udev_device *udev_device, const char *sysattr, char *value)
 841 {
 842         int r;
 843
 844         assert_return(udev_device, -EINVAL);
 845
 846         r = sd_device_set_sysattr_value(udev_device->device, sysattr, value);
 847         if (r < 0)
 848                 return r;
 849
 850         return 0;
 851 }
 852
 853 /**
 854  * udev_device_get_sysattr_list_entry:
 855  * @udev_device: udev device
 856  *
 857  * Retrieve the list of available sysattrs, with value being empty;
 858  * This just return all available sysfs attributes for a particular
 859  * device without reading their values.
 860  *
 861  * Returns: the first entry of the property list
 862  **/
 863 _public_ struct udev_list_entry *udev_device_get_sysattr_list_entry(struct udev_device *udev_device)
 864 {
 865         assert_return_errno(udev_device, NULL, EINVAL);
 866
 867         if (!udev_device->sysattrs_read) {
 868                 const char *sysattr;
 869
 870                 udev_list_cleanup(&udev_device->sysattrs);
 871
 872                 FOREACH_DEVICE_SYSATTR(udev_device->device, sysattr)
 873                         udev_list_entry_add(&udev_device->properties, sysattr, NULL);
 874
 875                 udev_device->sysattrs_read = true;
 876         }
 877
 878         return udev_list_get_entry(&udev_device->sysattrs);
 879 }
 880
 881 /**
 882  * udev_device_get_is_initialized:
 883  * @udev_device: udev device
 884  *
 885  * Check if udev has already handled the device and has set up
 886  * device node permissions and context, or has renamed a network
 887  * device.
 888  *
 889  * This is only implemented for devices with a device node
 890  * or network interfaces. All other devices return 1 here.
 891  *
 892  * Returns: 1 if the device is set up. 0 otherwise.
 893  **/
 894 _public_ int udev_device_get_is_initialized(struct udev_device *udev_device)
 895 {
 896         int r, initialized;
 897
 898         assert_return(udev_device, -EINVAL);
 899
 900         r = sd_device_get_is_initialized(udev_device->device, &initialized);
 901         if (r < 0) {
 902                 errno = -r;
 903
 904                 return 0;
 905         }
 906
 907         return initialized;
 908 }
 909
 910 /**
 911  * udev_device_get_tags_list_entry:
 912  * @udev_device: udev device
 913  *
 914  * Retrieve the list of tags attached to the udev device. The next
 915  * list entry can be retrieved with udev_list_entry_get_next(),
 916  * which returns #NULL if no more entries exist. The tag string
 917  * can be retrieved from the list entry by udev_list_entry_get_name().
 918  *
 919  * Returns: the first entry of the tag list
 920  **/
 921 _public_ struct udev_list_entry *udev_device_get_tags_list_entry(struct udev_device *udev_device)
 922 {
 923         assert_return_errno(udev_device, NULL, EINVAL);
 924
 925         if (device_get_tags_generation(udev_device->device) != udev_device->tags_generation ||
 926             !udev_device->tags_read) {
 927                 const char *tag;
 928
 929                 udev_list_cleanup(&udev_device->tags);
 930
 931                 FOREACH_DEVICE_TAG(udev_device->device, tag)
 932                         udev_list_entry_add(&udev_device->tags, tag, NULL);
 933
 934                 udev_device->tags_read = true;
 935                 udev_device->tags_generation = device_get_tags_generation(udev_device->device);
 936         }
 937
 938         return udev_list_get_entry(&udev_device->tags);
 939 }
 940
 941 /**
 942  * udev_device_has_tag:
 943  * @udev_device: udev device
 944  * @tag: tag name
 945  *
 946  * Check if a given device has a certain tag associated.
 947  *
 948  * Returns: 1 if the tag is found. 0 otherwise.
 949  **/
 950 _public_ int udev_device_has_tag(struct udev_device *udev_device, const char *tag)
 951 {
 952         assert_return(udev_device, 0);
 953
 954         return sd_device_has_tag(udev_device->device, tag);
 955 }