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 IRDA_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 IRDA_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 IRDA_WARNING("%s(), Unable to allocate attribs!\n",
112 EXPORT_SYMBOL(irias_new_object
);
115 * Function irias_delete_attrib (attrib)
117 * Delete given attribute and deallocate all its memory
120 static void __irias_delete_attrib(struct ias_attrib
*attrib
)
122 IRDA_ASSERT(attrib
!= NULL
, return;);
123 IRDA_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 IRDA_ASSERT(obj
!= NULL
, return;);
136 IRDA_ASSERT(obj
->magic
== IAS_OBJECT_MAGIC
, return;);
140 hashbin_delete(obj
->attribs
, (FREE_FUNC
) __irias_delete_attrib
);
142 obj
->magic
= ~IAS_OBJECT_MAGIC
;
148 * Function irias_delete_object (obj)
150 * Remove object from hashbin and deallocate all attributes associated with
151 * with this object and the object itself
154 int irias_delete_object(struct ias_object
*obj
)
156 struct ias_object
*node
;
158 IRDA_ASSERT(obj
!= NULL
, return -1;);
159 IRDA_ASSERT(obj
->magic
== IAS_OBJECT_MAGIC
, return -1;);
161 /* Remove from list */
162 node
= hashbin_remove_this(irias_objects
, (irda_queue_t
*) obj
);
164 IRDA_DEBUG( 0, "%s(), object already removed!\n",
168 __irias_delete_object(obj
);
172 EXPORT_SYMBOL(irias_delete_object
);
175 * Function irias_delete_attrib (obj)
177 * Remove attribute from hashbin and, if it was the last attribute of
178 * the object, remove the object as well.
181 int irias_delete_attrib(struct ias_object
*obj
, struct ias_attrib
*attrib
,
184 struct ias_attrib
*node
;
186 IRDA_ASSERT(obj
!= NULL
, return -1;);
187 IRDA_ASSERT(obj
->magic
== IAS_OBJECT_MAGIC
, return -1;);
188 IRDA_ASSERT(attrib
!= NULL
, return -1;);
190 /* Remove attribute from object */
191 node
= hashbin_remove_this(obj
->attribs
, (irda_queue_t
*) attrib
);
193 return 0; /* Already removed or non-existent */
195 /* Deallocate attribute */
196 __irias_delete_attrib(node
);
198 /* Check if object has still some attributes, destroy it if none.
199 * At first glance, this look dangerous, as the kernel reference
200 * various IAS objects. However, we only use this function on
201 * user attributes, not kernel attributes, so there is no risk
202 * of deleting a kernel object this way. Jean II */
203 node
= (struct ias_attrib
*) hashbin_get_first(obj
->attribs
);
204 if (cleanobject
&& !node
)
205 irias_delete_object(obj
);
211 * Function irias_insert_object (obj)
213 * Insert an object into the LM-IAS database
216 void irias_insert_object(struct ias_object
*obj
)
218 IRDA_ASSERT(obj
!= NULL
, return;);
219 IRDA_ASSERT(obj
->magic
== IAS_OBJECT_MAGIC
, return;);
221 hashbin_insert(irias_objects
, (irda_queue_t
*) obj
, 0, obj
->name
);
223 EXPORT_SYMBOL(irias_insert_object
);
226 * Function irias_find_object (name)
228 * Find object with given name
231 struct ias_object
*irias_find_object(char *name
)
233 IRDA_ASSERT(name
!= NULL
, return NULL
;);
235 /* Unsafe (locking), object might change */
236 return hashbin_lock_find(irias_objects
, 0, name
);
238 EXPORT_SYMBOL(irias_find_object
);
241 * Function irias_find_attrib (obj, name)
243 * Find named attribute in object
246 struct ias_attrib
*irias_find_attrib(struct ias_object
*obj
, char *name
)
248 struct ias_attrib
*attrib
;
250 IRDA_ASSERT(obj
!= NULL
, return NULL
;);
251 IRDA_ASSERT(obj
->magic
== IAS_OBJECT_MAGIC
, return NULL
;);
252 IRDA_ASSERT(name
!= NULL
, return NULL
;);
254 attrib
= hashbin_lock_find(obj
->attribs
, 0, name
);
258 /* Unsafe (locking), attrib might change */
261 EXPORT_SYMBOL(irias_find_attrib
);
264 * Function irias_add_attribute (obj, attrib)
266 * Add attribute to object
269 static void irias_add_attrib(struct ias_object
*obj
, struct ias_attrib
*attrib
,
272 IRDA_ASSERT(obj
!= NULL
, return;);
273 IRDA_ASSERT(obj
->magic
== IAS_OBJECT_MAGIC
, return;);
275 IRDA_ASSERT(attrib
!= NULL
, return;);
276 IRDA_ASSERT(attrib
->magic
== IAS_ATTRIB_MAGIC
, return;);
278 /* Set if attrib is owned by kernel or user space */
279 attrib
->value
->owner
= owner
;
281 hashbin_insert(obj
->attribs
, (irda_queue_t
*) attrib
, 0, attrib
->name
);
285 * Function irias_object_change_attribute (obj_name, attrib_name, new_value)
287 * Change the value of an objects attribute.
290 int irias_object_change_attribute(char *obj_name
, char *attrib_name
,
291 struct ias_value
*new_value
)
293 struct ias_object
*obj
;
294 struct ias_attrib
*attrib
;
298 obj
= hashbin_lock_find(irias_objects
, 0, obj_name
);
300 IRDA_WARNING("%s: Unable to find object: %s\n", __FUNCTION__
,
305 /* Slightly unsafe (obj might get removed under us) */
306 spin_lock_irqsave(&obj
->attribs
->hb_spinlock
, flags
);
309 attrib
= hashbin_find(obj
->attribs
, 0, attrib_name
);
310 if (attrib
== NULL
) {
311 IRDA_WARNING("%s: Unable to find attribute: %s\n",
312 __FUNCTION__
, attrib_name
);
313 spin_unlock_irqrestore(&obj
->attribs
->hb_spinlock
, flags
);
317 if ( attrib
->value
->type
!= new_value
->type
) {
318 IRDA_DEBUG( 0, "%s(), changing value type not allowed!\n",
320 spin_unlock_irqrestore(&obj
->attribs
->hb_spinlock
, flags
);
324 /* Delete old value */
325 irias_delete_value(attrib
->value
);
327 /* Insert new value */
328 attrib
->value
= new_value
;
331 spin_unlock_irqrestore(&obj
->attribs
->hb_spinlock
, flags
);
334 EXPORT_SYMBOL(irias_object_change_attribute
);
337 * Function irias_object_add_integer_attrib (obj, name, value)
339 * Add an integer attribute to an LM-IAS object
342 void irias_add_integer_attrib(struct ias_object
*obj
, char *name
, int value
,
345 struct ias_attrib
*attrib
;
347 IRDA_ASSERT(obj
!= NULL
, return;);
348 IRDA_ASSERT(obj
->magic
== IAS_OBJECT_MAGIC
, return;);
349 IRDA_ASSERT(name
!= NULL
, return;);
351 attrib
= (struct ias_attrib
*) kmalloc(sizeof(struct ias_attrib
),
353 if (attrib
== NULL
) {
354 IRDA_WARNING("%s: Unable to allocate attribute!\n",
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 IRDA_ASSERT(obj
!= NULL
, return;);
383 IRDA_ASSERT(obj
->magic
== IAS_OBJECT_MAGIC
, return;);
385 IRDA_ASSERT(name
!= NULL
, return;);
386 IRDA_ASSERT(octets
!= NULL
, return;);
388 attrib
= (struct ias_attrib
*) kmalloc(sizeof(struct ias_attrib
),
390 if (attrib
== NULL
) {
391 IRDA_WARNING("%s: Unable to allocate attribute!\n",
395 memset(attrib
, 0, sizeof( struct ias_attrib
));
397 attrib
->magic
= IAS_ATTRIB_MAGIC
;
398 attrib
->name
= strndup(name
, IAS_MAX_ATTRIBNAME
);
400 attrib
->value
= irias_new_octseq_value( octets
, len
);
402 irias_add_attrib(obj
, attrib
, owner
);
404 EXPORT_SYMBOL(irias_add_octseq_attrib
);
407 * Function irias_object_add_string_attrib (obj, string)
409 * Add a string attribute to an LM-IAS object
412 void irias_add_string_attrib(struct ias_object
*obj
, char *name
, char *value
,
415 struct ias_attrib
*attrib
;
417 IRDA_ASSERT(obj
!= NULL
, return;);
418 IRDA_ASSERT(obj
->magic
== IAS_OBJECT_MAGIC
, return;);
420 IRDA_ASSERT(name
!= NULL
, return;);
421 IRDA_ASSERT(value
!= NULL
, return;);
423 attrib
= (struct ias_attrib
*) kmalloc(sizeof( struct ias_attrib
),
425 if (attrib
== NULL
) {
426 IRDA_WARNING("%s: Unable to allocate attribute!\n",
430 memset(attrib
, 0, sizeof( struct ias_attrib
));
432 attrib
->magic
= IAS_ATTRIB_MAGIC
;
433 attrib
->name
= strndup(name
, IAS_MAX_ATTRIBNAME
);
435 attrib
->value
= irias_new_string_value(value
);
437 irias_add_attrib(obj
, attrib
, owner
);
439 EXPORT_SYMBOL(irias_add_string_attrib
);
442 * Function irias_new_integer_value (integer)
444 * Create new IAS integer value
447 struct ias_value
*irias_new_integer_value(int integer
)
449 struct ias_value
*value
;
451 value
= kmalloc(sizeof(struct ias_value
), GFP_ATOMIC
);
453 IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__
);
456 memset(value
, 0, sizeof(struct ias_value
));
458 value
->type
= IAS_INTEGER
;
460 value
->t
.integer
= integer
;
464 EXPORT_SYMBOL(irias_new_integer_value
);
467 * Function irias_new_string_value (string)
469 * Create new IAS string value
471 * Per IrLMP 1.1, 4.3.3.2, strings are up to 256 chars - Jean II
473 struct ias_value
*irias_new_string_value(char *string
)
475 struct ias_value
*value
;
477 value
= kmalloc(sizeof(struct ias_value
), GFP_ATOMIC
);
479 IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__
);
482 memset( value
, 0, sizeof( struct ias_value
));
484 value
->type
= IAS_STRING
;
485 value
->charset
= CS_ASCII
;
486 value
->t
.string
= strndup(string
, IAS_MAX_STRING
);
487 value
->len
= strlen(value
->t
.string
);
491 EXPORT_SYMBOL(irias_new_string_value
);
494 * Function irias_new_octseq_value (octets, len)
496 * Create new IAS octet-sequence value
498 * Per IrLMP 1.1, 4.3.3.2, octet-sequence are up to 1024 bytes - Jean II
500 struct ias_value
*irias_new_octseq_value(__u8
*octseq
, int len
)
502 struct ias_value
*value
;
504 value
= kmalloc(sizeof(struct ias_value
), GFP_ATOMIC
);
506 IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__
);
509 memset(value
, 0, sizeof(struct ias_value
));
511 value
->type
= IAS_OCT_SEQ
;
513 if(len
> IAS_MAX_OCTET_STRING
)
514 len
= IAS_MAX_OCTET_STRING
;
517 value
->t
.oct_seq
= kmalloc(len
, GFP_ATOMIC
);
518 if (value
->t
.oct_seq
== NULL
){
519 IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__
);
523 memcpy(value
->t
.oct_seq
, octseq
, len
);
526 EXPORT_SYMBOL(irias_new_octseq_value
);
528 struct ias_value
*irias_new_missing_value(void)
530 struct ias_value
*value
;
532 value
= kmalloc(sizeof(struct ias_value
), GFP_ATOMIC
);
534 IRDA_WARNING("%s: Unable to kmalloc!\n", __FUNCTION__
);
537 memset(value
, 0, sizeof(struct ias_value
));
539 value
->type
= IAS_MISSING
;
546 * Function irias_delete_value (value)
551 void irias_delete_value(struct ias_value
*value
)
553 IRDA_DEBUG(4, "%s()\n", __FUNCTION__
);
555 IRDA_ASSERT(value
!= NULL
, return;);
557 switch (value
->type
) {
558 case IAS_INTEGER
: /* Fallthrough */
560 /* No need to deallocate */
563 /* Deallocate string */
564 kfree(value
->t
.string
);
567 /* Deallocate byte stream */
568 kfree(value
->t
.oct_seq
);
571 IRDA_DEBUG(0, "%s(), Unknown value type!\n", __FUNCTION__
);
576 EXPORT_SYMBOL(irias_delete_value
);