net/irda/irias_object.c

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