[thirdparty/systemd.git] / udevdb.c

/*
 * udev database library
 */
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <string.h>
#include <sys/stat.h>
#include <errno.h>

#include "udevdb.h"
#include "tdb.h"

static TDB_CONTEXT *busdb;
static TDB_CONTEXT *classdb;
static TDB_CONTEXT *namedb;

/**
 * busdb_record - bus and id are keys to look up name of device
 */
struct busdb_record {
	char name[NAME_SIZE];
};

/**
 * classdb_record - class name and class device name used as keys to find
 *	device name.
 */
struct classdb_record {
	char name[NAME_SIZE];
};

/**
 * namedb_record - device name is key, remaining udevice info stored here.
 */
struct namedb_record {
	char sysfs_path[PATH_SIZE];
	char class_dev_name[NAME_SIZE];
	char class_name[NAME_SIZE];
	char bus[BUS_SIZE];
	char id[ID_SIZE];
	char driver[NAME_SIZE];
	char type;
	int major;
	int minor;
	int mode;
};

/**
 * busdb_close: close busdb database
 */
static void busdb_close(void)
{
	if (busdb != NULL) {
		tdb_close(busdb);
		busdb = NULL;
	}
}

/**
 * classdb_close: close classdb database
 */
static void classdb_close(void)
{
	if (classdb != NULL) {
		tdb_close(classdb);
		classdb = NULL;
	}
}

/**
 * namedb_close: close name database
 */
static void namedb_close(void)
{
	if (namedb != NULL) {
		tdb_close(namedb);
		namedb = NULL;
	}
}

/**
 * busdb_open: open busdb's database
 */
static int busdb_open(void)
{
	busdb = tdb_open(BUS_DB, 0, 0, O_RDWR | O_CREAT, 0644);
	if (busdb == NULL)
		return -1;
	return 0;
}

/**
 * classdb_open: open classdb's database
 */
static int classdb_open(void)
{
	classdb = tdb_open(CLASS_DB, 0, 0, O_RDWR | O_CREAT, 0644);
	if (classdb == NULL)
		return -1;
	return 0;
}

/**
 * namedb_open: open name database
 */
static int namedb_open(void)
{
	namedb = tdb_open(NAME_DB, 0, 0, O_RDWR | O_CREAT, 0644);
	if (namedb == NULL)
		return -1;
	return 0;
}

/**
 * busdb_fetch
 */
static struct busdb_record *busdb_fetch(const char *bus, const char *id)
{
	TDB_DATA key, data;
	char keystr[BUS_SIZE+ID_SIZE+2]; 
	struct busdb_record *rec = NULL;

	if (bus == NULL || id == NULL)
		return NULL; 
	if (strlen(bus) >= BUS_SIZE || strlen(id) >= ID_SIZE)
		return NULL;

	if ((busdb_open()) != 0)
		return NULL;

	memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
	strcpy(keystr, bus);
	strcat(keystr, UDEVDB_DEL);
	strcat(keystr, id);

	key.dptr = (void *)keystr;
	key.dsize = strlen(keystr) + 1;

	data = tdb_fetch(busdb, key);
	busdb_close();
	if (data.dptr == NULL || data.dsize == 0)
		return NULL;
	
	rec = (struct busdb_record *)malloc(sizeof(struct busdb_record));
	if (rec == NULL) {
		free(data.dptr);
		return NULL;
	}
	
	memcpy(rec, data.dptr, sizeof(struct busdb_record));
	free(data.dptr);

	return rec;
}

/**
 * classdb_fetch
 */
static struct classdb_record *classdb_fetch(const char *cls, 
						const char *cls_dev)
{
	TDB_DATA key, data;
	char keystr[NAME_SIZE+NAME_SIZE+2]; 
	struct classdb_record *rec = NULL;

	if (cls == NULL || cls_dev == NULL)
		return NULL; 
	if (strlen(cls) >= NAME_SIZE || strlen(cls_dev) >= NAME_SIZE)
		return NULL;

	if ((classdb_open()) != 0)
		return NULL;

	memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
	strcpy(keystr, cls);
	strcat(keystr, UDEVDB_DEL);
	strcat(keystr, cls_dev);

	key.dptr = (void *)keystr;
	key.dsize = strlen(keystr) + 1;

	data = tdb_fetch(classdb, key);
	classdb_close();
	if (data.dptr == NULL || data.dsize == 0)
		return NULL;
	
	rec = (struct classdb_record *)malloc(sizeof(struct classdb_record));
	if (rec == NULL) {
		free(data.dptr);
		return NULL;
	}
	
	memcpy(rec, data.dptr, sizeof(struct classdb_record));
	free(data.dptr);

	return rec;
}

/**
 * namedb_fetch
 */
static struct namedb_record *namedb_fetch(const char *name)
{
	TDB_DATA key, data;
	char nm_keystr[NAME_SIZE]; 
	struct namedb_record *nrec = NULL;

	if (name == NULL)
		return NULL; 
	if (strlen(name) >= NAME_SIZE)
		return NULL;

	if ((namedb_open()) != 0)
		return NULL;

	memset(nm_keystr, 0, NAME_SIZE);
	strcpy(nm_keystr, name);

	key.dptr = (void *)nm_keystr;
	key.dsize = strlen(nm_keystr) + 1;

	data = tdb_fetch(namedb, key);
	namedb_close();

	if (data.dptr == NULL || data.dsize == 0)
		return NULL;

	nrec = (struct namedb_record *)malloc(sizeof(struct namedb_record));
	if (nrec == NULL) {
		free(data.dptr);
		return NULL;
	}
	
	memcpy(nrec, data.dptr, sizeof(struct namedb_record));
	free(data.dptr);

	return nrec;
}

/**
 * busdb_store
 */
static int busdb_store(const struct udevice *dev)
{
	TDB_DATA key, data;
	char keystr[BUS_SIZE+ID_SIZE+2];
	struct busdb_record rec;
	int retval = 0;

	if (dev == NULL)
		return -1;

	if ((retval = busdb_open()) != 0)
		return -1;

	memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
	strcpy(keystr, dev->bus_name);
	strcat(keystr, UDEVDB_DEL);
	strcat(keystr, dev->bus_id);

	key.dptr = (void *)keystr;
	key.dsize = strlen(keystr) + 1;
	
	strcpy(rec.name, dev->name);

	data.dptr = (void *) &rec;
	data.dsize = sizeof(rec);
	
	retval = tdb_store(busdb, key, data, TDB_REPLACE); 

	busdb_close();
	return retval;
}

/**
 * classdb_store
 */
static int classdb_store(const struct udevice *dev)
{
	TDB_DATA key, data;
	char keystr[NAME_SIZE+NAME_SIZE+2];
	struct classdb_record rec;
	int retval = 0;

	if (dev == NULL)
		return -1;

	if ((retval = classdb_open()) != 0)
		return -1;

	memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
	strcpy(keystr, dev->class_name);
	strcat(keystr, UDEVDB_DEL);
	strcat(keystr, dev->class_dev_name);

	key.dptr = (void *)keystr;
	key.dsize = strlen(keystr) + 1;
	
	strcpy(rec.name, dev->name);

	data.dptr = (void *) &rec;
	data.dsize = sizeof(rec);
	
	retval = tdb_store(classdb, key, data, TDB_REPLACE); 

	classdb_close();
	return retval;
}

/**
 * namedb_store
 */
static int namedb_store(const struct udevice *dev)
{
	TDB_DATA key, data;
	char keystr[NAME_SIZE];
	struct namedb_record rec;
	int retval = 0;

	if (dev == NULL)
		return -1;

	if ((retval = namedb_open()) != 0)
		return -1;

	memset(keystr, 0, NAME_SIZE);
	strcpy(keystr, dev->name);

	key.dptr = (void *)keystr;
	key.dsize = strlen(keystr) + 1;
	
	strcpy(rec.sysfs_path, dev->sysfs_path);
	strcpy(rec.bus, dev->bus_name);
	strcpy(rec.id, dev->bus_id);
	strcpy(rec.class_dev_name, dev->class_dev_name);
	strcpy(rec.class_name, dev->class_name);
	strcpy(rec.driver, dev->driver);
	rec.type = dev->type;
	rec.major = dev->major;
	rec.minor = dev->minor;
	rec.mode = dev->mode;

	data.dptr = (void *) &rec;
	data.dsize = sizeof(rec);
	
	retval = tdb_store(namedb, key, data, TDB_REPLACE); 

	namedb_close();
	return retval;
}

/**
 * busdb_delete
 */
static int busdb_delete(const char *bus, const char *id)
{
	TDB_DATA key;
	char keystr[BUS_SIZE+ID_SIZE+2]; 
	int retval = 0;

	if (bus == NULL || id == NULL)
		return -1; 
	if (strlen(bus) >= BUS_SIZE || strlen(id) >= ID_SIZE)
		return -1;

	if ((busdb_open()) != 0)
		return -1;

	memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
	strcpy(keystr, bus);
	strcat(keystr, UDEVDB_DEL);
	strcat(keystr, id);

	key.dptr = (void *)keystr;
	key.dsize = strlen(keystr) + 1;

	retval = tdb_delete(busdb, key);
	busdb_close();
	
	return retval;
}

/**
 * classdb_delete
 */
static int classdb_delete(const char *cls, const char *cls_dev)
{
	TDB_DATA key;
	char keystr[NAME_SIZE+NAME_SIZE+2]; 
	int retval = 0;

	if (cls == NULL || cls_dev == NULL)
		return -1; 
	if (strlen(cls) >= NAME_SIZE || strlen(cls_dev) >= NAME_SIZE)
		return -1;

	if ((classdb_open()) != 0)
		return -1;

	memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
	strcpy(keystr, cls);
	strcat(keystr, UDEVDB_DEL);
	strcat(keystr, cls_dev);

	key.dptr = (void *)keystr;
	key.dsize = strlen(keystr) + 1;

	retval = tdb_delete(classdb, key);
	classdb_close();
	
	return retval;
}

/**
 * namedb_delete
 */
static int namedb_delete(const char *name)
{
	TDB_DATA key;
	char keystr[NAME_SIZE]; 
	int retval = 0;

	if (name == NULL)
		return -1; 
	if (strlen(name) >= NAME_SIZE)
		return -1;

	if ((namedb_open()) != 0)
		return -1;

	memset(keystr, 0, NAME_SIZE);
	strcpy(keystr, name);

	key.dptr = (void *)keystr;
	key.dsize = strlen(keystr) + 1;

	retval = tdb_delete(namedb, key);
	namedb_close();

	return retval;
}

/**
 * namedb_exists
 */
static int namedb_exists(const char *name)
{
	TDB_DATA key;
	char keystr[NAME_SIZE]; 
	int retval = 0;

	if (name == NULL)
		return retval; 
	if (strlen(name) >= NAME_SIZE)
		return retval;

	if ((namedb_open()) != 0)
		return retval;

	memset(keystr, 0, NAME_SIZE);
	strcpy(keystr, name);

	key.dptr = (void *)keystr;
	key.dsize = strlen(keystr) + 1;

	retval = tdb_exists(namedb, key);
	namedb_close();

	return retval;
}

/**
 * udevdb_delete_udevice
 */
int udevdb_delete_udevice(const char *name)
{
	struct namedb_record *nrec = NULL;

	if (name == NULL)
		return -1; 

	nrec = namedb_fetch(name);
	if (nrec == NULL)
		return -1;

	busdb_delete(nrec->bus, nrec->id);
	classdb_delete(nrec->class_name, nrec->class_dev_name);
	namedb_delete(name);
	free(nrec);

	return 0;
}

/**
 * udevdb_add_udevice: adds udevice to database
 */
int udevdb_add_udevice(const struct udevice *dev)
{
	if (dev == NULL) 
		return -1;

	if ((busdb_store(dev)) != 0)
		return -1;
	if ((classdb_store(dev)) != 0)
		return -1;
	if ((namedb_store(dev)) != 0)
		return -1;

	return 0;
}

/**
 * udevdb_get_device: grab's device by name
 */
struct udevice *udevdb_get_udevice(const char *name)
{
	struct namedb_record *nrec = NULL;
	struct udevice *dev = NULL;

	if (name == NULL)
		return NULL; 

	nrec = namedb_fetch(name);
	if (nrec == NULL)
		return NULL;

	dev = (struct udevice *)malloc(sizeof(struct udevice));
	if (dev == NULL) {
		free(nrec);
		return NULL;
	}

	strcpy(dev->name, name);
	strcpy(dev->sysfs_path, nrec->sysfs_path);
	strcpy(dev->class_dev_name, nrec->class_dev_name);
	strcpy(dev->class_name, nrec->class_name);
	strcpy(dev->bus_name, nrec->bus);
	strcpy(dev->bus_id, nrec->id);
	dev->type = nrec->type;
	dev->major = nrec->major;
	dev->minor = nrec->minor;
	dev->mode = nrec->mode;

	free(nrec);

	return dev;
}

/**
 * udevdb_get_device_by_bus
 */
struct udevice *udevdb_get_udevice_by_bus(const char *bus, const char *id)
{
	struct busdb_record *brec = NULL;
	struct udevice *dev = NULL;

	if (bus == NULL || id == NULL)
		return NULL;

	brec = busdb_fetch(bus, id);
	if (brec == NULL)
		return NULL;

	dev = udevdb_get_udevice(brec->name);
	free(brec);

	return dev;
}

/**
 * udevdb_get_udevice_by_class
 */
struct udevice *udevdb_get_udevice_by_class(const char *cls, 
						const char *cls_dev)
{
	struct classdb_record *crec = NULL;
	struct udevice *dev = NULL;

	if (cls == NULL || cls_dev == NULL)
		return NULL;

	crec = classdb_fetch(cls, cls_dev);
	if (crec == NULL)
		return NULL;

	dev = udevdb_get_udevice(crec->name);
	free(crec);

	return dev;
}
Commit	Line	Data
8e41d35d DS	1	/*
	2	* udev database library
	3	*/
	4	#include <stdlib.h>
	5	#include <stdio.h>
	6	#include <fcntl.h>
	7	#include <string.h>
	8	#include <sys/stat.h>
	9	#include <errno.h>
	10
	11	#include "udevdb.h"
	12	#include "tdb.h"
	13
	14	static TDB_CONTEXT *busdb;
	15	static TDB_CONTEXT *classdb;
	16	static TDB_CONTEXT *namedb;
	17
	18	/**
	19	* busdb_record - bus and id are keys to look up name of device
	20	*/
	21	struct busdb_record {
	22	char name[NAME_SIZE];
	23	};
	24
	25	/**
	26	* classdb_record - class name and class device name used as keys to find
	27	* device name.
	28	*/
	29	struct classdb_record {
	30	char name[NAME_SIZE];
	31	};
	32
	33	/**
	34	* namedb_record - device name is key, remaining udevice info stored here.
	35	*/
	36	struct namedb_record {
	37	char sysfs_path[PATH_SIZE];
	38	char class_dev_name[NAME_SIZE];
	39	char class_name[NAME_SIZE];
	40	char bus[BUS_SIZE];
	41	char id[ID_SIZE];
	42	char driver[NAME_SIZE];
	43	char type;
	44	int major;
	45	int minor;
	46	int mode;
	47	};
	48
	49	/**
	50	* busdb_close: close busdb database
	51	*/
	52	static void busdb_close(void)
	53	{
	54	if (busdb != NULL) {
	55	tdb_close(busdb);
	56	busdb = NULL;
	57	}
	58	}
	59
	60	/**
	61	* classdb_close: close classdb database
	62	*/
	63	static void classdb_close(void)
	64	{
65	if (classdb != NULL) {
66	tdb_close(classdb);
67	classdb = NULL;
68	}
69	}
70
71	/**
72	* namedb_close: close name database
73	*/
74	static void namedb_close(void)
75	{
76	if (namedb != NULL) {
77	tdb_close(namedb);
78	namedb = NULL;
79	}
80	}
81
82	/**
83	* busdb_open: open busdb's database
84	*/
85	static int busdb_open(void)
86	{
87	busdb = tdb_open(BUS_DB, 0, 0, O_RDWR \| O_CREAT, 0644);
88	if (busdb == NULL)
89	return -1;
90	return 0;
91	}
92
93	/**
94	* classdb_open: open classdb's database
95	*/
96	static int classdb_open(void)
97	{
98	classdb = tdb_open(CLASS_DB, 0, 0, O_RDWR \| O_CREAT, 0644);
99	if (classdb == NULL)
100	return -1;
101	return 0;
102	}
103
104	/**
105	* namedb_open: open name database
106	*/
107	static int namedb_open(void)
108	{
109	namedb = tdb_open(NAME_DB, 0, 0, O_RDWR \| O_CREAT, 0644);
110	if (namedb == NULL)
111	return -1;
112	return 0;
113	}
114
115	/**
116	* busdb_fetch
117	*/
118	static struct busdb_record busdb_fetch(const char bus, const char *id)
119	{
120	TDB_DATA key, data;
121	char keystr[BUS_SIZE+ID_SIZE+2];
122	struct busdb_record *rec = NULL;
123
124	if (bus == NULL \|\| id == NULL)
125	return NULL;
126	if (strlen(bus) >= BUS_SIZE \|\| strlen(id) >= ID_SIZE)
127	return NULL;
128
129	if ((busdb_open()) != 0)
130	return NULL;
131
132	memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
133	strcpy(keystr, bus);
134	strcat(keystr, UDEVDB_DEL);
135	strcat(keystr, id);
136
137	key.dptr = (void *)keystr;
138	key.dsize = strlen(keystr) + 1;
139
140	data = tdb_fetch(busdb, key);
141	busdb_close();
142	if (data.dptr == NULL \|\| data.dsize == 0)
143	return NULL;
144
145	rec = (struct busdb_record *)malloc(sizeof(struct busdb_record));
146	if (rec == NULL) {
147	free(data.dptr);
148	return NULL;
149	}
150
151	memcpy(rec, data.dptr, sizeof(struct busdb_record));
152	free(data.dptr);
153
154	return rec;
155	}
156
157	/**
158	* classdb_fetch
159	*/
160	static struct classdb_record classdb_fetch(const char cls,
161	const char *cls_dev)
162	{
163	TDB_DATA key, data;
164	char keystr[NAME_SIZE+NAME_SIZE+2];
165	struct classdb_record *rec = NULL;
166
167	if (cls == NULL \|\| cls_dev == NULL)
168	return NULL;
169	if (strlen(cls) >= NAME_SIZE \|\| strlen(cls_dev) >= NAME_SIZE)
170	return NULL;
171
172	if ((classdb_open()) != 0)
173	return NULL;
174
175	memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
176	strcpy(keystr, cls);
177	strcat(keystr, UDEVDB_DEL);
178	strcat(keystr, cls_dev);
179
180	key.dptr = (void *)keystr;
181	key.dsize = strlen(keystr) + 1;
182
183	data = tdb_fetch(classdb, key);
184	classdb_close();
185	if (data.dptr == NULL \|\| data.dsize == 0)
186	return NULL;
187
188	rec = (struct classdb_record *)malloc(sizeof(struct classdb_record));
189	if (rec == NULL) {
190	free(data.dptr);
191	return NULL;
192	}
193
194	memcpy(rec, data.dptr, sizeof(struct classdb_record));
195	free(data.dptr);
196
197	return rec;
198	}
199
200	/**
201	* namedb_fetch
202	*/
203	static struct namedb_record namedb_fetch(const char name)
204	{
205	TDB_DATA key, data;
206	char nm_keystr[NAME_SIZE];
207	struct namedb_record *nrec = NULL;
208
209	if (name == NULL)
210	return NULL;
211	if (strlen(name) >= NAME_SIZE)
212	return NULL;
213
214	if ((namedb_open()) != 0)
215	return NULL;
216
217	memset(nm_keystr, 0, NAME_SIZE);
218	strcpy(nm_keystr, name);
219
220	key.dptr = (void *)nm_keystr;
221	key.dsize = strlen(nm_keystr) + 1;
222
223	data = tdb_fetch(namedb, key);
224	namedb_close();
225
226	if (data.dptr == NULL \|\| data.dsize == 0)
227	return NULL;
228
229	nrec = (struct namedb_record *)malloc(sizeof(struct namedb_record));
230	if (nrec == NULL) {
231	free(data.dptr);
232	return NULL;
233	}
234
235	memcpy(nrec, data.dptr, sizeof(struct namedb_record));
236	free(data.dptr);
237
238	return nrec;
239	}
240
241	/**
242	* busdb_store
243	*/
244	static int busdb_store(const struct udevice *dev)
245	{
246	TDB_DATA key, data;
247	char keystr[BUS_SIZE+ID_SIZE+2];
248	struct busdb_record rec;
249	int retval = 0;
250
251	if (dev == NULL)
252	return -1;
253
254	if ((retval = busdb_open()) != 0)
255	return -1;
256
257	memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
258	strcpy(keystr, dev->bus_name);
259	strcat(keystr, UDEVDB_DEL);
260	strcat(keystr, dev->bus_id);
261
262	key.dptr = (void *)keystr;
263	key.dsize = strlen(keystr) + 1;
264
265	strcpy(rec.name, dev->name);
266
267	data.dptr = (void *) &rec;
268	data.dsize = sizeof(rec);
269
270	retval = tdb_store(busdb, key, data, TDB_REPLACE);
271
272	busdb_close();
273	return retval;
274	}
275
276	/**
277	* classdb_store
278	*/
279	static int classdb_store(const struct udevice *dev)
280	{
281	TDB_DATA key, data;
282	char keystr[NAME_SIZE+NAME_SIZE+2];
283	struct classdb_record rec;
284	int retval = 0;
285
286	if (dev == NULL)
287	return -1;
288
289	if ((retval = classdb_open()) != 0)
290	return -1;
291
292	memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
293	strcpy(keystr, dev->class_name);
294	strcat(keystr, UDEVDB_DEL);
295	strcat(keystr, dev->class_dev_name);
296
297	key.dptr = (void *)keystr;
298	key.dsize = strlen(keystr) + 1;
299
300	strcpy(rec.name, dev->name);
301
302	data.dptr = (void *) &rec;
303	data.dsize = sizeof(rec);
304
305	retval = tdb_store(classdb, key, data, TDB_REPLACE);
306
307	classdb_close();
308	return retval;
309	}
310
311	/**
312	* namedb_store
313	*/
314	static int namedb_store(const struct udevice *dev)
315	{
316	TDB_DATA key, data;
317	char keystr[NAME_SIZE];
318	struct namedb_record rec;
319	int retval = 0;
320
321	if (dev == NULL)
322	return -1;
323
324	if ((retval = namedb_open()) != 0)
325	return -1;
326
327	memset(keystr, 0, NAME_SIZE);
328	strcpy(keystr, dev->name);
329
330	key.dptr = (void *)keystr;
331	key.dsize = strlen(keystr) + 1;
332
333	strcpy(rec.sysfs_path, dev->sysfs_path);
334	strcpy(rec.bus, dev->bus_name);
335	strcpy(rec.id, dev->bus_id);
336	strcpy(rec.class_dev_name, dev->class_dev_name);
337	strcpy(rec.class_name, dev->class_name);
338	strcpy(rec.driver, dev->driver);
339	rec.type = dev->type;
340	rec.major = dev->major;
341	rec.minor = dev->minor;
342	rec.mode = dev->mode;
343
344	data.dptr = (void *) &rec;
345	data.dsize = sizeof(rec);
346
347	retval = tdb_store(namedb, key, data, TDB_REPLACE);
348
349	namedb_close();
350	return retval;
351	}
352
353	/**
354	* busdb_delete
355	*/
356	static int busdb_delete(const char bus, const char id)
357	{
358	TDB_DATA key;
359	char keystr[BUS_SIZE+ID_SIZE+2];
360	int retval = 0;
361
362	if (bus == NULL \|\| id == NULL)
363	return -1;
364	if (strlen(bus) >= BUS_SIZE \|\| strlen(id) >= ID_SIZE)
365	return -1;
366
367	if ((busdb_open()) != 0)
368	return -1;
369
370	memset(keystr, 0, (BUS_SIZE+ID_SIZE+2));
371	strcpy(keystr, bus);
372	strcat(keystr, UDEVDB_DEL);
373	strcat(keystr, id);
374
375	key.dptr = (void *)keystr;
376	key.dsize = strlen(keystr) + 1;
377
378	retval = tdb_delete(busdb, key);
379	busdb_close();
380
381	return retval;
382	}
383
384	/**
385	* classdb_delete
386	*/
387	static int classdb_delete(const char cls, const char cls_dev)
388	{
389	TDB_DATA key;
390	char keystr[NAME_SIZE+NAME_SIZE+2];
391	int retval = 0;
392
393	if (cls == NULL \|\| cls_dev == NULL)
394	return -1;
395	if (strlen(cls) >= NAME_SIZE \|\| strlen(cls_dev) >= NAME_SIZE)
396	return -1;
397
398	if ((classdb_open()) != 0)
399	return -1;
400
401	memset(keystr, 0, (NAME_SIZE+NAME_SIZE+2));
402	strcpy(keystr, cls);
403	strcat(keystr, UDEVDB_DEL);
404	strcat(keystr, cls_dev);
405
406	key.dptr = (void *)keystr;
407	key.dsize = strlen(keystr) + 1;
408
409	retval = tdb_delete(classdb, key);
410	classdb_close();
411
412	return retval;
413	}
414
415	/**
416	* namedb_delete
417	*/
418	static int namedb_delete(const char *name)
419	{
420	TDB_DATA key;
421	char keystr[NAME_SIZE];
422	int retval = 0;
423
424	if (name == NULL)
425	return -1;
426	if (strlen(name) >= NAME_SIZE)
427	return -1;
428
429	if ((namedb_open()) != 0)
430	return -1;
431
432	memset(keystr, 0, NAME_SIZE);
433	strcpy(keystr, name);
434
435	key.dptr = (void *)keystr;
436	key.dsize = strlen(keystr) + 1;
437
438	retval = tdb_delete(namedb, key);
439	namedb_close();
440
441	return retval;
442	}
443
444	/**
445	* namedb_exists
446	*/
447	static int namedb_exists(const char *name)
448	{
449	TDB_DATA key;
450	char keystr[NAME_SIZE];
451	int retval = 0;
452
453	if (name == NULL)
454	return retval;
455	if (strlen(name) >= NAME_SIZE)
456	return retval;
457
458	if ((namedb_open()) != 0)
459	return retval;
460
461	memset(keystr, 0, NAME_SIZE);
462	strcpy(keystr, name);
463
464	key.dptr = (void *)keystr;
465	key.dsize = strlen(keystr) + 1;
466
467	retval = tdb_exists(namedb, key);
468	namedb_close();
469
470	return retval;
471	}
472
473	/**
474	* udevdb_delete_udevice
475	*/
476	int udevdb_delete_udevice(const char *name)
477	{
478	struct namedb_record *nrec = NULL;
479
480	if (name == NULL)
481	return -1;
482
483	nrec = namedb_fetch(name);
484	if (nrec == NULL)
485	return -1;
486
487	busdb_delete(nrec->bus, nrec->id);
488	classdb_delete(nrec->class_name, nrec->class_dev_name);
489	namedb_delete(name);
490	free(nrec);
491
492	return 0;
493	}
494
495	/**
496	* udevdb_add_udevice: adds udevice to database
497	*/
498	int udevdb_add_udevice(const struct udevice *dev)
499	{
500	if (dev == NULL)
501	return -1;
502
503	if ((busdb_store(dev)) != 0)
504	return -1;
505	if ((classdb_store(dev)) != 0)
506	return -1;
507	if ((namedb_store(dev)) != 0)
508	return -1;
509
510	return 0;
511	}
512
513	/**
514	* udevdb_get_device: grab's device by name
515	*/
516	struct udevice udevdb_get_udevice(const char name)
517	{
518	struct namedb_record *nrec = NULL;
519	struct udevice *dev = NULL;
520
521	if (name == NULL)
522	return NULL;
523
524	nrec = namedb_fetch(name);
525	if (nrec == NULL)
526	return NULL;
527
528	dev = (struct udevice *)malloc(sizeof(struct udevice));
529	if (dev == NULL) {
530	free(nrec);
531	return NULL;
532	}
533
534	strcpy(dev->name, name);
535	strcpy(dev->sysfs_path, nrec->sysfs_path);
536	strcpy(dev->class_dev_name, nrec->class_dev_name);
537	strcpy(dev->class_name, nrec->class_name);
538	strcpy(dev->bus_name, nrec->bus);
539	strcpy(dev->bus_id, nrec->id);
540	dev->type = nrec->type;
541	dev->major = nrec->major;
542	dev->minor = nrec->minor;
543	dev->mode = nrec->mode;
544
545	free(nrec);
546
547	return dev;
548	}
549
550	/**
551	* udevdb_get_device_by_bus
552	*/
553	struct udevice udevdb_get_udevice_by_bus(const char bus, const char *id)
554	{
555	struct busdb_record *brec = NULL;
556	struct udevice *dev = NULL;
557
558	if (bus == NULL \|\| id == NULL)
559	return NULL;
560
561	brec = busdb_fetch(bus, id);
562	if (brec == NULL)
563	return NULL;
564
565	dev = udevdb_get_udevice(brec->name);
566	free(brec);
567
568	return dev;
569	}
570
571	/**
572	* udevdb_get_udevice_by_class
573	*/
574	struct udevice udevdb_get_udevice_by_class(const char cls,
575	const char *cls_dev)
576	{
577	struct classdb_record *crec = NULL;
578	struct udevice *dev = NULL;
579
580	if (cls == NULL \|\| cls_dev == NULL)
581	return NULL;
582
583	crec = classdb_fetch(cls, cls_dev);
584	if (crec == NULL)
585	return NULL;
586
587	dev = udevdb_get_udevice(crec->name);
588	free(crec);
589
590	return dev;
591	}