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