1 /*********************************************************************
3 * Filename: irias_object.c
5 * Description: IAS object database and functions
6 * Status: Experimental.
7 * Author: Dag Brattli <dagb@cs.uit.no>
8 * Created at: Thu Oct 1 22:50:04 1998
9 * Modified at: Wed Dec 15 11:23:16 1999
10 * Modified by: Dag Brattli <dagb@cs.uit.no>
12 * Copyright (c) 1998-1999 Dag Brattli, All Rights Reserved.
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License as
16 * published by the Free Software Foundation; either version 2 of
17 * the License, or (at your option) any later version.
19 * Neither Dag Brattli nor University of Tromsø admit liability nor
20 * provide warranty for any of this software. This material is
21 * provided "AS-IS" and at no charge.
23 ********************************************************************/
25 #include <linux/string.h>
26 #include <linux/socket.h>
27 #include <linux/module.h>
29 #include <net/irda/irda.h>
30 #include <net/irda/irias_object.h>
32 hashbin_t *irias_objects;
35 * Used when a missing value needs to be returned
37 struct ias_value irias_missing = { IAS_MISSING, 0, 0, 0, {0}};
40 * Function strndup (str, max)
42 * My own kernel version of strndup!
44 * Faster, check boundary... Jean II
46 static char *strndup(char *str, int max)
54 /* Check length, truncate */
59 /* Allocate new string */
60 new_str = kmalloc(len + 1, GFP_ATOMIC);
61 if (new_str == NULL) {
62 WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
66 /* Copy and truncate */
67 memcpy(new_str, str, len);
74 * Function ias_new_object (name, id)
76 * Create a new IAS object
79 struct ias_object *irias_new_object( char *name, int id)
81 struct ias_object *obj;
83 IRDA_DEBUG( 4, "%s()\n", __FUNCTION__);
85 obj = (struct ias_object *) kmalloc(sizeof(struct ias_object),
88 WARNING("%s(), Unable to allocate object!\n",
92 memset(obj, 0, sizeof( struct ias_object));
94 obj->magic = IAS_OBJECT_MAGIC;
95 obj->name = strndup(name, IAS_MAX_CLASSNAME);
98 /* Locking notes : the attrib spinlock has lower precendence
99 * than the objects spinlock. Never grap the objects spinlock
100 * while holding any attrib spinlock (risk of deadlock). Jean II */
101 obj->attribs = hashbin_new(HB_LOCK);
103 if (obj->attribs == NULL) {
104 WARNING("%s(), Unable to allocate attribs!\n", __FUNCTION__);
111 EXPORT_SYMBOL(irias_new_object);
114 * Function irias_delete_attrib (attrib)
116 * Delete given attribute and deallocate all its memory
119 void __irias_delete_attrib(struct ias_attrib *attrib)
121 ASSERT(attrib != NULL, return;);
122 ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, return;);
127 irias_delete_value(attrib->value);
128 attrib->magic = ~IAS_ATTRIB_MAGIC;
133 void __irias_delete_object(struct ias_object *obj)
135 ASSERT(obj != NULL, return;);
136 ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
141 hashbin_delete(obj->attribs, (FREE_FUNC) __irias_delete_attrib);
143 obj->magic = ~IAS_OBJECT_MAGIC;
149 * Function irias_delete_object (obj)
151 * Remove object from hashbin and deallocate all attributes associated with
152 * with this object and the object itself
155 int irias_delete_object(struct ias_object *obj)
157 struct ias_object *node;
159 ASSERT(obj != NULL, return -1;);
160 ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -1;);
162 /* Remove from list */
163 node = hashbin_remove_this(irias_objects, (irda_queue_t *) obj);
165 IRDA_DEBUG( 0, "%s(), object already removed!\n",
169 __irias_delete_object(obj);
173 EXPORT_SYMBOL(irias_delete_object);
176 * Function irias_delete_attrib (obj)
178 * Remove attribute from hashbin and, if it was the last attribute of
179 * the object, remove the object as well.
182 int irias_delete_attrib(struct ias_object *obj, struct ias_attrib *attrib,
185 struct ias_attrib *node;
187 ASSERT(obj != NULL, return -1;);
188 ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -1;);
189 ASSERT(attrib != NULL, return -1;);
191 /* Remove attribute from object */
192 node = hashbin_remove_this(obj->attribs, (irda_queue_t *) attrib);
194 return 0; /* Already removed or non-existent */
196 /* Deallocate attribute */
197 __irias_delete_attrib(node);
199 /* Check if object has still some attributes, destroy it if none.
200 * At first glance, this look dangerous, as the kernel reference
201 * various IAS objects. However, we only use this function on
202 * user attributes, not kernel attributes, so there is no risk
203 * of deleting a kernel object this way. Jean II */
204 node = (struct ias_attrib *) hashbin_get_first(obj->attribs);
205 if (cleanobject && !node)
206 irias_delete_object(obj);
212 * Function irias_insert_object (obj)
214 * Insert an object into the LM-IAS database
217 void irias_insert_object(struct ias_object *obj)
219 ASSERT(obj != NULL, return;);
220 ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
222 hashbin_insert(irias_objects, (irda_queue_t *) obj, 0, obj->name);
224 EXPORT_SYMBOL(irias_insert_object);
227 * Function irias_find_object (name)
229 * Find object with given name
232 struct ias_object *irias_find_object(char *name)
234 ASSERT(name != NULL, return NULL;);
236 /* Unsafe (locking), object might change */
237 return hashbin_lock_find(irias_objects, 0, name);
239 EXPORT_SYMBOL(irias_find_object);
242 * Function irias_find_attrib (obj, name)
244 * Find named attribute in object
247 struct ias_attrib *irias_find_attrib(struct ias_object *obj, char *name)
249 struct ias_attrib *attrib;
251 ASSERT(obj != NULL, return NULL;);
252 ASSERT(obj->magic == IAS_OBJECT_MAGIC, return NULL;);
253 ASSERT(name != NULL, return NULL;);
255 attrib = hashbin_lock_find(obj->attribs, 0, name);
259 /* Unsafe (locking), attrib might change */
262 EXPORT_SYMBOL(irias_find_attrib);
265 * Function irias_add_attribute (obj, attrib)
267 * Add attribute to object
270 void irias_add_attrib( struct ias_object *obj, struct ias_attrib *attrib,
273 ASSERT(obj != NULL, return;);
274 ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
276 ASSERT(attrib != NULL, return;);
277 ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, return;);
279 /* Set if attrib is owned by kernel or user space */
280 attrib->value->owner = owner;
282 hashbin_insert(obj->attribs, (irda_queue_t *) attrib, 0, attrib->name);
286 * Function irias_object_change_attribute (obj_name, attrib_name, new_value)
288 * Change the value of an objects attribute.
291 int irias_object_change_attribute(char *obj_name, char *attrib_name,
292 struct ias_value *new_value)
294 struct ias_object *obj;
295 struct ias_attrib *attrib;
299 obj = hashbin_lock_find(irias_objects, 0, obj_name);
301 WARNING("%s: Unable to find object: %s\n", __FUNCTION__,
306 /* Slightly unsafe (obj might get removed under us) */
307 spin_lock_irqsave(&obj->attribs->hb_spinlock, flags);
310 attrib = hashbin_find(obj->attribs, 0, attrib_name);
311 if (attrib == NULL) {
312 WARNING("%s: Unable to find attribute: %s\n", __FUNCTION__,
314 spin_unlock_irqrestore(&obj->attribs->hb_spinlock, flags);
318 if ( attrib->value->type != new_value->type) {
319 IRDA_DEBUG( 0, "%s(), changing value type not allowed!\n",
321 spin_unlock_irqrestore(&obj->attribs->hb_spinlock, flags);
325 /* Delete old value */
326 irias_delete_value(attrib->value);
328 /* Insert new value */
329 attrib->value = new_value;
332 spin_unlock_irqrestore(&obj->attribs->hb_spinlock, flags);
335 EXPORT_SYMBOL(irias_object_change_attribute);
338 * Function irias_object_add_integer_attrib (obj, name, value)
340 * Add an integer attribute to an LM-IAS object
343 void irias_add_integer_attrib(struct ias_object *obj, char *name, int value,
346 struct ias_attrib *attrib;
348 ASSERT(obj != NULL, return;);
349 ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
350 ASSERT(name != NULL, return;);
352 attrib = (struct ias_attrib *) kmalloc(sizeof(struct ias_attrib),
354 if (attrib == NULL) {
355 WARNING("%s: Unable to allocate attribute!\n", __FUNCTION__);
358 memset(attrib, 0, sizeof( struct ias_attrib));
360 attrib->magic = IAS_ATTRIB_MAGIC;
361 attrib->name = strndup(name, IAS_MAX_ATTRIBNAME);
364 attrib->value = irias_new_integer_value(value);
366 irias_add_attrib(obj, attrib, owner);
368 EXPORT_SYMBOL(irias_add_integer_attrib);
371 * Function irias_add_octseq_attrib (obj, name, octet_seq, len)
373 * Add a octet sequence attribute to an LM-IAS object
377 void irias_add_octseq_attrib(struct ias_object *obj, char *name, __u8 *octets,
380 struct ias_attrib *attrib;
382 ASSERT(obj != NULL, return;);
383 ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
385 ASSERT(name != NULL, return;);
386 ASSERT(octets != NULL, return;);
388 attrib = (struct ias_attrib *) kmalloc(sizeof(struct ias_attrib),
390 if (attrib == NULL) {
391 WARNING("%s: Unable to allocate attribute!\n", __FUNCTION__);
394 memset(attrib, 0, sizeof( struct ias_attrib));
396 attrib->magic = IAS_ATTRIB_MAGIC;
397 attrib->name = strndup(name, IAS_MAX_ATTRIBNAME);
399 attrib->value = irias_new_octseq_value( octets, len);
401 irias_add_attrib(obj, attrib, owner);
403 EXPORT_SYMBOL(irias_add_octseq_attrib);
406 * Function irias_object_add_string_attrib (obj, string)
408 * Add a string attribute to an LM-IAS object
411 void irias_add_string_attrib(struct ias_object *obj, char *name, char *value,
414 struct ias_attrib *attrib;
416 ASSERT(obj != NULL, return;);
417 ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
419 ASSERT(name != NULL, return;);
420 ASSERT(value != NULL, return;);
422 attrib = (struct ias_attrib *) kmalloc(sizeof( struct ias_attrib),
424 if (attrib == NULL) {
425 WARNING("%s: Unable to allocate attribute!\n", __FUNCTION__);
428 memset(attrib, 0, sizeof( struct ias_attrib));
430 attrib->magic = IAS_ATTRIB_MAGIC;
431 attrib->name = strndup(name, IAS_MAX_ATTRIBNAME);
433 attrib->value = irias_new_string_value(value);
435 irias_add_attrib(obj, attrib, owner);
437 EXPORT_SYMBOL(irias_add_string_attrib);
440 * Function irias_new_integer_value (integer)
442 * Create new IAS integer value
445 struct ias_value *irias_new_integer_value(int integer)
447 struct ias_value *value;
449 value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
451 WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
454 memset(value, 0, sizeof(struct ias_value));
456 value->type = IAS_INTEGER;
458 value->t.integer = integer;
462 EXPORT_SYMBOL(irias_new_integer_value);
465 * Function irias_new_string_value (string)
467 * Create new IAS string value
469 * Per IrLMP 1.1, 4.3.3.2, strings are up to 256 chars - Jean II
471 struct ias_value *irias_new_string_value(char *string)
473 struct ias_value *value;
475 value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
477 WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
480 memset( value, 0, sizeof( struct ias_value));
482 value->type = IAS_STRING;
483 value->charset = CS_ASCII;
484 value->t.string = strndup(string, IAS_MAX_STRING);
485 value->len = strlen(value->t.string);
489 EXPORT_SYMBOL(irias_new_string_value);
492 * Function irias_new_octseq_value (octets, len)
494 * Create new IAS octet-sequence value
496 * Per IrLMP 1.1, 4.3.3.2, octet-sequence are up to 1024 bytes - Jean II
498 struct ias_value *irias_new_octseq_value(__u8 *octseq , int len)
500 struct ias_value *value;
502 value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
504 WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
507 memset(value, 0, sizeof(struct ias_value));
509 value->type = IAS_OCT_SEQ;
511 if(len > IAS_MAX_OCTET_STRING)
512 len = IAS_MAX_OCTET_STRING;
515 value->t.oct_seq = kmalloc(len, GFP_ATOMIC);
516 if (value->t.oct_seq == NULL){
517 WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
521 memcpy(value->t.oct_seq, octseq , len);
524 EXPORT_SYMBOL(irias_new_octseq_value);
526 struct ias_value *irias_new_missing_value(void)
528 struct ias_value *value;
530 value = kmalloc(sizeof(struct ias_value), GFP_ATOMIC);
532 WARNING("%s: Unable to kmalloc!\n", __FUNCTION__);
535 memset(value, 0, sizeof(struct ias_value));
537 value->type = IAS_MISSING;
544 * Function irias_delete_value (value)
549 void irias_delete_value(struct ias_value *value)
551 IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
553 ASSERT(value != NULL, return;);
555 switch (value->type) {
556 case IAS_INTEGER: /* Fallthrough */
558 /* No need to deallocate */
561 /* If string, deallocate string */
562 if (value->t.string != NULL)
563 kfree(value->t.string);
566 /* If byte stream, deallocate byte stream */
567 if (value->t.oct_seq != NULL)
568 kfree(value->t.oct_seq);
571 IRDA_DEBUG(0, "%s(), Unknown value type!\n", __FUNCTION__);
576 EXPORT_SYMBOL(irias_delete_value);