lib/silccore/silcattrs.c

   1 /*
   2
   3   silcattrs.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 2002 Pekka Riikonen
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; version 2 of the License.
  12
  13   This program is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18 */
  19 /* Implementation of Attribute Payload routines */
  20 /* $Id$ */
  21
  22 #include "silcincludes.h"
  23 #include "silcattrs.h"
  24
  25 /******************************************************************************
  26
  27                              Attribute Payload
  28
  29 ******************************************************************************/
  30
  31 struct SilcAttributePayloadStruct {
  32   SilcAttribute attribute;
  33   SilcAttributeFlags flags;
  34   SilcUInt16 data_len;
  35   unsigned char *data;
  36 };
  37
  38 /* Internal routine for encoding a attribute */
  39
  40 static unsigned char *
  41 silc_attribute_payload_encode_int(SilcAttribute attribute,
  42                                   SilcAttributeFlags flags,
  43                                   void *object,
  44                                   SilcUInt32 object_size,
  45                                   SilcUInt32 *ret_len)
  46 {
  47   SilcBuffer tmpbuf = NULL;
  48   unsigned char tmp[4], *str = NULL, *ret;
  49   int len;
  50
  51   /* Encode according to attribute type */
  52   if (flags & SILC_ATTRIBUTE_FLAG_VALID) {
  53     if (!object && !object_size)
  54       return NULL;
  55
  56     switch (attribute) {
  57
  58     case SILC_ATTRIBUTE_USER_INFO:
  59       {
  60         SilcVCard vcard = object;
  61         if (object_size != sizeof(*vcard))
  62           return NULL;
  63         str = silc_vcard_encode(vcard, &object_size);
  64         if (!str)
  65           return NULL;
  66         object = str;
  67       }
  68       break;
  69
  70     case SILC_ATTRIBUTE_SERVICE:
  71       {
  72         SilcAttributeObjService *service = object;
  73         if (object_size != sizeof(*service))
  74           return NULL;
  75         len = strlen(service->address);
  76         str = silc_malloc(7 + len);
  77         if (!str)
  78           return NULL;
  79         SILC_PUT32_MSB(service->port, str);
  80         SILC_PUT16_MSB(len, str + 4);
  81         memcpy(str + 6, service->address, len);
  82         str[6 + len] = service->status;
  83         object = str;
  84         object_size = 7 + len;
  85       }
  86       break;
  87
  88     case SILC_ATTRIBUTE_STATUS_MOOD:
  89     case SILC_ATTRIBUTE_PREFERRED_CONTACT:
  90       {
  91         SilcUInt32 mask = (SilcUInt32)object;
  92         if (object_size != sizeof(SilcUInt32))
  93           return NULL;
  94         SILC_PUT32_MSB(mask, tmp);
  95         object = tmp;
  96         object_size = sizeof(SilcUInt32);
  97       }
  98       break;
  99
 100     case SILC_ATTRIBUTE_STATUS_FREETEXT:
 101     case SILC_ATTRIBUTE_PREFERRED_LANGUAGE:
 102     case SILC_ATTRIBUTE_TIMEZONE:
 103       {
 104         unsigned char *string = object;
 105         str = silc_malloc(2 + object_size);
 106         if (!str)
 107           return NULL;
 108         SILC_PUT16_MSB(object_size, str);
 109         memcpy(str + 2, string, object_size);
 110         object = str;
 111         object_size += 2;
 112       }
 113       break;
 114
 115     case SILC_ATTRIBUTE_STATUS_MESSAGE:
 116     case SILC_ATTRIBUTE_EXTENSION:
 117       {
 118         SilcAttributeObjMime *mime = object;
 119         if (object_size != sizeof(*mime))
 120           return NULL;
 121         object = (void *)mime->mime;
 122         object_size = mime->mime_len;
 123       }
 124       break;
 125
 126     case SILC_ATTRIBUTE_GEOLOCATION:
 127       {
 128         SilcAttributeObjGeo *geo = object;
 129         if (object_size != sizeof(*geo))
 130           return NULL;
 131         len =
 132           (geo->longitude ? strlen(geo->longitude) : 0) +
 133           (geo->latitude  ? strlen(geo->latitude)  : 0) +
 134           (geo->altitude  ? strlen(geo->altitude)  : 0) +
 135           (geo->accuracy  ? strlen(geo->accuracy)  : 0);
 136         if (!len)
 137           return NULL;
 138         tmpbuf = silc_buffer_alloc_size(8 + len);
 139         if (!tmpbuf)
 140           return NULL;
 141         silc_buffer_format(tmpbuf,
 142                            SILC_STR_UI_SHORT(strlen(geo->longitude)),
 143                            SILC_STR_UI16_STRING(geo->longitude),
 144                            SILC_STR_UI_SHORT(strlen(geo->latitude)),
 145                            SILC_STR_UI16_STRING(geo->latitude),
 146                            SILC_STR_UI_SHORT(strlen(geo->altitude)),
 147                            SILC_STR_UI16_STRING(geo->altitude),
 148                            SILC_STR_UI_SHORT(strlen(geo->accuracy)),
 149                            SILC_STR_UI16_STRING(geo->accuracy),
 150                            SILC_STR_END);
 151         object = tmpbuf->data;
 152         object_size = tmpbuf->len;
 153       }
 154       break;
 155
 156     case SILC_ATTRIBUTE_DEVICE_INFO:
 157       {
 158         SilcAttributeObjDevice *dev = object;
 159         if (object_size != sizeof(*dev))
 160           return NULL;
 161         len =
 162           (dev->manufacturer ? strlen(dev->manufacturer) : 0) +
 163           (dev->version      ? strlen(dev->version)      : 0) +
 164           (dev->model        ? strlen(dev->model)        : 0) +
 165           (dev->language     ? strlen(dev->language)     : 0);
 166         tmpbuf = silc_buffer_alloc_size(4 + 8 + len);
 167         if (!tmpbuf)
 168           return NULL;
 169         silc_buffer_format(tmpbuf,
 170                            SILC_STR_UI_INT(dev->type),
 171                            SILC_STR_UI_SHORT(strlen(dev->manufacturer)),
 172                            SILC_STR_UI16_STRING(dev->manufacturer),
 173                            SILC_STR_UI_SHORT(strlen(dev->version)),
 174                            SILC_STR_UI16_STRING(dev->version),
 175                            SILC_STR_UI_SHORT(strlen(dev->model)),
 176                            SILC_STR_UI16_STRING(dev->model),
 177                            SILC_STR_UI_SHORT(strlen(dev->language)),
 178                            SILC_STR_UI16_STRING(dev->language),
 179                            SILC_STR_END);
 180         object = tmpbuf->data;
 181         object_size = tmpbuf->len;
 182       }
 183       break;
 184
 185     case SILC_ATTRIBUTE_USER_PUBLIC_KEY:
 186     case SILC_ATTRIBUTE_SERVER_PUBLIC_KEY:
 187       {
 188         SilcAttributeObjPk *pk = object;
 189         if (object_size != sizeof(*pk))
 190           return NULL;
 191         len = (pk->type ? strlen(pk->type) : 0);
 192         tmpbuf = silc_buffer_alloc_size(2 + len + pk->data_len);
 193         if (!tmpbuf)
 194           return NULL;
 195         silc_buffer_format(tmpbuf,
 196                            SILC_STR_UI_SHORT(len),
 197                            SILC_STR_UI16_STRING(pk->type),
 198                            SILC_STR_UI_XNSTRING(pk->data, pk->data_len),
 199                            SILC_STR_END);
 200         object = tmpbuf->data;
 201         object_size = tmpbuf->len;
 202       }
 203       break;
 204
 205     case SILC_ATTRIBUTE_USER_DIGITAL_SIGNATURE:
 206     case SILC_ATTRIBUTE_SERVER_DIGITAL_SIGNATURE:
 207       {
 208         SilcAttributeObjPk *pk = object;
 209         if (object_size != sizeof(*pk))
 210           return NULL;
 211         object = pk->data;
 212         object_size = pk->data_len;
 213       }
 214       break;
 215
 216     default:
 217       return NULL;
 218       break;
 219     }
 220
 221     ret = silc_memdup(object, object_size);
 222
 223     if (tmpbuf)
 224       silc_buffer_free(tmpbuf);
 225     silc_free(str);
 226
 227     if (ret_len)
 228       *ret_len = object_size;
 229
 230     return ret;
 231   }
 232
 233   return NULL;
 234 }
 235
 236 /* Allocates attribute payload and encodes the attribute there */
 237
 238 SilcAttributePayload silc_attribute_payload_alloc(SilcAttribute attribute,
 239                                                   SilcAttributeFlags flags,
 240                                                   void *object,
 241                                                   SilcUInt32 object_size)
 242 {
 243   SilcAttributePayload attr;
 244
 245   attr = silc_calloc(1, sizeof(*attr));
 246   if (!attr)
 247     return NULL;
 248
 249   attr->attribute = attribute;
 250   attr->flags = flags;
 251   attr->data =
 252     silc_attribute_payload_encode_int(attribute, flags, object,
 253                                       object_size,
 254                                       (SilcUInt32 *)&attr->data_len);
 255   if (!attr->data) {
 256     silc_free(attr);
 257     return NULL;
 258   }
 259
 260   return attr;
 261 }
 262
 263 /* Parse list of payloads */
 264
 265 SilcDList silc_attribute_payload_parse(const unsigned char *payload,
 266                                        SilcUInt32 payload_len)
 267 {
 268   SilcBufferStruct buffer;
 269   SilcDList list;
 270   SilcAttributePayload newp;
 271   int len, ret;
 272
 273   SILC_LOG_DEBUG(("Parsing Attribute Payload list"));
 274
 275   silc_buffer_set(&buffer, (unsigned char *)payload, payload_len);
 276   list = silc_dlist_init();
 277
 278   while (buffer.len) {
 279     newp = silc_calloc(1, sizeof(*newp));
 280     if (!newp)
 281       goto err;
 282     ret = silc_buffer_unformat(&buffer,
 283                                SILC_STR_UI_CHAR(&newp->attribute),
 284                                SILC_STR_UI_CHAR(&newp->flags),
 285                                SILC_STR_UI16_NSTRING_ALLOC(&newp->data,
 286                                                            &newp->data_len),
 287                                SILC_STR_END);
 288     if (ret == -1)
 289       goto err;
 290
 291     if (newp->data_len > buffer.len) {
 292       SILC_LOG_ERROR(("Incorrect attribute payload in list"));
 293       goto err;
 294     }
 295
 296     len = 4 + newp->data_len;
 297     if (buffer.len < len)
 298       break;
 299     silc_buffer_pull(&buffer, len);
 300
 301     silc_dlist_add(list, newp);
 302   }
 303
 304   return list;
 305
 306  err:
 307   silc_attribute_payload_list_free(list);
 308   return NULL;
 309 }
 310
 311 /* Encode one attribute payload to buffer */
 312
 313 SilcBuffer silc_attribute_payload_encode(SilcBuffer attrs,
 314                                          SilcAttribute attribute,
 315                                          SilcAttributeFlags flags,
 316                                          void *object,
 317                                          SilcUInt32 object_size)
 318 {
 319   object = silc_attribute_payload_encode_int(attribute, flags, object,
 320                                              object_size, &object_size);
 321   attrs = silc_attribute_payload_encode_data(attrs, attribute, flags,
 322                                              (const unsigned char *)object,
 323                                              object_size);
 324   silc_free(object);
 325   return attrs;
 326 }
 327
 328 /* Encoded the attribute data directly to buffer */
 329
 330 SilcBuffer silc_attribute_payload_encode_data(SilcBuffer attrs,
 331                                               SilcAttribute attribute,
 332                                               SilcAttributeFlags flags,
 333                                               const unsigned char *data,
 334                                               SilcUInt32 data_len)
 335 {
 336   SilcBuffer buffer = attrs;
 337   int len;
 338
 339   len = 4 + data_len;
 340   buffer = silc_buffer_realloc(buffer,
 341                                (buffer ? buffer->truelen + len : len));
 342   if (!buffer)
 343     return NULL;
 344   silc_buffer_pull(buffer, buffer->len);
 345   silc_buffer_pull_tail(buffer, len);
 346   silc_buffer_format(buffer,
 347                      SILC_STR_UI_CHAR(attribute),
 348                      SILC_STR_UI_CHAR(flags),
 349                      SILC_STR_UI_SHORT((SilcUInt16)data_len),
 350                      SILC_STR_UI_XNSTRING(data, data_len),
 351                      SILC_STR_END);
 352   silc_buffer_push(buffer, buffer->data - buffer->head);
 353
 354   return buffer;
 355 }
 356
 357 /* Free Attribute Payload */
 358
 359 void silc_attribute_payload_free(SilcAttributePayload payload)
 360 {
 361   silc_free(payload->data);
 362   silc_free(payload);
 363 }
 364
 365 /* Free's list of Attribute Payloads */
 366
 367 void silc_attribute_payload_list_free(SilcDList list)
 368 {
 369   SilcAttributePayload entry;
 370
 371   silc_dlist_start(list);
 372   while ((entry = silc_dlist_get(list)) != SILC_LIST_END) {
 373     silc_attribute_payload_free(entry);
 374     silc_dlist_del(list, entry);
 375   }
 376
 377   silc_dlist_uninit(list);
 378 }
 379
 380 /* Return attribute type */
 381
 382 SilcAttribute silc_attribute_get_attribute(SilcAttributePayload payload)
 383 {
 384   return payload->attribute;
 385 }
 386
 387 /* Return attribute flags */
 388
 389 SilcAttributeFlags silc_attribute_get_flags(SilcAttributePayload payload)
 390 {
 391   return payload->flags;
 392 }
 393
 394 /* Return attribute data from the payload */
 395
 396 const unsigned char *silc_attribute_get_data(SilcAttributePayload payload,
 397                                              SilcUInt32 *data_len)
 398 {
 399   if (data_len)
 400     *data_len = payload->data_len;
 401   return (const unsigned char *)payload->data;
 402 }
 403
 404 /* Return parsed attribute object */
 405
 406 bool silc_attribute_get_object(SilcAttributePayload payload,
 407                                void *object, SilcUInt32 object_size)
 408 {
 409   SilcUInt16 len;
 410   bool ret = FALSE;
 411
 412   if (!object || payload->flags & SILC_ATTRIBUTE_FLAG_INVALID)
 413     return FALSE;
 414
 415   switch (payload->attribute) {
 416   case SILC_ATTRIBUTE_USER_INFO:
 417     {
 418       SilcVCard vcard = object;
 419       if (object_size != sizeof(*vcard))
 420         break;
 421       if (!silc_vcard_decode(payload->data, payload->data_len, vcard))
 422         break;
 423       ret = TRUE;
 424     }
 425     break;
 426
 427   case SILC_ATTRIBUTE_SERVICE:
 428     {
 429       SilcAttributeObjService *service = object;
 430       if (object_size != sizeof(*service))
 431         break;
 432       if (payload->data_len < 7)
 433         break;
 434       SILC_GET32_MSB(service->port, payload->data);
 435       SILC_GET16_MSB(len, payload->data + 4);
 436       if (payload->data_len < 7 + len)
 437         break;
 438       memcpy(service->address, payload->data + 6,
 439              (len < sizeof(service->address) - 1 ? len :
 440               sizeof(service->address) - 1));
 441       service->status = payload->data[6 + len] ? TRUE : FALSE;
 442       ret = TRUE;
 443     }
 444     break;
 445
 446   case SILC_ATTRIBUTE_STATUS_MOOD:
 447   case SILC_ATTRIBUTE_PREFERRED_CONTACT:
 448     {
 449       SilcUInt32 *mask = (SilcUInt32 *)object;
 450       if (object_size != sizeof(SilcUInt32))
 451         break;
 452       if (payload->data_len < 4)
 453         break;
 454       SILC_GET32_MSB(*mask, payload->data);
 455       ret = TRUE;
 456     }
 457     break;
 458
 459   case SILC_ATTRIBUTE_STATUS_FREETEXT:
 460   case SILC_ATTRIBUTE_PREFERRED_LANGUAGE:
 461   case SILC_ATTRIBUTE_TIMEZONE:
 462     {
 463       char *string = object;
 464       if (payload->data_len < 2)
 465         break;
 466       SILC_GET16_MSB(len, payload->data);
 467       if (payload->data_len < 2 + len)
 468         break;
 469       if (object_size < len)
 470         break;
 471       memcpy(string, payload->data + 2, len);
 472       ret = TRUE;
 473     }
 474     break;
 475
 476   case SILC_ATTRIBUTE_STATUS_MESSAGE:
 477   case SILC_ATTRIBUTE_EXTENSION:
 478     {
 479       SilcAttributeObjMime *mime = object;
 480       if (object_size != sizeof(*mime))
 481         break;
 482       mime->mime = (const unsigned char *)payload->data;
 483       mime->mime_len = payload->data_len;
 484       ret = TRUE;
 485     }
 486     break;
 487
 488   case SILC_ATTRIBUTE_GEOLOCATION:
 489     {
 490       SilcAttributeObjGeo *geo = object;
 491       SilcBufferStruct buffer;
 492       int res;
 493       if (object_size != sizeof(*geo))
 494         break;
 495       silc_buffer_set(&buffer, (unsigned char *)payload->data,
 496                       payload->data_len);
 497       res = silc_buffer_unformat(&buffer,
 498                                  SILC_STR_UI16_STRING_ALLOC(&geo->longitude),
 499                                  SILC_STR_UI16_STRING_ALLOC(&geo->latitude),
 500                                  SILC_STR_UI16_STRING_ALLOC(&geo->altitude),
 501                                  SILC_STR_UI16_STRING_ALLOC(&geo->accuracy),
 502                                  SILC_STR_END);
 503       if (res == -1)
 504         break;
 505       ret = TRUE;
 506     }
 507     break;
 508
 509   case SILC_ATTRIBUTE_DEVICE_INFO:
 510     {
 511       SilcAttributeObjDevice *dev = object;
 512       SilcBufferStruct buffer;
 513       SilcUInt32 type;
 514       int res;
 515       if (object_size != sizeof(*dev))
 516         break;
 517       silc_buffer_set(&buffer, (unsigned char *)payload->data,
 518                       payload->data_len);
 519       res =
 520         silc_buffer_unformat(&buffer,
 521                              SILC_STR_UI_INT(&type),
 522                              SILC_STR_UI16_STRING_ALLOC(&dev->manufacturer),
 523                              SILC_STR_UI16_STRING_ALLOC(&dev->version),
 524                              SILC_STR_UI16_STRING_ALLOC(&dev->model),
 525                              SILC_STR_UI16_STRING_ALLOC(&dev->language),
 526                              SILC_STR_END);
 527       if (res == -1)
 528         break;
 529       dev->type = type;
 530       ret = TRUE;
 531     }
 532     break;
 533
 534   case SILC_ATTRIBUTE_USER_PUBLIC_KEY:
 535   case SILC_ATTRIBUTE_SERVER_PUBLIC_KEY:
 536     {
 537       SilcAttributeObjPk *pk = object;
 538       SilcBufferStruct buffer;
 539       int res;
 540       if (object_size != sizeof(*pk))
 541         break;
 542       silc_buffer_set(&buffer, (unsigned char *)payload->data,
 543                       payload->data_len);
 544       res =
 545         silc_buffer_unformat(&buffer,
 546                              SILC_STR_UI16_NSTRING_ALLOC(&pk->type, &len),
 547                              SILC_STR_END);
 548       if (res == -1)
 549         break;
 550       pk->data = silc_memdup(payload->data + 2 + len,
 551                              payload->data_len - 2 - len);
 552       pk->data_len = payload->data_len - 2 - len;
 553       ret = TRUE;
 554     }
 555     break;
 556
 557   case SILC_ATTRIBUTE_USER_DIGITAL_SIGNATURE:
 558   case SILC_ATTRIBUTE_SERVER_DIGITAL_SIGNATURE:
 559     {
 560       SilcAttributeObjPk *pk = object;
 561       if (object_size != sizeof(*pk))
 562         break;
 563       pk->type = NULL;
 564       pk->data = silc_memdup(payload->data, payload->data_len);
 565       pk->data_len = payload->data_len;
 566       ret = TRUE;
 567     }
 568     break;
 569
 570   default:
 571     break;
 572   }
 573
 574   return ret;
 575 }