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