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