src/libudev/libudev-device-private.c

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