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