src/libudev/libudev-device-private.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include "libudev.h"
   4
   5 #include "device-private.h"
   6 #include "libudev-device-internal.h"
   7 #include "libudev-private.h"
   8
   9 int udev_device_tag_index(struct udev_device *udev_device, struct udev_device *udev_device_old, bool add) {
  10         sd_device *device_old = NULL;
  11         int r;
  12
  13         assert(udev_device);
  14
  15         if (udev_device_old)
  16                 device_old = udev_device_old->device;
  17
  18         r = device_tag_index(udev_device->device, device_old, add);
  19         if (r < 0)
  20                 return r;
  21
  22         return 0;
  23 }
  24
  25 int udev_device_update_db(struct udev_device *udev_device) {
  26         int r;
  27
  28         assert(udev_device);
  29
  30         r = device_update_db(udev_device->device);
  31         if (r < 0)
  32                 return r;
  33
  34         return 0;
  35 }
  36
  37 int udev_device_delete_db(struct udev_device *udev_device) {
  38         int r;
  39
  40         assert(udev_device);
  41
  42         r = device_delete_db(udev_device->device);
  43         if (r < 0)
  44                 return r;
  45
  46         return 0;
  47 }
  48
  49 int udev_device_get_ifindex(struct udev_device *udev_device) {
  50         int r, ifindex;
  51
  52         assert(udev_device);
  53
  54         r = sd_device_get_ifindex(udev_device->device, &ifindex);
  55         if (r < 0)
  56                 return r;
  57
  58         return ifindex;
  59 }
  60
  61 const char *udev_device_get_devpath_old(struct udev_device *udev_device) {
  62         const char *devpath_old = NULL;
  63         int r;
  64
  65         assert(udev_device);
  66
  67         r = sd_device_get_property_value(udev_device->device, "DEVPATH_OLD", &devpath_old);
  68         if (r < 0 && r != -ENOENT) {
  69                 errno = -r;
  70                 return NULL;
  71         }
  72
  73         return devpath_old;
  74 }
  75
  76 mode_t udev_device_get_devnode_mode(struct udev_device *udev_device) {
  77         mode_t mode;
  78         int r;
  79
  80         assert(udev_device);
  81
  82         r = device_get_devnode_mode(udev_device->device, &mode);
  83         if (r < 0) {
  84                 errno = -r;
  85                 return 0;
  86         }
  87
  88         return mode;
  89 }
  90
  91 uid_t udev_device_get_devnode_uid(struct udev_device *udev_device) {
  92         uid_t uid;
  93         int r;
  94
  95         assert(udev_device);
  96
  97         r = device_get_devnode_uid(udev_device->device, &uid);
  98         if (r < 0) {
  99                 errno = -r;
 100                 return 0;
 101         }
 102
 103         return uid;
 104 }
 105
 106 gid_t udev_device_get_devnode_gid(struct udev_device *udev_device) {
 107         gid_t gid;
 108         int r;
 109
 110         assert(udev_device);
 111
 112         r = device_get_devnode_gid(udev_device->device, &gid);
 113         if (r < 0) {
 114                 errno = -r;
 115                 return 0;
 116         }
 117
 118         return gid;
 119 }
 120
 121 void udev_device_ensure_usec_initialized(struct udev_device *udev_device, struct udev_device *udev_device_old) {
 122         assert(udev_device);
 123
 124         device_ensure_usec_initialized(udev_device->device,
 125                                        udev_device_old ? udev_device_old->device : NULL);
 126 }
 127
 128 char **udev_device_get_properties_envp(struct udev_device *udev_device) {
 129         char **envp;
 130         int r;
 131
 132         assert(udev_device);
 133
 134         r = device_get_properties_strv(udev_device->device, &envp);
 135         if (r < 0) {
 136                 errno = -r;
 137                 return NULL;
 138         }
 139
 140         return envp;
 141 }
 142
 143 ssize_t udev_device_get_properties_monitor_buf(struct udev_device *udev_device, const char **buf) {
 144         const char *nulstr;
 145         size_t len;
 146         int r;
 147
 148         assert(udev_device);
 149         assert(buf);
 150
 151         r = device_get_properties_nulstr(udev_device->device, (const uint8_t **)&nulstr, &len);
 152         if (r < 0)
 153                 return r;
 154
 155         *buf = nulstr;
 156
 157         return len;
 158 }
 159
 160 int udev_device_get_devlink_priority(struct udev_device *udev_device) {
 161         int priority, r;
 162
 163         assert(udev_device);
 164
 165         r = device_get_devlink_priority(udev_device->device, &priority);
 166         if (r < 0)
 167                 return r;
 168
 169         return priority;
 170 }
 171
 172 int udev_device_get_watch_handle(struct udev_device *udev_device) {
 173         int handle, r;
 174
 175         assert(udev_device);
 176
 177         r = device_get_watch_handle(udev_device->device, &handle);
 178         if (r < 0)
 179                 return r;
 180
 181         return handle;
 182 }
 183
 184 void udev_device_set_is_initialized(struct udev_device *udev_device) {
 185         assert(udev_device);
 186
 187         device_set_is_initialized(udev_device->device);
 188 }
 189
 190 int udev_device_rename(struct udev_device *udev_device, const char *name) {
 191         int r;
 192
 193         assert(udev_device);
 194
 195         r = device_rename(udev_device->device, name);
 196         if (r < 0)
 197                 return r;
 198
 199         return 0;
 200 }
 201
 202 struct udev_device *udev_device_shallow_clone(struct udev_device *old_device) {
 203         _cleanup_(sd_device_unrefp) sd_device *device = NULL;
 204         int r;
 205
 206         assert(old_device);
 207
 208         r = device_shallow_clone(old_device->device, &device);
 209         if (r < 0) {
 210                 errno = -r;
 211                 return NULL;
 212         }
 213
 214         return udev_device_new(old_device->udev, device);
 215 }
 216
 217 struct udev_device *udev_device_clone_with_db(struct udev_device *udev_device_old) {
 218         _cleanup_(sd_device_unrefp) sd_device *device = NULL;
 219         int r;
 220
 221         assert(udev_device_old);
 222
 223         r = device_clone_with_db(udev_device_old->device, &device);
 224         if (r < 0) {
 225                 errno = -r;
 226                 return NULL;
 227         }
 228
 229         return udev_device_new(udev_device_old->udev, device);
 230 }
 231
 232 struct udev_device *udev_device_new_from_nulstr(struct udev *udev, char *nulstr, ssize_t buflen) {
 233         _cleanup_(sd_device_unrefp) sd_device *device = NULL;
 234         int r;
 235
 236         r = device_new_from_nulstr(&device, (uint8_t*)nulstr, buflen);
 237         if (r < 0) {
 238                 errno = -r;
 239                 return NULL;
 240         }
 241
 242         return udev_device_new(udev, device);
 243 }
 244
 245 struct udev_device *udev_device_new_from_synthetic_event(struct udev *udev, const char *syspath, const char *action) {
 246         _cleanup_(sd_device_unrefp) sd_device *device = NULL;
 247         int r;
 248
 249         r = device_new_from_synthetic_event(&device, syspath, action);
 250         if (r < 0) {
 251                 errno = -r;
 252                 return NULL;
 253         }
 254
 255         return udev_device_new(udev, device);
 256 }
 257
 258 int udev_device_copy_properties(struct udev_device *udev_device_dst, struct udev_device *udev_device_src) {
 259         int r;
 260
 261         assert(udev_device_dst);
 262         assert(udev_device_src);
 263
 264         r = device_copy_properties(udev_device_dst->device, udev_device_src->device);
 265         if (r < 0)
 266                 return r;
 267
 268         return 0;
 269 }
 270
 271 const char *udev_device_get_id_filename(struct udev_device *udev_device) {
 272         const char *filename;
 273         int r;
 274
 275         assert(udev_device);
 276
 277         r = device_get_id_filename(udev_device->device, &filename);
 278         if (r < 0) {
 279                 errno = -r;
 280                 return NULL;
 281         }
 282
 283         return filename;
 284 }
 285
 286 int udev_device_set_watch_handle(struct udev_device *udev_device, int handle) {
 287
 288         assert(udev_device);
 289
 290         device_set_watch_handle(udev_device->device, handle);
 291
 292         return 0;
 293 }
 294
 295 void udev_device_set_db_persist(struct udev_device *udev_device) {
 296         assert(udev_device);
 297
 298         device_set_db_persist(udev_device->device);
 299 }
 300
 301 int udev_device_set_devlink_priority(struct udev_device *udev_device, int priority) {
 302         assert(udev_device);
 303
 304         device_set_devlink_priority(udev_device->device, priority);
 305
 306         return 0;
 307 }
 308
 309 int udev_device_add_devlink(struct udev_device *udev_device, const char *devlink) {
 310         int r;
 311
 312         assert(udev_device);
 313
 314         r = device_add_devlink(udev_device->device, devlink);
 315         if (r < 0)
 316                 return r;
 317
 318         return 0;
 319 }
 320
 321 int udev_device_add_property(struct udev_device *udev_device, const char *property, const char *value) {
 322         int r;
 323
 324         assert(udev_device);
 325
 326         r = device_add_property(udev_device->device, property, value);
 327         if (r < 0)
 328                 return r;
 329
 330         return 0;
 331 }
 332
 333 int udev_device_add_tag(struct udev_device *udev_device, const char *tag) {
 334         int r;
 335
 336         assert(udev_device);
 337
 338         r = device_add_tag(udev_device->device, tag);
 339         if (r < 0)
 340                 return r;
 341
 342         return 0;
 343 }
 344
 345 void udev_device_remove_tag(struct udev_device *udev_device, const char *tag) {
 346         assert(udev_device);
 347
 348         device_remove_tag(udev_device->device, tag);
 349 }
 350
 351 void udev_device_cleanup_tags_list(struct udev_device *udev_device) {
 352         assert(udev_device);
 353
 354         device_cleanup_tags(udev_device->device);
 355 }
 356
 357 void udev_device_cleanup_devlinks_list(struct udev_device *udev_device) {
 358         assert(udev_device);
 359
 360         device_cleanup_devlinks(udev_device->device);
 361 }
 362
 363 void udev_device_set_info_loaded(struct udev_device *udev_device) {
 364         assert(udev_device);
 365
 366         device_seal(udev_device->device);
 367 }
 368
 369 void udev_device_read_db(struct udev_device *udev_device) {
 370         assert(udev_device);
 371
 372         device_read_db_force(udev_device->device);
 373 }