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