Loading...
Note: File does not exist in v4.17.
1/*********************************************************************
2 *
3 * Filename: irias_object.c
4 * Version: 0.3
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>
11 *
12 * Copyright (c) 1998-1999 Dag Brattli, All Rights Reserved.
13 *
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.
18 *
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.
22 *
23 ********************************************************************/
24
25#include <linux/slab.h>
26#include <linux/string.h>
27#include <linux/socket.h>
28#include <linux/module.h>
29
30#include <net/irda/irda.h>
31#include <net/irda/irias_object.h>
32
33hashbin_t *irias_objects;
34
35/*
36 * Used when a missing value needs to be returned
37 */
38struct ias_value irias_missing = { IAS_MISSING, 0, 0, 0, {0}};
39
40
41/*
42 * Function ias_new_object (name, id)
43 *
44 * Create a new IAS object
45 *
46 */
47struct ias_object *irias_new_object( char *name, int id)
48{
49 struct ias_object *obj;
50
51 IRDA_DEBUG( 4, "%s()\n", __func__);
52
53 obj = kzalloc(sizeof(struct ias_object), GFP_ATOMIC);
54 if (obj == NULL) {
55 IRDA_WARNING("%s(), Unable to allocate object!\n",
56 __func__);
57 return NULL;
58 }
59
60 obj->magic = IAS_OBJECT_MAGIC;
61 obj->name = kstrndup(name, IAS_MAX_CLASSNAME, GFP_ATOMIC);
62 if (!obj->name) {
63 IRDA_WARNING("%s(), Unable to allocate name!\n",
64 __func__);
65 kfree(obj);
66 return NULL;
67 }
68 obj->id = id;
69
70 /* Locking notes : the attrib spinlock has lower precendence
71 * than the objects spinlock. Never grap the objects spinlock
72 * while holding any attrib spinlock (risk of deadlock). Jean II */
73 obj->attribs = hashbin_new(HB_LOCK);
74
75 if (obj->attribs == NULL) {
76 IRDA_WARNING("%s(), Unable to allocate attribs!\n",
77 __func__);
78 kfree(obj->name);
79 kfree(obj);
80 return NULL;
81 }
82
83 return obj;
84}
85EXPORT_SYMBOL(irias_new_object);
86
87/*
88 * Function irias_delete_attrib (attrib)
89 *
90 * Delete given attribute and deallocate all its memory
91 *
92 */
93static void __irias_delete_attrib(struct ias_attrib *attrib)
94{
95 IRDA_ASSERT(attrib != NULL, return;);
96 IRDA_ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, return;);
97
98 kfree(attrib->name);
99
100 irias_delete_value(attrib->value);
101 attrib->magic = ~IAS_ATTRIB_MAGIC;
102
103 kfree(attrib);
104}
105
106void __irias_delete_object(struct ias_object *obj)
107{
108 IRDA_ASSERT(obj != NULL, return;);
109 IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
110
111 kfree(obj->name);
112
113 hashbin_delete(obj->attribs, (FREE_FUNC) __irias_delete_attrib);
114
115 obj->magic = ~IAS_OBJECT_MAGIC;
116
117 kfree(obj);
118}
119
120/*
121 * Function irias_delete_object (obj)
122 *
123 * Remove object from hashbin and deallocate all attributes associated with
124 * with this object and the object itself
125 *
126 */
127int irias_delete_object(struct ias_object *obj)
128{
129 struct ias_object *node;
130
131 IRDA_ASSERT(obj != NULL, return -1;);
132 IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -1;);
133
134 /* Remove from list */
135 node = hashbin_remove_this(irias_objects, (irda_queue_t *) obj);
136 if (!node)
137 IRDA_DEBUG( 0, "%s(), object already removed!\n",
138 __func__);
139
140 /* Destroy */
141 __irias_delete_object(obj);
142
143 return 0;
144}
145EXPORT_SYMBOL(irias_delete_object);
146
147/*
148 * Function irias_delete_attrib (obj)
149 *
150 * Remove attribute from hashbin and, if it was the last attribute of
151 * the object, remove the object as well.
152 *
153 */
154int irias_delete_attrib(struct ias_object *obj, struct ias_attrib *attrib,
155 int cleanobject)
156{
157 struct ias_attrib *node;
158
159 IRDA_ASSERT(obj != NULL, return -1;);
160 IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -1;);
161 IRDA_ASSERT(attrib != NULL, return -1;);
162
163 /* Remove attribute from object */
164 node = hashbin_remove_this(obj->attribs, (irda_queue_t *) attrib);
165 if (!node)
166 return 0; /* Already removed or non-existent */
167
168 /* Deallocate attribute */
169 __irias_delete_attrib(node);
170
171 /* Check if object has still some attributes, destroy it if none.
172 * At first glance, this look dangerous, as the kernel reference
173 * various IAS objects. However, we only use this function on
174 * user attributes, not kernel attributes, so there is no risk
175 * of deleting a kernel object this way. Jean II */
176 node = (struct ias_attrib *) hashbin_get_first(obj->attribs);
177 if (cleanobject && !node)
178 irias_delete_object(obj);
179
180 return 0;
181}
182
183/*
184 * Function irias_insert_object (obj)
185 *
186 * Insert an object into the LM-IAS database
187 *
188 */
189void irias_insert_object(struct ias_object *obj)
190{
191 IRDA_ASSERT(obj != NULL, return;);
192 IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
193
194 hashbin_insert(irias_objects, (irda_queue_t *) obj, 0, obj->name);
195}
196EXPORT_SYMBOL(irias_insert_object);
197
198/*
199 * Function irias_find_object (name)
200 *
201 * Find object with given name
202 *
203 */
204struct ias_object *irias_find_object(char *name)
205{
206 IRDA_ASSERT(name != NULL, return NULL;);
207
208 /* Unsafe (locking), object might change */
209 return hashbin_lock_find(irias_objects, 0, name);
210}
211EXPORT_SYMBOL(irias_find_object);
212
213/*
214 * Function irias_find_attrib (obj, name)
215 *
216 * Find named attribute in object
217 *
218 */
219struct ias_attrib *irias_find_attrib(struct ias_object *obj, char *name)
220{
221 struct ias_attrib *attrib;
222
223 IRDA_ASSERT(obj != NULL, return NULL;);
224 IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return NULL;);
225 IRDA_ASSERT(name != NULL, return NULL;);
226
227 attrib = hashbin_lock_find(obj->attribs, 0, name);
228 if (attrib == NULL)
229 return NULL;
230
231 /* Unsafe (locking), attrib might change */
232 return attrib;
233}
234
235/*
236 * Function irias_add_attribute (obj, attrib)
237 *
238 * Add attribute to object
239 *
240 */
241static void irias_add_attrib(struct ias_object *obj, struct ias_attrib *attrib,
242 int owner)
243{
244 IRDA_ASSERT(obj != NULL, return;);
245 IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
246
247 IRDA_ASSERT(attrib != NULL, return;);
248 IRDA_ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, return;);
249
250 /* Set if attrib is owned by kernel or user space */
251 attrib->value->owner = owner;
252
253 hashbin_insert(obj->attribs, (irda_queue_t *) attrib, 0, attrib->name);
254}
255
256/*
257 * Function irias_object_change_attribute (obj_name, attrib_name, new_value)
258 *
259 * Change the value of an objects attribute.
260 *
261 */
262int irias_object_change_attribute(char *obj_name, char *attrib_name,
263 struct ias_value *new_value)
264{
265 struct ias_object *obj;
266 struct ias_attrib *attrib;
267 unsigned long flags;
268
269 /* Find object */
270 obj = hashbin_lock_find(irias_objects, 0, obj_name);
271 if (obj == NULL) {
272 IRDA_WARNING("%s: Unable to find object: %s\n", __func__,
273 obj_name);
274 return -1;
275 }
276
277 /* Slightly unsafe (obj might get removed under us) */
278 spin_lock_irqsave(&obj->attribs->hb_spinlock, flags);
279
280 /* Find attribute */
281 attrib = hashbin_find(obj->attribs, 0, attrib_name);
282 if (attrib == NULL) {
283 IRDA_WARNING("%s: Unable to find attribute: %s\n",
284 __func__, attrib_name);
285 spin_unlock_irqrestore(&obj->attribs->hb_spinlock, flags);
286 return -1;
287 }
288
289 if ( attrib->value->type != new_value->type) {
290 IRDA_DEBUG( 0, "%s(), changing value type not allowed!\n",
291 __func__);
292 spin_unlock_irqrestore(&obj->attribs->hb_spinlock, flags);
293 return -1;
294 }
295
296 /* Delete old value */
297 irias_delete_value(attrib->value);
298
299 /* Insert new value */
300 attrib->value = new_value;
301
302 /* Success */
303 spin_unlock_irqrestore(&obj->attribs->hb_spinlock, flags);
304 return 0;
305}
306EXPORT_SYMBOL(irias_object_change_attribute);
307
308/*
309 * Function irias_object_add_integer_attrib (obj, name, value)
310 *
311 * Add an integer attribute to an LM-IAS object
312 *
313 */
314void irias_add_integer_attrib(struct ias_object *obj, char *name, int value,
315 int owner)
316{
317 struct ias_attrib *attrib;
318
319 IRDA_ASSERT(obj != NULL, return;);
320 IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
321 IRDA_ASSERT(name != NULL, return;);
322
323 attrib = kzalloc(sizeof(struct ias_attrib), GFP_ATOMIC);
324 if (attrib == NULL) {
325 IRDA_WARNING("%s: Unable to allocate attribute!\n",
326 __func__);
327 return;
328 }
329
330 attrib->magic = IAS_ATTRIB_MAGIC;
331 attrib->name = kstrndup(name, IAS_MAX_ATTRIBNAME, GFP_ATOMIC);
332
333 /* Insert value */
334 attrib->value = irias_new_integer_value(value);
335 if (!attrib->name || !attrib->value) {
336 IRDA_WARNING("%s: Unable to allocate attribute!\n",
337 __func__);
338 if (attrib->value)
339 irias_delete_value(attrib->value);
340 kfree(attrib->name);
341 kfree(attrib);
342 return;
343 }
344
345 irias_add_attrib(obj, attrib, owner);
346}
347EXPORT_SYMBOL(irias_add_integer_attrib);
348
349 /*
350 * Function irias_add_octseq_attrib (obj, name, octet_seq, len)
351 *
352 * Add a octet sequence attribute to an LM-IAS object
353 *
354 */
355
356void irias_add_octseq_attrib(struct ias_object *obj, char *name, __u8 *octets,
357 int len, int owner)
358{
359 struct ias_attrib *attrib;
360
361 IRDA_ASSERT(obj != NULL, return;);
362 IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
363
364 IRDA_ASSERT(name != NULL, return;);
365 IRDA_ASSERT(octets != NULL, return;);
366
367 attrib = kzalloc(sizeof(struct ias_attrib), GFP_ATOMIC);
368 if (attrib == NULL) {
369 IRDA_WARNING("%s: Unable to allocate attribute!\n",
370 __func__);
371 return;
372 }
373
374 attrib->magic = IAS_ATTRIB_MAGIC;
375 attrib->name = kstrndup(name, IAS_MAX_ATTRIBNAME, GFP_ATOMIC);
376
377 attrib->value = irias_new_octseq_value( octets, len);
378 if (!attrib->name || !attrib->value) {
379 IRDA_WARNING("%s: Unable to allocate attribute!\n",
380 __func__);
381 if (attrib->value)
382 irias_delete_value(attrib->value);
383 kfree(attrib->name);
384 kfree(attrib);
385 return;
386 }
387
388 irias_add_attrib(obj, attrib, owner);
389}
390EXPORT_SYMBOL(irias_add_octseq_attrib);
391
392/*
393 * Function irias_object_add_string_attrib (obj, string)
394 *
395 * Add a string attribute to an LM-IAS object
396 *
397 */
398void irias_add_string_attrib(struct ias_object *obj, char *name, char *value,
399 int owner)
400{
401 struct ias_attrib *attrib;
402
403 IRDA_ASSERT(obj != NULL, return;);
404 IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return;);
405
406 IRDA_ASSERT(name != NULL, return;);
407 IRDA_ASSERT(value != NULL, return;);
408
409 attrib = kzalloc(sizeof( struct ias_attrib), GFP_ATOMIC);
410 if (attrib == NULL) {
411 IRDA_WARNING("%s: Unable to allocate attribute!\n",
412 __func__);
413 return;
414 }
415
416 attrib->magic = IAS_ATTRIB_MAGIC;
417 attrib->name = kstrndup(name, IAS_MAX_ATTRIBNAME, GFP_ATOMIC);
418
419 attrib->value = irias_new_string_value(value);
420 if (!attrib->name || !attrib->value) {
421 IRDA_WARNING("%s: Unable to allocate attribute!\n",
422 __func__);
423 if (attrib->value)
424 irias_delete_value(attrib->value);
425 kfree(attrib->name);
426 kfree(attrib);
427 return;
428 }
429
430 irias_add_attrib(obj, attrib, owner);
431}
432EXPORT_SYMBOL(irias_add_string_attrib);
433
434/*
435 * Function irias_new_integer_value (integer)
436 *
437 * Create new IAS integer value
438 *
439 */
440struct ias_value *irias_new_integer_value(int integer)
441{
442 struct ias_value *value;
443
444 value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC);
445 if (value == NULL) {
446 IRDA_WARNING("%s: Unable to kmalloc!\n", __func__);
447 return NULL;
448 }
449
450 value->type = IAS_INTEGER;
451 value->len = 4;
452 value->t.integer = integer;
453
454 return value;
455}
456EXPORT_SYMBOL(irias_new_integer_value);
457
458/*
459 * Function irias_new_string_value (string)
460 *
461 * Create new IAS string value
462 *
463 * Per IrLMP 1.1, 4.3.3.2, strings are up to 256 chars - Jean II
464 */
465struct ias_value *irias_new_string_value(char *string)
466{
467 struct ias_value *value;
468
469 value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC);
470 if (value == NULL) {
471 IRDA_WARNING("%s: Unable to kmalloc!\n", __func__);
472 return NULL;
473 }
474
475 value->type = IAS_STRING;
476 value->charset = CS_ASCII;
477 value->t.string = kstrndup(string, IAS_MAX_STRING, GFP_ATOMIC);
478 if (!value->t.string) {
479 IRDA_WARNING("%s: Unable to kmalloc!\n", __func__);
480 kfree(value);
481 return NULL;
482 }
483
484 value->len = strlen(value->t.string);
485
486 return value;
487}
488
489/*
490 * Function irias_new_octseq_value (octets, len)
491 *
492 * Create new IAS octet-sequence value
493 *
494 * Per IrLMP 1.1, 4.3.3.2, octet-sequence are up to 1024 bytes - Jean II
495 */
496struct ias_value *irias_new_octseq_value(__u8 *octseq , int len)
497{
498 struct ias_value *value;
499
500 value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC);
501 if (value == NULL) {
502 IRDA_WARNING("%s: Unable to kmalloc!\n", __func__);
503 return NULL;
504 }
505
506 value->type = IAS_OCT_SEQ;
507 /* Check length */
508 if(len > IAS_MAX_OCTET_STRING)
509 len = IAS_MAX_OCTET_STRING;
510 value->len = len;
511
512 value->t.oct_seq = kmemdup(octseq, len, GFP_ATOMIC);
513 if (value->t.oct_seq == NULL){
514 IRDA_WARNING("%s: Unable to kmalloc!\n", __func__);
515 kfree(value);
516 return NULL;
517 }
518 return value;
519}
520
521struct ias_value *irias_new_missing_value(void)
522{
523 struct ias_value *value;
524
525 value = kzalloc(sizeof(struct ias_value), GFP_ATOMIC);
526 if (value == NULL) {
527 IRDA_WARNING("%s: Unable to kmalloc!\n", __func__);
528 return NULL;
529 }
530
531 value->type = IAS_MISSING;
532
533 return value;
534}
535
536/*
537 * Function irias_delete_value (value)
538 *
539 * Delete IAS value
540 *
541 */
542void irias_delete_value(struct ias_value *value)
543{
544 IRDA_DEBUG(4, "%s()\n", __func__);
545
546 IRDA_ASSERT(value != NULL, return;);
547
548 switch (value->type) {
549 case IAS_INTEGER: /* Fallthrough */
550 case IAS_MISSING:
551 /* No need to deallocate */
552 break;
553 case IAS_STRING:
554 /* Deallocate string */
555 kfree(value->t.string);
556 break;
557 case IAS_OCT_SEQ:
558 /* Deallocate byte stream */
559 kfree(value->t.oct_seq);
560 break;
561 default:
562 IRDA_DEBUG(0, "%s(), Unknown value type!\n", __func__);
563 break;
564 }
565 kfree(value);
566}
567EXPORT_SYMBOL(irias_delete_value);