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/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
  33 hashbin_t *irias_objects;
  34
  35 /*
  36  *  Used when a missing value needs to be returned
  37  */
  38 struct 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  */
  47 struct 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 }
  85 EXPORT_SYMBOL(irias_new_object);
  86
  87 /*
  88  * Function irias_delete_attrib (attrib)
  89  *
  90  *    Delete given attribute and deallocate all its memory
  91  *
  92  */
  93 static 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
 106 void __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  */
 127 int 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 }
 145 EXPORT_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  */
 154 int 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  */
 189 void 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 }
 196 EXPORT_SYMBOL(irias_insert_object);
 197
 198 /*
 199  * Function irias_find_object (name)
 200  *
 201  *    Find object with given name
 202  *
 203  */
 204 struct 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 }
 211 EXPORT_SYMBOL(irias_find_object);
 212
 213 /*
 214  * Function irias_find_attrib (obj, name)
 215  *
 216  *    Find named attribute in object
 217  *
 218  */
 219 struct 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  */
 241 static 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  */
 262 int 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 }
 306 EXPORT_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  */
 314 void 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 }
 347 EXPORT_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
 356 void 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 }
 390 EXPORT_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  */
 398 void 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 }
 432 EXPORT_SYMBOL(irias_add_string_attrib);
 433
 434 /*
 435  * Function irias_new_integer_value (integer)
 436  *
 437  *    Create new IAS integer value
 438  *
 439  */
 440 struct 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 }
 456 EXPORT_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  */
 465 struct 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  */
 496 struct 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
 521 struct 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  */
 542 void 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 }
 567 EXPORT_SYMBOL(irias_delete_value);