udevdb.c

   1 /*
   2  * udevdb.c
   3  *
   4  * Userspace devfs
   5  *
   6  * Copyright (C) 2003 Greg Kroah-Hartman <greg@kroah.com>
   7  * Copyright (C) 2003 IBM Corp.
   8  *
   9  *      This program is free software; you can redistribute it and/or modify it
  10  *      under the terms of the GNU General Public License as published by the
  11  *      Free Software Foundation version 2 of the License.
  12  *
  13  *      This program is distributed in the hope that it will be useful, but
  14  *      WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  *      General Public License for more details.
  17  *
  18  *      You should have received a copy of the GNU General Public License along
  19  *      with this program; if not, write to the Free Software Foundation, Inc.,
  20  *      675 Mass Ave, Cambridge, MA 02139, USA.
  21  *
  22  */
  23
  24 /*
  25  * udev database library
  26  */
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <fcntl.h>
  30 #include <string.h>
  31 #include <sys/stat.h>
  32 #include <errno.h>
  33 #include <signal.h>
  34
  35 #include "udev_version.h"
  36 #include "udev.h"
  37 #include "namedev.h"
  38 #include "udevdb.h"
  39 #include "tdb/tdb.h"
  40
  41 static TDB_CONTEXT *udevdb;
  42
  43 /**
  44  * busdb_record - bus and id are keys to look up name of device
  45  */
  46 struct busdb_record {
  47         char name[NAME_SIZE];
  48 };
  49
  50 /**
  51  * classdb_record - class name and class device name used as keys to find
  52  *      device name.
  53  */
  54 struct classdb_record {
  55         char name[NAME_SIZE];
  56 };
  57
  58 /**
  59  * namedb_record - device name is key, remaining udevice info stored here.
  60  */
  61 struct namedb_record {
  62         char sysfs_path[PATH_SIZE];
  63         char class_dev_name[NAME_SIZE];
  64         char class_name[NAME_SIZE];
  65         char bus[BUS_SIZE];
  66         char id[ID_SIZE];
  67         char driver[NAME_SIZE];
  68         char type;
  69         int major;
  70         int minor;
  71         int mode;
  72 };
  73
  74 /**
  75  * udevdb_close: close udev database
  76  */
  77 static void udevdb_close(void)
  78 {
  79         if (udevdb != NULL) {
  80                 tdb_close(udevdb);
  81                 udevdb = NULL;
  82         }
  83 }
  84
  85 /**
  86  * udevdb_open: opens udev's database
  87  * @method: database can either be in memory - UDEVDB_INTERNAL - or
  88  *      written to a file with UDEVDB_DEFAULT.
  89  */
  90 static int udevdb_open(int method)
  91 {
  92         udevdb = tdb_open(UDEV_CONFIG_DIR UDEV_DB, 0, method, O_RDWR | O_CREAT, 0644);
  93         if (udevdb == NULL) {
  94                 if (method == UDEVDB_INTERNAL)
  95                         dbg("Unable to initialize in-memory database");
  96                 else
  97                         dbg("Unable to initialize database at %s", UDEV_CONFIG_DIR UDEV_DB);
  98                 return -EINVAL;
  99         }
 100         return 0;
 101 }
 102
 103 /**
 104  * busdb_fetch
 105  */
 106 static struct busdb_record *busdb_fetch(const char *bus, const char *id)
 107 {
 108         TDB_DATA key, data;
 109         char keystr[BUS_SIZE+ID_SIZE+2];
 110         struct busdb_record *rec = NULL;
 111
 112         if (bus == NULL || id == NULL)
 113                 return NULL;
 114         if (strlen(bus) >= BUS_SIZE || strlen(id) >= ID_SIZE)
 115                 return NULL;
 116
 117         memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
 118         strcpy(keystr, bus);
 119         strcat(keystr, UDEVDB_DEL);
 120         strcat(keystr, id);
 121
 122         key.dptr = (void *)keystr;
 123         key.dsize = strlen(keystr) + 1;
 124
 125         data = tdb_fetch(udevdb, key);
 126         if (data.dptr == NULL || data.dsize == 0)
 127                 return NULL;
 128
 129         rec = (struct busdb_record *)malloc(sizeof(struct busdb_record));
 130         if (rec == NULL) {
 131                 free(data.dptr);
 132                 return NULL;
 133         }
 134
 135         memcpy(rec, data.dptr, sizeof(struct busdb_record));
 136         free(data.dptr);
 137
 138         return rec;
 139 }
 140
 141 /**
 142  * classdb_fetch
 143  */
 144 static struct classdb_record *classdb_fetch(const char *cls,
 145                                                 const char *cls_dev)
 146 {
 147         TDB_DATA key, data;
 148         char keystr[NAME_SIZE+NAME_SIZE+2];
 149         struct classdb_record *rec = NULL;
 150
 151         if (cls == NULL || cls_dev == NULL)
 152                 return NULL;
 153         if (strlen(cls) >= NAME_SIZE || strlen(cls_dev) >= NAME_SIZE)
 154                 return NULL;
 155
 156         memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
 157         strcpy(keystr, cls);
 158         strcat(keystr, UDEVDB_DEL);
 159         strcat(keystr, cls_dev);
 160
 161         key.dptr = (void *)keystr;
 162         key.dsize = strlen(keystr) + 1;
 163
 164         data = tdb_fetch(udevdb, key);
 165         if (data.dptr == NULL || data.dsize == 0)
 166                 return NULL;
 167
 168         rec = (struct classdb_record *)malloc(sizeof(struct classdb_record));
 169         if (rec == NULL) {
 170                 free(data.dptr);
 171                 return NULL;
 172         }
 173
 174         memcpy(rec, data.dptr, sizeof(struct classdb_record));
 175         free(data.dptr);
 176
 177         return rec;
 178 }
 179
 180 /**
 181  * namedb_fetch
 182  */
 183 static struct namedb_record *namedb_fetch(const char *name)
 184 {
 185         TDB_DATA key, data;
 186         char nm_keystr[NAME_SIZE];
 187         struct namedb_record *nrec = NULL;
 188
 189         if (name == NULL)
 190                 return NULL;
 191         if (strlen(name) >= NAME_SIZE)
 192                 return NULL;
 193
 194         memset(nm_keystr, 0, NAME_SIZE);
 195         strcpy(nm_keystr, name);
 196
 197         key.dptr = (void *)nm_keystr;
 198         key.dsize = strlen(nm_keystr) + 1;
 199
 200         data = tdb_fetch(udevdb, key);
 201         if (data.dptr == NULL || data.dsize == 0)
 202                 return NULL;
 203
 204         nrec = (struct namedb_record *)malloc(sizeof(struct namedb_record));
 205         if (nrec == NULL) {
 206                 free(data.dptr);
 207                 return NULL;
 208         }
 209
 210         memcpy(nrec, data.dptr, sizeof(struct namedb_record));
 211         free(data.dptr);
 212
 213         return nrec;
 214 }
 215
 216 /**
 217  * busdb_store
 218  */
 219 static int busdb_store(const struct udevice *dev)
 220 {
 221         TDB_DATA key, data;
 222         char keystr[BUS_SIZE+ID_SIZE+2];
 223         struct busdb_record rec;
 224         int retval = 0;
 225
 226         if (dev == NULL)
 227                 return -1;
 228
 229         memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
 230         strcpy(keystr, dev->bus_name);
 231         strcat(keystr, UDEVDB_DEL);
 232         strcat(keystr, dev->bus_id);
 233
 234         key.dptr = (void *)keystr;
 235         key.dsize = strlen(keystr) + 1;
 236
 237         strcpy(rec.name, dev->name);
 238
 239         data.dptr = (void *) &rec;
 240         data.dsize = sizeof(rec);
 241
 242         retval = tdb_store(udevdb, key, data, TDB_REPLACE);
 243         return retval;
 244 }
 245
 246 /**
 247  * classdb_store
 248  */
 249 static int classdb_store(const struct udevice *dev)
 250 {
 251         TDB_DATA key, data;
 252         char keystr[NAME_SIZE+NAME_SIZE+2];
 253         struct classdb_record rec;
 254         int retval = 0;
 255
 256         if (dev == NULL)
 257                 return -1;
 258
 259         memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
 260         strcpy(keystr, dev->class_name);
 261         strcat(keystr, UDEVDB_DEL);
 262         strcat(keystr, dev->class_dev_name);
 263
 264         key.dptr = (void *)keystr;
 265         key.dsize = strlen(keystr) + 1;
 266
 267         strcpy(rec.name, dev->name);
 268
 269         data.dptr = (void *) &rec;
 270         data.dsize = sizeof(rec);
 271
 272         retval = tdb_store(udevdb, key, data, TDB_REPLACE);
 273         return retval;
 274 }
 275
 276 /**
 277  * namedb_store
 278  */
 279 static int namedb_store(const struct udevice *dev)
 280 {
 281         TDB_DATA key, data;
 282         char keystr[NAME_SIZE];
 283         struct namedb_record rec;
 284         int retval = 0;
 285
 286         if (dev == NULL)
 287                 return -1;
 288
 289         memset(keystr, 0, NAME_SIZE);
 290         strcpy(keystr, dev->name);
 291
 292         key.dptr = (void *)keystr;
 293         key.dsize = strlen(keystr) + 1;
 294
 295         strcpy(rec.sysfs_path, dev->sysfs_path);
 296         strcpy(rec.bus, dev->bus_name);
 297         strcpy(rec.id, dev->bus_id);
 298         strcpy(rec.class_dev_name, dev->class_dev_name);
 299         strcpy(rec.class_name, dev->class_name);
 300         strcpy(rec.driver, dev->driver);
 301         rec.type = dev->type;
 302         rec.major = dev->major;
 303         rec.minor = dev->minor;
 304         rec.mode = dev->mode;
 305
 306         data.dptr = (void *) &rec;
 307         data.dsize = sizeof(rec);
 308
 309         retval = tdb_store(udevdb, key, data, TDB_REPLACE);
 310         return retval;
 311 }
 312
 313 /**
 314  * busdb_delete
 315  */
 316 static int busdb_delete(const char *bus, const char *id)
 317 {
 318         TDB_DATA key;
 319         char keystr[BUS_SIZE+ID_SIZE+2];
 320         int retval = 0;
 321
 322         if (bus == NULL || id == NULL)
 323                 return -1;
 324         if (strlen(bus) >= BUS_SIZE || strlen(id) >= ID_SIZE)
 325                 return -1;
 326
 327         memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
 328         strcpy(keystr, bus);
 329         strcat(keystr, UDEVDB_DEL);
 330         strcat(keystr, id);
 331
 332         key.dptr = (void *)keystr;
 333         key.dsize = strlen(keystr) + 1;
 334
 335         retval = tdb_delete(udevdb, key);
 336         return retval;
 337 }
 338
 339 /**
 340  * classdb_delete
 341  */
 342 static int classdb_delete(const char *cls, const char *cls_dev)
 343 {
 344         TDB_DATA key;
 345         char keystr[NAME_SIZE+NAME_SIZE+2];
 346         int retval = 0;
 347
 348         if (cls == NULL || cls_dev == NULL)
 349                 return -1;
 350         if (strlen(cls) >= NAME_SIZE || strlen(cls_dev) >= NAME_SIZE)
 351                 return -1;
 352
 353         memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
 354         strcpy(keystr, cls);
 355         strcat(keystr, UDEVDB_DEL);
 356         strcat(keystr, cls_dev);
 357
 358         key.dptr = (void *)keystr;
 359         key.dsize = strlen(keystr) + 1;
 360
 361         retval = tdb_delete(udevdb, key);
 362         return retval;
 363 }
 364
 365 /**
 366  * namedb_delete
 367  */
 368 static int namedb_delete(const char *name)
 369 {
 370         TDB_DATA key;
 371         char keystr[NAME_SIZE];
 372         int retval = 0;
 373
 374         if (name == NULL)
 375                 return -1;
 376         if (strlen(name) >= NAME_SIZE)
 377                 return -1;
 378
 379         memset(keystr, 0, NAME_SIZE);
 380         strcpy(keystr, name);
 381
 382         key.dptr = (void *)keystr;
 383         key.dsize = strlen(keystr) + 1;
 384
 385         retval = tdb_delete(udevdb, key);
 386         return retval;
 387 }
 388
 389 /**
 390  * udevdb_delete_udevice
 391  */
 392 int udevdb_delete_udevice(const char *name)
 393 {
 394         struct namedb_record *nrec = NULL;
 395
 396         if (name == NULL)
 397                 return -1;
 398
 399         nrec = namedb_fetch(name);
 400         if (nrec == NULL)
 401                 return -1;
 402
 403         busdb_delete(nrec->bus, nrec->id);
 404         classdb_delete(nrec->class_name, nrec->class_dev_name);
 405         namedb_delete(name);
 406         free(nrec);
 407
 408         return 0;
 409 }
 410
 411 /**
 412  * udevdb_add_udevice: adds udevice to database
 413  */
 414 int udevdb_add_udevice(const struct udevice *dev)
 415 {
 416         if (dev == NULL)
 417                 return -1;
 418
 419         if ((busdb_store(dev)) != 0)
 420                 return -1;
 421         if ((classdb_store(dev)) != 0)
 422                 return -1;
 423         if ((namedb_store(dev)) != 0)
 424                 return -1;
 425
 426         return 0;
 427 }
 428
 429 /**
 430  * udevdb_get_device: grab's device by name
 431  */
 432 struct udevice *udevdb_get_udevice(const char *name)
 433 {
 434         struct namedb_record *nrec = NULL;
 435         struct udevice *dev = NULL;
 436
 437         if (name == NULL)
 438                 return NULL;
 439
 440         nrec = namedb_fetch(name);
 441         if (nrec == NULL)
 442                 return NULL;
 443
 444         dev = (struct udevice *)malloc(sizeof(struct udevice));
 445         if (dev == NULL) {
 446                 free(nrec);
 447                 return NULL;
 448         }
 449
 450         strcpy(dev->name, name);
 451         strcpy(dev->sysfs_path, nrec->sysfs_path);
 452         strcpy(dev->class_dev_name, nrec->class_dev_name);
 453         strcpy(dev->class_name, nrec->class_name);
 454         strcpy(dev->bus_name, nrec->bus);
 455         strcpy(dev->bus_id, nrec->id);
 456         dev->type = nrec->type;
 457         dev->major = nrec->major;
 458         dev->minor = nrec->minor;
 459         dev->mode = nrec->mode;
 460
 461         free(nrec);
 462
 463         return dev;
 464 }
 465
 466 /**
 467  * udevdb_get_device_by_bus
 468  */
 469 struct udevice *udevdb_get_udevice_by_bus(const char *bus, const char *id)
 470 {
 471         struct busdb_record *brec = NULL;
 472         struct udevice *dev = NULL;
 473
 474         if (bus == NULL || id == NULL)
 475                 return NULL;
 476
 477         brec = busdb_fetch(bus, id);
 478         if (brec == NULL)
 479                 return NULL;
 480
 481         dev = udevdb_get_udevice(brec->name);
 482         free(brec);
 483
 484         return dev;
 485 }
 486
 487 /**
 488  * udevdb_get_udevice_by_class
 489  */
 490 struct udevice *udevdb_get_udevice_by_class(const char *cls,
 491                                                 const char *cls_dev)
 492 {
 493         struct classdb_record *crec = NULL;
 494         struct udevice *dev = NULL;
 495
 496         if (cls == NULL || cls_dev == NULL)
 497                 return NULL;
 498
 499         crec = classdb_fetch(cls, cls_dev);
 500         if (crec == NULL)
 501                 return NULL;
 502
 503         dev = udevdb_get_udevice(crec->name);
 504         free(crec);
 505
 506         return dev;
 507 }
 508
 509 /**
 510  * udevdb_exit: closes database
 511  */
 512 void udevdb_exit(void)
 513 {
 514         udevdb_close();
 515 }
 516
 517 /**
 518  * udevdb_init: initializes database
 519  */
 520 int udevdb_init(int init_flag)
 521 {
 522         if (init_flag != UDEVDB_DEFAULT && init_flag != UDEVDB_INTERNAL)
 523                 return -1;
 524
 525         return udevdb_open(init_flag);
 526 }