udev/lib/libudev-device.c

   1 /*
   2  * libudev - interface to udev device information
   3  *
   4  * Copyright (C) 2008 Kay Sievers <kay.sievers@vrfy.org>
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "config.h"
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <stddef.h>
  25 #include <unistd.h>
  26 #include <errno.h>
  27 #include <string.h>
  28 #include <dirent.h>
  29 #include <fcntl.h>
  30 #include <sys/stat.h>
  31
  32 #include "libudev.h"
  33 #include "libudev-private.h"
  34
  35 struct udev_device {
  36         int refcount;
  37         struct udev *udev;
  38         struct udev_device *parent_device;
  39         char *syspath;
  40         const char *devpath;
  41         const char *sysname;
  42         char *devname;
  43         char *subsystem;
  44         struct list_head link_list;
  45         struct list_head env_list;
  46         char *action;
  47         char *driver;
  48         char *devpath_old;
  49         char *physdevpath;
  50         int timeout;
  51         dev_t devnum;
  52         unsigned long long int seqnum;
  53         int num_fake_partitions;
  54         int devlink_priority;
  55         int ignore_remove;
  56         struct list_head attr_list;
  57 };
  58
  59 static size_t devpath_to_db_path(struct udev *udev, const char *devpath, char *filename, size_t len)
  60 {
  61         size_t start;
  62
  63         /* translate to location of db file */
  64         util_strlcpy(filename, udev_get_dev_path(udev), len);
  65         start = util_strlcat(filename, "/.udev/db/", len);
  66         util_strlcat(filename, devpath, len);
  67         return util_path_encode(&filename[start], len - start);
  68 }
  69
  70 static int device_read_db(struct udev_device *udev_device)
  71 {
  72         struct stat stats;
  73         char filename[UTIL_PATH_SIZE];
  74         char line[UTIL_LINE_SIZE];
  75         FILE *f;
  76         int rc = 0;
  77
  78         devpath_to_db_path(udev_device->udev, udev_device->devpath, filename, sizeof(filename));
  79
  80         if (lstat(filename, &stats) != 0) {
  81                 info(udev_device->udev, "no db file to read %s: %s\n", filename, strerror(errno));
  82                 return -1;
  83         }
  84         if ((stats.st_mode & S_IFMT) == S_IFLNK) {
  85                 char target[UTIL_PATH_SIZE];
  86                 int target_len;
  87
  88                 info(udev_device->udev, "found a symlink as db file\n");
  89                 target_len = readlink(filename, target, sizeof(target));
  90                 if (target_len > 0)
  91                         target[target_len] = '\0';
  92                 else {
  93                         info(udev_device->udev, "error reading db link %s: %s\n", filename, strerror(errno));
  94                         return -1;
  95                 }
  96                 dbg(udev_device->udev, "db link points to '%s'\n", target);
  97                 if (asprintf(&udev_device->devname, "%s/%s", udev_get_dev_path(udev_device->udev), target) < 0)
  98                         return -ENOMEM;
  99                 return 0;
 100         }
 101
 102         f = fopen(filename, "r");
 103         if (f == NULL) {
 104                 info(udev_device->udev, "error reading db file %s: %s\n", filename, strerror(errno));
 105                 return -1;
 106         }
 107         while (fgets(line, sizeof(line), f)) {
 108                 ssize_t len;
 109                 const char *val;
 110                 unsigned int maj, min;
 111
 112                 len = strlen(line);
 113                 if (len < 4)
 114                         break;
 115                 line[len-1] = '\0';
 116                 val = &line[2];
 117
 118                 switch(line[0]) {
 119                 case 'N':
 120                         asprintf(&udev_device->devname, "%s/%s", udev_get_dev_path(udev_device->udev), val);
 121                         break;
 122                 case 'M':
 123                         sscanf(val, "%u:%u", &maj, &min);
 124                         device_set_devnum(udev_device, makedev(maj, min));
 125                         break;
 126                 case 'S':
 127                         util_strlcpy(filename, udev_get_dev_path(udev_device->udev), sizeof(filename));
 128                         util_strlcat(filename, "/", sizeof(filename));
 129                         util_strlcat(filename, val, sizeof(filename));
 130                         device_add_devlink(udev_device, filename);
 131                         break;
 132                 case 'L':
 133                         device_set_devlink_priority(udev_device, atoi(val));
 134                         break;
 135                 case 'T':
 136                         device_set_timeout(udev_device,  atoi(val));
 137                         break;
 138                 case 'A':
 139                         device_set_num_fake_partitions(udev_device, atoi(val));
 140                         break;
 141                 case 'R':
 142                         device_set_ignore_remove(udev_device, atoi(val));
 143                         break;
 144                 case 'E':
 145                         device_add_property(udev_device, val);
 146                         break;
 147                 }
 148         }
 149         fclose(f);
 150
 151         return rc;
 152 }
 153
 154 struct udev_device *device_init(struct udev *udev)
 155 {
 156         struct udev_device *udev_device;
 157
 158         if (udev == NULL)
 159                 return NULL;
 160
 161         udev_device = malloc(sizeof(struct udev_device));
 162         if (udev_device == NULL)
 163                 return NULL;
 164         memset(udev_device, 0x00, sizeof(struct udev_device));
 165         udev_device->refcount = 1;
 166         udev_device->udev = udev;
 167         INIT_LIST_HEAD(&udev_device->link_list);
 168         INIT_LIST_HEAD(&udev_device->env_list);
 169         INIT_LIST_HEAD(&udev_device->attr_list);
 170         info(udev_device->udev, "udev_device: %p created\n", udev_device);
 171         return udev_device;
 172 }
 173
 174 /**
 175  * udev_device_new_from_devpath:
 176  * @udev: udev library context
 177  * @devpath: sys device path
 178  *
 179  * Create new udev device, and fill in information from the sysfs
 180  * device and the udev database entry. The devpath must not contain
 181  * the sysfs mount path, and must contain a leading '/'.
 182  *
 183  * The initial refcount is 1, and needs to be decremented to
 184  * release the ressources of the udev device.
 185  *
 186  * Returns: a new udev device, or #NULL, if it does not exist
 187  **/
 188 struct udev_device *udev_device_new_from_devpath(struct udev *udev, const char *devpath)
 189 {
 190         char path[UTIL_PATH_SIZE];
 191         struct stat statbuf;
 192         struct udev_device *udev_device;
 193
 194         if (udev == NULL)
 195                 return NULL;
 196         if (devpath == NULL)
 197                 return NULL;
 198
 199         util_strlcpy(path, udev_get_sys_path(udev), sizeof(path));
 200         util_strlcat(path, devpath, sizeof(path));
 201         util_strlcat(path, "/uevent", sizeof(path));
 202         if (stat(path, &statbuf) != 0) {
 203                 info(udev, "not a device :%s\n", devpath);
 204                 return NULL;
 205         }
 206
 207         udev_device = device_init(udev);
 208         if (udev_device == NULL)
 209                 return NULL;
 210
 211         /* resolve possible symlink to real path */
 212         util_strlcpy(path, devpath, sizeof(path));
 213         util_resolve_sys_link(udev, path, sizeof(path));
 214         device_set_devpath(udev_device, path);
 215         info(udev, "device %p has devpath '%s'\n", udev_device, udev_device_get_devpath(udev_device));
 216
 217         if (device_read_db(udev_device) >= 0)
 218                 info(udev, "device %p filled with udev database data\n", udev_device);
 219         return udev_device;
 220 }
 221
 222 static struct udev_device *device_new_from_parent(struct udev_device *udev_device)
 223 {
 224         struct udev_device *udev_device_parent = NULL;
 225         char path[UTIL_PATH_SIZE];
 226         char *pos;
 227
 228         if (udev_device == NULL)
 229                 return NULL;
 230
 231         util_strlcpy(path, udev_device_get_devpath(udev_device), sizeof(path));
 232         while (1) {
 233                 pos = strrchr(path, '/');
 234                 if (pos == path || pos == NULL)
 235                         break;
 236                 pos[0] = '\0';
 237                 udev_device_parent = udev_device_new_from_devpath(udev_device->udev, path);
 238                 if (udev_device_parent != NULL)
 239                         break;
 240         }
 241         return udev_device_parent;
 242 }
 243
 244 struct udev_device *udev_device_get_parent(struct udev_device *udev_device)
 245 {
 246         if (udev_device->parent_device == NULL)
 247                 udev_device->parent_device = device_new_from_parent(udev_device);
 248         return udev_device->parent_device;
 249 }
 250
 251 /**
 252  * udev_device_get_udev:
 253  * @udev_device: udev device
 254  *
 255  * Retrieve the udev library context the device was created with.
 256  *
 257  * Returns: the udev library context
 258  **/
 259 struct udev *udev_device_get_udev(struct udev_device *udev_device)
 260 {
 261         if (udev_device == NULL)
 262                 return NULL;
 263         return udev_device->udev;
 264 }
 265
 266 /**
 267  * udev_device_ref:
 268  * @udev_device: udev device
 269  *
 270  * Take a reference of a udev device.
 271  *
 272  * Returns: the passed udev device
 273  **/
 274 struct udev_device *udev_device_ref(struct udev_device *udev_device)
 275 {
 276         if (udev_device == NULL)
 277                 return NULL;
 278         udev_device->refcount++;
 279         return udev_device;
 280 }
 281
 282 /**
 283  * udev_device_unref:
 284  * @udev_device: udev device
 285  *
 286  * Drop a reference of a udev device. If the refcount reaches zero,
 287  * the ressources of the device will be released.
 288  *
 289  **/
 290 void udev_device_unref(struct udev_device *udev_device)
 291 {
 292         if (udev_device == NULL)
 293                 return;
 294         udev_device->refcount--;
 295         if (udev_device->refcount > 0)
 296                 return;
 297         if (udev_device->parent_device != NULL)
 298                 udev_device_unref(udev_device->parent_device);
 299         free(udev_device->syspath);
 300         free(udev_device->devname);
 301         free(udev_device->subsystem);
 302         util_name_list_cleanup(udev_device->udev, &udev_device->link_list);
 303         util_name_list_cleanup(udev_device->udev, &udev_device->env_list);
 304         free(udev_device->action);
 305         free(udev_device->driver);
 306         free(udev_device->devpath_old);
 307         free(udev_device->physdevpath);
 308         util_name_list_cleanup(udev_device->udev, &udev_device->attr_list);
 309         info(udev_device->udev, "udev_device: %p released\n", udev_device);
 310         free(udev_device);
 311 }
 312
 313 /**
 314  * udev_device_get_devpath:
 315  * @udev_device: udev device
 316  *
 317  * Retrieve the kernel devpath value of the udev device. The path
 318  * does not contain the sys mount point, and starts with a '/'.
 319  *
 320  * Returns: the devpath of the udev device
 321  **/
 322 const char *udev_device_get_devpath(struct udev_device *udev_device)
 323 {
 324         if (udev_device == NULL)
 325                 return NULL;
 326         return udev_device->devpath;
 327 }
 328
 329 /**
 330  * udev_device_get_syspath:
 331  * @udev_device: udev device
 332  *
 333  * Retrieve the sys path of the udev device. The path is an
 334  * absolute path and starts with the sys mount point.
 335  *
 336  * Returns: the sys path of the udev device
 337  **/
 338 const char *udev_device_get_syspath(struct udev_device *udev_device)
 339 {
 340         if (udev_device == NULL)
 341                 return NULL;
 342         return udev_device->syspath;
 343 }
 344
 345 const char *udev_device_get_sysname(struct udev_device *udev_device)
 346 {
 347         if (udev_device == NULL)
 348                 return NULL;
 349         return udev_device->sysname;
 350 }
 351
 352 /**
 353  * udev_device_get_devname:
 354  * @udev_device: udev device
 355  *
 356  * Retrieve the device node file name belonging to the udev device.
 357  * The path is an absolute path, and starts with the device directory.
 358  *
 359  * Returns: the device node file name of the udev device, or #NULL if no device node exists
 360  **/
 361 const char *udev_device_get_devname(struct udev_device *udev_device)
 362 {
 363         if (udev_device == NULL)
 364                 return NULL;
 365         return udev_device->devname;
 366 }
 367
 368 /**
 369  * udev_device_get_subsystem:
 370  * @udev_device: udev device
 371  *
 372  * Retrieve the subsystem string of the udev device. The string does not
 373  * contain any "/".
 374  *
 375  * Returns: the subsystem name of the udev device, or #NULL if it can not be determined
 376  **/
 377 const char *udev_device_get_subsystem(struct udev_device *udev_device)
 378 {
 379         char subsystem[UTIL_NAME_SIZE];
 380
 381         if (udev_device == NULL)
 382                 return NULL;
 383         if (udev_device->subsystem != NULL)
 384                 return udev_device->subsystem;
 385         if (util_get_sys_subsystem(udev_device->udev, udev_device->devpath, subsystem, sizeof(subsystem)) < 2)
 386                 return NULL;
 387         udev_device->subsystem = strdup(subsystem);
 388         return udev_device->subsystem;
 389 }
 390
 391 /**
 392  * udev_device_get_devlinks:
 393  * @udev_device: udev device
 394  * @cb: function to be called for every device link found
 395  * @data: data to be passed to the function
 396  *
 397  * Retrieve the device links pointing to the device file of the
 398  * udev device. For every device link, the passed function will be
 399  * called with the device link string.
 400  * The path is an absolute path, and starts with the device directory.
 401  * If the function returns 1, remaning device links will be ignored.
 402  *
 403  * Returns: the number of device links passed to the caller, or a negative value on error
 404  **/
 405 int udev_device_get_devlinks(struct udev_device *udev_device,
 406                               int (*cb)(struct udev_device *udev_device, const char *value, void *data),
 407                               void *data)
 408 {
 409         struct util_name_entry *name_loop;
 410         int count = 0;
 411
 412         if (udev_device == NULL)
 413                 return -1;
 414         list_for_each_entry(name_loop, &udev_device->link_list, node) {
 415                 count++;
 416                 if (cb(udev_device, name_loop->name, data) != 0)
 417                         break;
 418         }
 419         return count;
 420 }
 421
 422 /**
 423  * udev_device_get_properties:
 424  * @udev_device: udev device
 425  * @cb: function to be called for every property found
 426  * @data: data to be passed to the function
 427  *
 428  * Retrieve the property key/value pairs belonging to the
 429  * udev device. For every key/value pair, the passed function will be
 430  * called. If the function returns 1, remaning properties will be
 431  * ignored.
 432  *
 433  * Returns: the number of properties passed to the caller, or a negative value on error
 434  **/
 435 int udev_device_get_properties(struct udev_device *udev_device,
 436                                 int (*cb)(struct udev_device *udev_device, const char *key, const char *value, void *data),
 437                                 void *data)
 438 {
 439         struct util_name_entry *name_loop;
 440         int count = 0;
 441
 442         if (udev_device == NULL)
 443                 return -1;
 444         list_for_each_entry(name_loop, &udev_device->env_list, node) {
 445                 char name[UTIL_NAME_SIZE];
 446                 char *val;
 447
 448                 strncpy(name, name_loop->name, sizeof(name));
 449                 val = strchr(name, '=');
 450                 if (val == NULL)
 451                         continue;
 452                 val[0] = '\0';
 453                 val = &val[1];
 454                 count++;
 455                 if (cb(udev_device, name, val, data) != 0)
 456                         break;
 457         }
 458         return count;
 459 }
 460
 461 const char *udev_device_get_driver(struct udev_device *udev_device)
 462 {
 463         char driver[UTIL_NAME_SIZE];
 464
 465         if (udev_device == NULL)
 466                 return NULL;
 467         if (udev_device->driver != NULL)
 468                 return udev_device->driver;
 469         if (util_get_sys_driver(udev_device->udev, udev_device->devpath, driver, sizeof(driver)) < 2)
 470                 return NULL;
 471         udev_device->driver = strdup(driver);
 472         return udev_device->driver;
 473 }
 474
 475 dev_t udev_device_get_devnum(struct udev_device *udev_device)
 476 {
 477         if (udev_device == NULL)
 478                 return makedev(0, 0);
 479         return udev_device->devnum;
 480 }
 481
 482 const char *udev_device_get_action(struct udev_device *udev_device)
 483 {
 484         if (udev_device == NULL)
 485                 return NULL;
 486         return udev_device->action;
 487 }
 488
 489 unsigned long long int udev_device_get_seqnum(struct udev_device *udev_device)
 490 {
 491         if (udev_device == NULL)
 492                 return 0;
 493         return udev_device->seqnum;
 494 }
 495
 496 const char *udev_device_get_attr_value(struct udev_device *udev_device, const char *attr)
 497 {
 498         char path[UTIL_PATH_SIZE];
 499         char value[UTIL_NAME_SIZE];
 500         struct stat statbuf;
 501         int fd;
 502         ssize_t size;
 503         const char *val = NULL;
 504
 505         util_strlcpy(path, udev_device_get_syspath(udev_device), sizeof(path));
 506         util_strlcat(path, "/", sizeof(path));
 507         util_strlcat(path, attr, sizeof(path));
 508
 509         if (lstat(path, &statbuf) != 0) {
 510                 info(udev_device->udev, "stat '%s' failed: %s\n", path, strerror(errno));
 511                 goto out;
 512         }
 513
 514         if (S_ISLNK(statbuf.st_mode)) {
 515                 /* links return the last element of the target path */
 516                 char target[UTIL_NAME_SIZE];
 517                 int len;
 518                 char *pos;
 519
 520                 len = readlink(path, target, sizeof(target));
 521                 if (len > 0) {
 522                         target[len] = '\0';
 523                         pos = strrchr(target, '/');
 524                         if (pos != NULL) {
 525                                 pos = &pos[1];
 526                                 info(udev_device->udev, "cache '%s' with link value '%s'\n", attr, pos);
 527                                 val = util_name_list_add(udev_device->udev, &udev_device->attr_list, attr, pos, 0)->value;
 528                         }
 529                 }
 530                 goto out;
 531         }
 532
 533         /* skip directories */
 534         if (S_ISDIR(statbuf.st_mode))
 535                 goto out;
 536
 537         /* skip non-readable files */
 538         if ((statbuf.st_mode & S_IRUSR) == 0)
 539                 goto out;
 540
 541         /* read attribute value */
 542         fd = open(path, O_RDONLY);
 543         if (fd < 0) {
 544                 info(udev_device->udev, "attribute '%s' can not be opened\n", path);
 545                 goto out;
 546         }
 547         size = read(fd, value, sizeof(value));
 548         close(fd);
 549         if (size < 0)
 550                 goto out;
 551         if (size == sizeof(value))
 552                 goto out;
 553
 554         /* got a valid value, store and return it */
 555         value[size] = '\0';
 556         util_remove_trailing_chars(value, '\n');
 557         info(udev_device->udev, "'%s' has attribute value '%s'\n", path, value);
 558         val = util_name_list_add(udev_device->udev, &udev_device->attr_list, attr, value, 0)->value;
 559 out:
 560         return val;
 561 }
 562 int device_set_devpath(struct udev_device *udev_device, const char *devpath)
 563 {
 564         if (asprintf(&udev_device->syspath, "%s%s", udev_get_sys_path(udev_device->udev), devpath) < 0)
 565                 return -ENOMEM;
 566         udev_device->devpath = &udev_device->syspath[strlen(udev_get_sys_path(udev_device->udev))];
 567         udev_device->sysname = strrchr(udev_device->syspath, '/');
 568         if (udev_device->sysname != NULL)
 569                 udev_device->sysname = &udev_device->sysname[1];
 570         return 0;
 571 }
 572
 573 int device_set_subsystem(struct udev_device *udev_device, const char *subsystem)
 574 {
 575         udev_device->subsystem = strdup(subsystem);
 576         if (udev_device->subsystem == NULL)
 577                 return -1;
 578         return 0;
 579 }
 580
 581 int device_set_devname(struct udev_device *udev_device, const char *devname)
 582 {
 583         udev_device->devname = strdup(devname);
 584         if (udev_device->devname == NULL)
 585                 return -ENOMEM;
 586         return 0;
 587 }
 588
 589 int device_add_devlink(struct udev_device *udev_device, const char *devlink)
 590 {
 591         if (util_name_list_add(udev_device->udev, &udev_device->link_list, devlink, NULL, 0) == NULL)
 592                 return -ENOMEM;
 593         return 0;
 594 }
 595
 596 int device_add_property(struct udev_device *udev_device, const char *property)
 597 {
 598         if (util_name_list_add(udev_device->udev, &udev_device->env_list, property, NULL, 0) == NULL)
 599                 return -ENOMEM;
 600         return 0;
 601 }
 602
 603 int device_set_action(struct udev_device *udev_device, const char *action)
 604 {
 605         udev_device->action = strdup(action);
 606         if (udev_device->action == NULL)
 607                 return -ENOMEM;
 608         return 0;
 609 }
 610
 611 int device_set_driver(struct udev_device *udev_device, const char *driver)
 612 {
 613         udev_device->driver = strdup(driver);
 614         if (udev_device->driver == NULL)
 615                 return -ENOMEM;
 616         return 0;
 617 }
 618
 619 const char *device_get_devpath_old(struct udev_device *udev_device)
 620 {
 621         if (udev_device == NULL)
 622                 return NULL;
 623         return udev_device->devpath_old;
 624 }
 625
 626 int device_set_devpath_old(struct udev_device *udev_device, const char *devpath_old)
 627 {
 628         udev_device->devpath_old = strdup(devpath_old);
 629         if (udev_device->devpath_old == NULL)
 630                 return -ENOMEM;
 631         return 0;
 632 }
 633
 634 const char *device_get_physdevpath(struct udev_device *udev_device)
 635 {
 636         if (udev_device == NULL)
 637                 return NULL;
 638         return udev_device->physdevpath;
 639 }
 640
 641 int device_set_physdevpath(struct udev_device *udev_device, const char *physdevpath)
 642 {
 643         udev_device->physdevpath = strdup(physdevpath);
 644         if (udev_device->physdevpath == NULL)
 645                 return -ENOMEM;
 646         return 0;
 647 }
 648
 649 int device_get_timeout(struct udev_device *udev_device)
 650 {
 651         if (udev_device == NULL)
 652                 return -1;
 653         return udev_device->timeout;
 654 }
 655
 656 int device_set_timeout(struct udev_device *udev_device, int timeout)
 657 {
 658         udev_device->timeout = timeout;
 659         return 0;
 660 }
 661
 662 int device_set_seqnum(struct udev_device *udev_device, unsigned long long int seqnum)
 663 {
 664         udev_device->seqnum = seqnum;
 665         return 0;
 666 }
 667
 668 int device_set_devnum(struct udev_device *udev_device, dev_t devnum)
 669 {
 670         udev_device->devnum = devnum;
 671         return 0;
 672 }
 673
 674 int device_get_num_fake_partitions(struct udev_device *udev_device)
 675 {
 676         if (udev_device == NULL)
 677                 return -1;
 678         return udev_device->num_fake_partitions;
 679 }
 680
 681 int device_set_num_fake_partitions(struct udev_device *udev_device, int num)
 682 {
 683         udev_device->num_fake_partitions = num;
 684         return 0;
 685 }
 686
 687 int device_get_devlink_priority(struct udev_device *udev_device)
 688 {
 689         if (udev_device == NULL)
 690                 return -1;
 691         return udev_device->devlink_priority;
 692 }
 693
 694 int device_set_devlink_priority(struct udev_device *udev_device, int prio)
 695 {
 696          udev_device->devlink_priority = prio;
 697         return 0;
 698 }
 699
 700 int device_get_ignore_remove(struct udev_device *udev_device)
 701 {
 702         if (udev_device == NULL)
 703                 return -1;
 704         return udev_device->ignore_remove;
 705 }
 706
 707 int device_set_ignore_remove(struct udev_device *udev_device, int ignore)
 708 {
 709         udev_device->ignore_remove = ignore;
 710         return 0;
 711 }
 712