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 #include "libsysfs/libsysfs.h"
  41
  42 static TDB_CONTEXT *udevdb;
  43
  44 struct sysfsdb_record {
  45         char name[PATH_SIZE];
  46 };
  47
  48 /**
  49  * namedb_record - device name is key, remaining udevice info stored here.
  50  */
  51 struct namedb_record {
  52         char sysfs_dev_path[PATH_SIZE];
  53         char class_dev_name[NAME_SIZE];
  54         char class_name[NAME_SIZE];
  55         char id[ID_SIZE];
  56         char type;
  57         int major;
  58         int minor;
  59         mode_t mode;
  60 };
  61
  62 /**
  63  * udevdb_close: close udev database
  64  */
  65 static void udevdb_close(void)
  66 {
  67         if (udevdb != NULL) {
  68                 tdb_close(udevdb);
  69                 udevdb = NULL;
  70         }
  71 }
  72
  73 /**
  74  * udevdb_open: opens udev's database
  75  * @method: database can either be in memory - UDEVDB_INTERNAL - or
  76  *      written to a file with UDEVDB_DEFAULT.
  77  */
  78 static int udevdb_open(int method)
  79 {
  80         udevdb = tdb_open(UDEV_CONFIG_DIR UDEV_DB, 0, method, O_RDWR | O_CREAT, 0644);
  81         if (udevdb == NULL) {
  82                 if (method == UDEVDB_INTERNAL)
  83                         dbg("Unable to initialize in-memory database");
  84                 else
  85                         dbg("Unable to initialize database at %s", UDEV_CONFIG_DIR UDEV_DB);
  86                 return -EINVAL;
  87         }
  88         return 0;
  89 }
  90
  91 static struct sysfsdb_record *sysfsdb_fetch(const char *path)
  92 {
  93         TDB_DATA key, data;
  94         char keystr[PATH_SIZE+2];
  95         struct sysfsdb_record *rec = NULL;
  96
  97         if (strlen(path) >= PATH_SIZE)
  98                 return NULL;
  99
 100         memset(keystr, 0, sizeof(keystr));
 101         strcpy(keystr, path);
 102
 103         dbg("keystr = %s", keystr);
 104
 105         key.dptr = (void *)keystr;
 106         key.dsize = strlen(keystr) + 1;
 107
 108         data = tdb_fetch(udevdb, key);
 109         if (data.dptr == NULL || data.dsize == 0) {
 110                 dbg("tdb_fetch did not work :(");
 111                 return NULL;
 112         }
 113
 114         rec = (struct sysfsdb_record *)malloc(sizeof(struct sysfsdb_record));
 115         if (rec == NULL) {
 116                 free(data.dptr);
 117                 return NULL;
 118         }
 119
 120         memcpy(rec, data.dptr, sizeof(struct sysfsdb_record));
 121         free(data.dptr);
 122
 123         return rec;
 124 }
 125
 126 /**
 127  * namedb_fetch
 128  */
 129 static struct namedb_record *namedb_fetch(const char *name)
 130 {
 131         TDB_DATA key, data;
 132         char nm_keystr[NAME_SIZE];
 133         struct namedb_record *nrec = NULL;
 134
 135         if (name == NULL)
 136                 return NULL;
 137         if (strlen(name) >= NAME_SIZE)
 138                 return NULL;
 139
 140         memset(nm_keystr, 0, NAME_SIZE);
 141         strcpy(nm_keystr, name);
 142
 143         key.dptr = (void *)nm_keystr;
 144         key.dsize = strlen(nm_keystr) + 1;
 145
 146         data = tdb_fetch(udevdb, key);
 147         if (data.dptr == NULL || data.dsize == 0)
 148                 return NULL;
 149
 150         nrec = (struct namedb_record *)malloc(sizeof(struct namedb_record));
 151         if (nrec == NULL) {
 152                 free(data.dptr);
 153                 return NULL;
 154         }
 155
 156         memcpy(nrec, data.dptr, sizeof(struct namedb_record));
 157         free(data.dptr);
 158
 159         return nrec;
 160 }
 161
 162 static int sysfs_store(const char *path, const struct udevice *dev)
 163 {
 164         TDB_DATA key, data;
 165         char keystr[PATH_SIZE+2];
 166         struct sysfsdb_record rec;
 167         int retval = 0;
 168
 169         if (dev == NULL)
 170                 return -ENODEV;
 171
 172         memset(keystr, 0, sizeof(keystr));
 173         strcpy(keystr, path);
 174
 175         key.dptr = (void *)keystr;
 176         key.dsize = strlen(keystr) + 1;
 177
 178         strcpy(rec.name, dev->name);
 179
 180         data.dptr = (void *) &rec;
 181         data.dsize = sizeof(rec);
 182
 183         retval = tdb_store(udevdb, key, data, TDB_REPLACE);
 184         return retval;
 185 }
 186
 187 /**
 188  * namedb_store
 189  */
 190 static int namedb_store(const struct udevice *dev)
 191 {
 192         TDB_DATA key, data;
 193         char keystr[NAME_SIZE];
 194         struct namedb_record rec;
 195         int retval = 0;
 196
 197         if (dev == NULL)
 198                 return -1;
 199
 200         memset(keystr, 0, NAME_SIZE);
 201         strcpy(keystr, dev->name);
 202
 203         key.dptr = (void *)keystr;
 204         key.dsize = strlen(keystr) + 1;
 205
 206         strcpy(rec.sysfs_dev_path, dev->sysfs_dev_path);
 207         strcpy(rec.id, dev->bus_id);
 208         strcpy(rec.class_dev_name, dev->class_dev_name);
 209         strcpy(rec.class_name, dev->class_name);
 210         rec.type = dev->type;
 211         rec.major = dev->major;
 212         rec.minor = dev->minor;
 213         rec.mode = dev->mode;
 214
 215         data.dptr = (void *) &rec;
 216         data.dsize = sizeof(rec);
 217
 218         retval = tdb_store(udevdb, key, data, TDB_REPLACE);
 219         return retval;
 220 }
 221
 222 /**
 223  * namedb_delete
 224  */
 225 static int namedb_delete(const char *name)
 226 {
 227         TDB_DATA key;
 228         char keystr[NAME_SIZE];
 229         int retval = 0;
 230
 231         if (name == NULL)
 232                 return -1;
 233         if (strlen(name) >= NAME_SIZE)
 234                 return -1;
 235
 236         memset(keystr, 0, NAME_SIZE);
 237         strcpy(keystr, name);
 238
 239         key.dptr = (void *)keystr;
 240         key.dsize = strlen(keystr) + 1;
 241
 242         retval = tdb_delete(udevdb, key);
 243         return retval;
 244 }
 245
 246 static int sysfs_delete(const char *path)
 247 {
 248         TDB_DATA key;
 249         char keystr[PATH_SIZE];
 250
 251         memset(keystr, 0, sizeof(keystr));
 252         strcpy(keystr, path);
 253
 254         key.dptr = keystr;
 255         key.dsize = strlen(keystr) + 1;
 256
 257         return tdb_delete(udevdb, key);
 258 }
 259
 260 /**
 261  * udevdb_delete_udevice
 262  */
 263 int udevdb_delete_udevice(const char *name)
 264 {
 265         struct namedb_record *nrec = NULL;
 266
 267         if (name == NULL)
 268                 return -1;
 269
 270         nrec = namedb_fetch(name);
 271         if (nrec == NULL)
 272                 return -1;
 273
 274         namedb_delete(name);
 275         free(nrec);
 276
 277         return 0;
 278 }
 279
 280 /**
 281  * udevdb_add_device: adds class device to database
 282  */
 283 int udevdb_add_device(const char *device, const struct sysfs_class_device *class_dev, const char *name, char type, int major, int minor, int mode)
 284 {
 285         struct udevice dbdev;
 286
 287         if (class_dev == NULL)
 288                 return -ENODEV;
 289
 290         memset(&dbdev, 0, sizeof(dbdev));
 291         strncpy(dbdev.name, name, NAME_SIZE);
 292         if (class_dev->sysdevice) {
 293                 strncpy(dbdev.sysfs_dev_path, class_dev->sysdevice->directory->path, PATH_SIZE);
 294                 strncpy(dbdev.bus_id, class_dev->sysdevice->bus_id, ID_SIZE);
 295         }
 296         strncpy(dbdev.class_dev_name, class_dev->name, NAME_SIZE);
 297 //      if ((sysfs_get_name_from_path(subsystem, dbdev.class_name, NAME_SIZE)) != 0)
 298 //              strcpy(dbdev.class_name, "unknown");
 299         dbdev.type = type;
 300         dbdev.major = major;
 301         dbdev.minor = minor;
 302         dbdev.mode = mode;
 303
 304         if ((sysfs_store(device, &dbdev)) != 0)
 305                 return -1;
 306 //      if ((namedb_store(&dbdev)) != 0)
 307 //              return -1;
 308
 309         return 0;
 310 }
 311
 312 /**
 313  * udevdb_get_device: grab's device by name
 314  */
 315 struct udevice *udevdb_get_udevice(const char *name)
 316 {
 317         struct namedb_record *nrec = NULL;
 318         struct udevice *dev = NULL;
 319
 320         if (name == NULL)
 321                 return NULL;
 322
 323         nrec = namedb_fetch(name);
 324         if (nrec == NULL)
 325                 return NULL;
 326
 327         dev = (struct udevice *)malloc(sizeof(struct udevice));
 328         if (dev == NULL) {
 329                 free(nrec);
 330                 return NULL;
 331         }
 332
 333         strcpy(dev->name, name);
 334         strcpy(dev->sysfs_dev_path, nrec->sysfs_dev_path);
 335         strcpy(dev->class_dev_name, nrec->class_dev_name);
 336         strcpy(dev->class_name, nrec->class_name);
 337         strcpy(dev->bus_id, nrec->id);
 338         dev->type = nrec->type;
 339         dev->major = nrec->major;
 340         dev->minor = nrec->minor;
 341         dev->mode = nrec->mode;
 342
 343         free(nrec);
 344
 345         return dev;
 346 }
 347
 348 int udevdb_get_dev(const char *path, char *name, size_t name_size)
 349 {
 350         struct sysfsdb_record *rec = NULL;
 351
 352         if ((path == NULL) || (name == NULL) || (name_size < 1))
 353                 return -EINVAL;
 354
 355         rec = sysfsdb_fetch(path);
 356         if (rec == NULL)
 357                 return -ENODEV;
 358
 359         if (strlen(rec->name) >= name_size)
 360                 return -EINVAL;
 361
 362         strncpy(name, rec->name, name_size);
 363         return 0;
 364 }
 365
 366 int udevdb_delete_dev(const char *path)
 367 {
 368         if (path == NULL)
 369                 return -EINVAL;
 370
 371         return sysfs_delete(path);
 372 }
 373
 374 /**
 375  * udevdb_exit: closes database
 376  */
 377 void udevdb_exit(void)
 378 {
 379         udevdb_close();
 380 }
 381
 382 /**
 383  * udevdb_init: initializes database
 384  */
 385 int udevdb_init(int init_flag)
 386 {
 387         if (init_flag != UDEVDB_DEFAULT && init_flag != UDEVDB_INTERNAL)
 388                 return -1;
 389
 390         return udevdb_open(init_flag);
 391 }