lib/silccore/silcattrs.c

   1 /*
   2
   3   silcattrs.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 2002 - 2006 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 "silc.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   SilcUInt32 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         SilcUInt32 len2;
  74         if (object_size != sizeof(*service))
  75           return NULL;
  76         len = strlen(service->address);
  77         len2 = strlen(service->signon);
  78         tmpbuf = silc_buffer_alloc_size(13 + len + len2);
  79         if (!tmpbuf)
  80           return NULL;
  81         silc_buffer_format(tmpbuf,
  82                            SILC_STR_UI_INT(service->port),
  83                            SILC_STR_UI_SHORT(len),
  84                            SILC_STR_UI_XNSTRING(service->address, len),
  85                            SILC_STR_UI_CHAR(service->status),
  86                            SILC_STR_UI_SHORT(len2),
  87                            SILC_STR_UI_XNSTRING(service->signon, len2),
  88                            SILC_STR_UI_INT(service->idle),
  89                            SILC_STR_END);
  90         object = tmpbuf->data;
  91         object_size = silc_buffer_len(tmpbuf);
  92       }
  93       break;
  94
  95     case SILC_ATTRIBUTE_STATUS_MOOD:
  96     case SILC_ATTRIBUTE_PREFERRED_CONTACT:
  97       {
  98         SilcUInt32 mask = SILC_PTR_TO_32(object);
  99         if (object_size != sizeof(SilcUInt32))
 100           return NULL;
 101         SILC_PUT32_MSB(mask, tmp);
 102         object = tmp;
 103         object_size = sizeof(SilcUInt32);
 104       }
 105       break;
 106
 107     case SILC_ATTRIBUTE_STATUS_FREETEXT:
 108     case SILC_ATTRIBUTE_PREFERRED_LANGUAGE:
 109     case SILC_ATTRIBUTE_TIMEZONE:
 110       {
 111         unsigned char *string = object;
 112         str = silc_malloc(2 + object_size);
 113         if (!str)
 114           return NULL;
 115         SILC_PUT16_MSB(object_size, str);
 116         memcpy(str + 2, string, object_size);
 117         object = str;
 118         object_size += 2;
 119       }
 120       break;
 121
 122     case SILC_ATTRIBUTE_STATUS_MESSAGE:
 123     case SILC_ATTRIBUTE_EXTENSION:
 124     case SILC_ATTRIBUTE_USER_ICON:
 125       {
 126         SilcMime mime = object;
 127         if (object_size != sizeof(*mime))
 128           return NULL;
 129         str = silc_mime_encode(mime, &object_size);
 130         if (!str)
 131           return NULL;
 132       }
 133       break;
 134
 135     case SILC_ATTRIBUTE_GEOLOCATION:
 136       {
 137         SilcAttributeObjGeo *geo = object;
 138         SilcUInt32 len1, len2, len3, len4;
 139         if (object_size != sizeof(*geo))
 140           return NULL;
 141         len1 = (geo->longitude ? strlen(geo->longitude) : 0);
 142         len2 = (geo->latitude  ? strlen(geo->latitude)  : 0);
 143         len3 = (geo->altitude  ? strlen(geo->altitude)  : 0);
 144         len4 = (geo->accuracy  ? strlen(geo->accuracy)  : 0);
 145         if (len1 + len2 + len3 + len4 == 0)
 146           return NULL;
 147         len = len1 + len2 + len3 + len4;
 148         tmpbuf = silc_buffer_alloc_size(8 + len);
 149         if (!tmpbuf)
 150           return NULL;
 151         silc_buffer_format(tmpbuf,
 152                            SILC_STR_UI_SHORT(len1),
 153                            SILC_STR_UI16_STRING(len1 ? geo->longitude : ""),
 154                            SILC_STR_UI_SHORT(len2),
 155                            SILC_STR_UI16_STRING(len2 ? geo->latitude : ""),
 156                            SILC_STR_UI_SHORT(len3),
 157                            SILC_STR_UI16_STRING(len3 ? geo->altitude : ""),
 158                            SILC_STR_UI_SHORT(len4),
 159                            SILC_STR_UI16_STRING(len4 ? geo->accuracy : ""),
 160                            SILC_STR_END);
 161         object = tmpbuf->data;
 162         object_size = silc_buffer_len(tmpbuf);
 163       }
 164       break;
 165
 166     case SILC_ATTRIBUTE_DEVICE_INFO:
 167       {
 168         SilcAttributeObjDevice *dev = object;
 169         SilcUInt32 len1, len2, len3, len4;
 170         if (object_size != sizeof(*dev))
 171           return NULL;
 172         len1 = (dev->manufacturer ? strlen(dev->manufacturer) : 0);
 173         len2 = (dev->version      ? strlen(dev->version)      : 0);
 174         len3 = (dev->model        ? strlen(dev->model)        : 0);
 175         len4 = (dev->language     ? strlen(dev->language)     : 0);
 176         if (len1 + len2 + len3 + len4 == 0)
 177           return NULL;
 178         len = len1 + len2 + len3 + len4;
 179         tmpbuf = silc_buffer_alloc_size(4 + 8 + len);
 180         if (!tmpbuf)
 181           return NULL;
 182         silc_buffer_format(tmpbuf,
 183                            SILC_STR_UI_INT(dev->type),
 184                            SILC_STR_UI_SHORT(len1),
 185                            SILC_STR_UI16_STRING(len1 ? dev->manufacturer : ""),
 186                            SILC_STR_UI_SHORT(len2),
 187                            SILC_STR_UI16_STRING(len2 ? dev->version : ""),
 188                            SILC_STR_UI_SHORT(len3),
 189                            SILC_STR_UI16_STRING(len3 ? dev->model : ""),
 190                            SILC_STR_UI_SHORT(len4),
 191                            SILC_STR_UI16_STRING(len4 ? dev->language : ""),
 192                            SILC_STR_END);
 193         object = tmpbuf->data;
 194         object_size = silc_buffer_len(tmpbuf);
 195       }
 196       break;
 197
 198     case SILC_ATTRIBUTE_USER_PUBLIC_KEY:
 199     case SILC_ATTRIBUTE_SERVER_PUBLIC_KEY:
 200       {
 201         SilcAttributeObjPk *pk = object;
 202         if (object_size != sizeof(*pk))
 203           return NULL;
 204         len = (pk->type ? strlen(pk->type) : 0);
 205         tmpbuf = silc_buffer_alloc_size(2 + len + pk->data_len);
 206         if (!tmpbuf)
 207           return NULL;
 208         silc_buffer_format(tmpbuf,
 209                            SILC_STR_UI_SHORT(len),
 210                            SILC_STR_UI16_STRING(pk->type),
 211                            SILC_STR_UI_XNSTRING(pk->data, pk->data_len),
 212                            SILC_STR_END);
 213         object = tmpbuf->data;
 214         object_size = silc_buffer_len(tmpbuf);
 215       }
 216       break;
 217
 218     case SILC_ATTRIBUTE_USER_DIGITAL_SIGNATURE:
 219     case SILC_ATTRIBUTE_SERVER_DIGITAL_SIGNATURE:
 220       {
 221         SilcAttributeObjPk *pk = object;
 222         if (object_size != sizeof(*pk))
 223           return NULL;
 224         object = pk->data;
 225         object_size = pk->data_len;
 226       }
 227       break;
 228
 229     default:
 230       return NULL;
 231       break;
 232     }
 233
 234     ret = silc_memdup(object, object_size);
 235
 236     if (tmpbuf)
 237       silc_buffer_free(tmpbuf);
 238     silc_free(str);
 239
 240     if (ret_len)
 241       *ret_len = object_size;
 242
 243     return ret;
 244   }
 245
 246   return NULL;
 247 }
 248
 249 /* Allocates attribute payload and encodes the attribute there */
 250
 251 SilcAttributePayload silc_attribute_payload_alloc(SilcAttribute attribute,
 252                                                   SilcAttributeFlags flags,
 253                                                   void *object,
 254                                                   SilcUInt32 object_size)
 255 {
 256   SilcAttributePayload attr;
 257   SilcUInt32 tmp_len;
 258
 259   attr = silc_calloc(1, sizeof(*attr));
 260   if (!attr)
 261     return NULL;
 262
 263   attr->attribute = attribute;
 264   attr->flags = flags;
 265   attr->data =
 266     silc_attribute_payload_encode_int(attribute, flags, object,
 267                                       object_size, &tmp_len);
 268   attr->data_len = (SilcUInt16)tmp_len;
 269   if (!attr->data) {
 270     silc_free(attr);
 271     return NULL;
 272   }
 273
 274   return attr;
 275 }
 276
 277 /* Parse list of payloads */
 278
 279 SilcDList silc_attribute_payload_parse(const unsigned char *payload,
 280                                        SilcUInt32 payload_len)
 281 {
 282   SilcBufferStruct buffer;
 283   SilcDList list;
 284   SilcAttributePayload newp;
 285   SilcUInt32 len;
 286   int ret;
 287
 288   SILC_LOG_DEBUG(("Parsing Attribute Payload list"));
 289
 290   silc_buffer_set(&buffer, (unsigned char *)payload, payload_len);
 291   list = silc_dlist_init();
 292
 293   while (silc_buffer_len(&buffer)) {
 294     newp = silc_calloc(1, sizeof(*newp));
 295     if (!newp)
 296       goto err;
 297     ret = silc_buffer_unformat(&buffer,
 298                                SILC_STR_UI_CHAR(&newp->attribute),
 299                                SILC_STR_UI_CHAR(&newp->flags),
 300                                SILC_STR_UI16_NSTRING_ALLOC(&newp->data,
 301                                                            &newp->data_len),
 302                                SILC_STR_END);
 303     if (ret == -1)
 304       goto err;
 305
 306     if (newp->data_len > silc_buffer_len(&buffer) - 4) {
 307       SILC_LOG_ERROR(("Incorrect attribute payload in list"));
 308       goto err;
 309     }
 310
 311     len = 4 + newp->data_len;
 312     if (silc_buffer_len(&buffer) < len)
 313       break;
 314     silc_buffer_pull(&buffer, len);
 315
 316     silc_dlist_add(list, newp);
 317   }
 318
 319   return list;
 320
 321  err:
 322   silc_attribute_payload_list_free(list);
 323   return NULL;
 324 }
 325
 326 /* Encode one attribute payload to buffer */
 327
 328 SilcBuffer silc_attribute_payload_encode(SilcBuffer attrs,
 329                                          SilcAttribute attribute,
 330                                          SilcAttributeFlags flags,
 331                                          void *object,
 332                                          SilcUInt32 object_size)
 333 {
 334   object = silc_attribute_payload_encode_int(attribute, flags, object,
 335                                              object_size, &object_size);
 336   attrs = silc_attribute_payload_encode_data(attrs, attribute, flags,
 337                                              (const unsigned char *)object,
 338                                              object_size);
 339   silc_free(object);
 340   return attrs;
 341 }
 342
 343 /* Encoded the attribute data directly to buffer */
 344
 345 SilcBuffer silc_attribute_payload_encode_data(SilcBuffer attrs,
 346                                               SilcAttribute attribute,
 347                                               SilcAttributeFlags flags,
 348                                               const unsigned char *data,
 349                                               SilcUInt32 data_len)
 350 {
 351   SilcBuffer buffer = attrs;
 352   SilcUInt32 len;
 353
 354   len = 4 + (SilcUInt16)data_len;
 355   buffer = silc_buffer_realloc(buffer,
 356                                (buffer ? silc_buffer_truelen(buffer) + len : len));
 357   if (!buffer)
 358     return NULL;
 359   silc_buffer_pull(buffer, silc_buffer_len(buffer));
 360   silc_buffer_pull_tail(buffer, len);
 361   silc_buffer_format(buffer,
 362                      SILC_STR_UI_CHAR(attribute),
 363                      SILC_STR_UI_CHAR(flags),
 364                      SILC_STR_UI_SHORT((SilcUInt16)data_len),
 365                      SILC_STR_UI_XNSTRING(data, (SilcUInt16)data_len),
 366                      SILC_STR_END);
 367   silc_buffer_push(buffer, buffer->data - buffer->head);
 368
 369   return buffer;
 370 }
 371
 372 /* Free Attribute Payload */
 373
 374 void silc_attribute_payload_free(SilcAttributePayload payload)
 375 {
 376   silc_free(payload->data);
 377   silc_free(payload);
 378 }
 379
 380 /* Free's list of Attribute Payloads */
 381
 382 void silc_attribute_payload_list_free(SilcDList list)
 383 {
 384   SilcAttributePayload entry;
 385
 386   silc_dlist_start(list);
 387   while ((entry = silc_dlist_get(list)) != SILC_LIST_END) {
 388     silc_attribute_payload_free(entry);
 389     silc_dlist_del(list, entry);
 390   }
 391
 392   silc_dlist_uninit(list);
 393 }
 394
 395 /* Return attribute type */
 396
 397 SilcAttribute silc_attribute_get_attribute(SilcAttributePayload payload)
 398 {
 399   return payload->attribute;
 400 }
 401
 402 /* Return attribute flags */
 403
 404 SilcAttributeFlags silc_attribute_get_flags(SilcAttributePayload payload)
 405 {
 406   return payload->flags;
 407 }
 408
 409 /* Return attribute data from the payload */
 410
 411 const unsigned char *silc_attribute_get_data(SilcAttributePayload payload,
 412                                              SilcUInt32 *data_len)
 413 {
 414   if (data_len)
 415     *data_len = (SilcUInt32)payload->data_len;
 416   return (const unsigned char *)payload->data;
 417 }
 418
 419 /* Construct digital signature verification data */
 420
 421 unsigned char *silc_attribute_get_verify_data(SilcDList attrs,
 422                                               SilcBool server_verification,
 423                                               SilcUInt32 *data_len)
 424 {
 425   SilcAttributePayload attr;
 426   SilcBufferStruct buffer;
 427   unsigned char *data = NULL;
 428   SilcUInt32 len = 0;
 429
 430   silc_dlist_start(attrs);
 431   while ((attr = silc_dlist_get(attrs)) != SILC_LIST_END) {
 432     switch (attr->attribute) {
 433     case SILC_ATTRIBUTE_SERVER_DIGITAL_SIGNATURE:
 434       /* Server signature is never part of the verification data */
 435       break;
 436
 437     case SILC_ATTRIBUTE_USER_DIGITAL_SIGNATURE:
 438       /* For user signature verification this is not part of the data */
 439       if (!server_verification)
 440         break;
 441
 442       /* Fallback, for server signature verification, user digital signature
 443          is part of verification data. */
 444
 445     default:
 446       /* All other data is part of the verification data */
 447       data = silc_realloc(data, sizeof(*data) * (4 + attr->data_len + len));
 448       if (!data)
 449         return NULL;
 450       silc_buffer_set(&buffer, data + len, 4 + attr->data_len);
 451       silc_buffer_format(&buffer,
 452                          SILC_STR_UI_CHAR(attr->attribute),
 453                          SILC_STR_UI_CHAR(attr->flags),
 454                          SILC_STR_UI_SHORT(attr->data_len),
 455                          SILC_STR_UI_XNSTRING(attr->data, attr->data_len),
 456                          SILC_STR_END);
 457       len += 4 + attr->data_len;
 458       break;
 459     }
 460   }
 461
 462   if (data_len)
 463     *data_len = len;
 464
 465   return data;
 466 }
 467
 468 /* Return parsed attribute object */
 469
 470 SilcBool silc_attribute_get_object(SilcAttributePayload payload,
 471                                    void *object, SilcUInt32 object_size)
 472 {
 473   SilcUInt16 len;
 474   SilcBool ret = FALSE;
 475
 476   if (!object || payload->flags & SILC_ATTRIBUTE_FLAG_INVALID)
 477     return FALSE;
 478
 479   switch (payload->attribute) {
 480   case SILC_ATTRIBUTE_USER_INFO:
 481     {
 482       SilcVCard vcard = object;
 483       if (object_size != sizeof(*vcard))
 484         break;
 485       if (!silc_vcard_decode(payload->data, payload->data_len, vcard))
 486         break;
 487       ret = TRUE;
 488     }
 489     break;
 490
 491   case SILC_ATTRIBUTE_SERVICE:
 492     {
 493       SilcAttributeObjService *service = object;
 494       SilcBufferStruct buf;
 495       SilcUInt16 addr_len, signon_len;
 496       char *addr, *signon;
 497       int res;
 498       if (object_size != sizeof(*service))
 499         break;
 500       if (payload->data_len < 13)
 501         break;
 502       silc_buffer_set(&buf, payload->data, payload->data_len);
 503       res = silc_buffer_unformat(&buf,
 504                                  SILC_STR_UI_INT(&service->port),
 505                                  SILC_STR_UI16_NSTRING(&addr, &addr_len),
 506                                  SILC_STR_UI_CHAR(&service->status),
 507                                  SILC_STR_UI16_NSTRING(&signon, &signon_len),
 508                                  SILC_STR_UI_INT(&service->idle),
 509                                  SILC_STR_END);
 510       if (res == -1)
 511         break;
 512       memset(service->address, 0, sizeof(service->address));
 513       memset(service->signon, 0, sizeof(service->signon));
 514       memcpy(service->address, addr,
 515              (addr_len < sizeof(service->address) - 1 ? addr_len :
 516               sizeof(service->address) - 1));
 517       memcpy(service->signon, signon,
 518              (signon_len < sizeof(service->signon) - 1 ? signon_len :
 519               sizeof(service->signon) - 1));
 520       ret = TRUE;
 521     }
 522     break;
 523
 524   case SILC_ATTRIBUTE_STATUS_MOOD:
 525   case SILC_ATTRIBUTE_PREFERRED_CONTACT:
 526     {
 527       SilcUInt32 *mask = (SilcUInt32 *)object;
 528       if (object_size != sizeof(SilcUInt32))
 529         break;
 530       if (payload->data_len < 4)
 531         break;
 532       SILC_GET32_MSB(*mask, payload->data);
 533       ret = TRUE;
 534     }
 535     break;
 536
 537   case SILC_ATTRIBUTE_STATUS_FREETEXT:
 538   case SILC_ATTRIBUTE_PREFERRED_LANGUAGE:
 539   case SILC_ATTRIBUTE_TIMEZONE:
 540     {
 541       char *string = object;
 542       if (payload->data_len < 2)
 543         break;
 544       SILC_GET16_MSB(len, payload->data);
 545       if (payload->data_len < 2 + len)
 546         break;
 547       if (object_size < len)
 548         break;
 549       memcpy(string, payload->data + 2, len);
 550       ret = TRUE;
 551     }
 552     break;
 553
 554   case SILC_ATTRIBUTE_STATUS_MESSAGE:
 555   case SILC_ATTRIBUTE_EXTENSION:
 556   case SILC_ATTRIBUTE_USER_ICON:
 557     {
 558       SilcMime mime = object;
 559       if (object_size != sizeof(*mime))
 560         break;
 561       if (!silc_mime_decode(mime, payload->data, payload->data_len))
 562         break;
 563       ret = TRUE;
 564     }
 565     break;
 566
 567   case SILC_ATTRIBUTE_GEOLOCATION:
 568     {
 569       SilcAttributeObjGeo *geo = object;
 570       SilcBufferStruct buffer;
 571       int res;
 572       if (object_size != sizeof(*geo))
 573         break;
 574       silc_buffer_set(&buffer, (unsigned char *)payload->data,
 575                       payload->data_len);
 576       res = silc_buffer_unformat(&buffer,
 577                                  SILC_STR_UI16_STRING_ALLOC(&geo->longitude),
 578                                  SILC_STR_UI16_STRING_ALLOC(&geo->latitude),
 579                                  SILC_STR_UI16_STRING_ALLOC(&geo->altitude),
 580                                  SILC_STR_UI16_STRING_ALLOC(&geo->accuracy),
 581                                  SILC_STR_END);
 582       if (res == -1)
 583         break;
 584       ret = TRUE;
 585     }
 586     break;
 587
 588   case SILC_ATTRIBUTE_DEVICE_INFO:
 589     {
 590       SilcAttributeObjDevice *dev = object;
 591       SilcBufferStruct buffer;
 592       SilcUInt32 type;
 593       int res;
 594       if (object_size != sizeof(*dev))
 595         break;
 596       silc_buffer_set(&buffer, (unsigned char *)payload->data,
 597                       payload->data_len);
 598       res =
 599         silc_buffer_unformat(&buffer,
 600                              SILC_STR_UI_INT(&type),
 601                              SILC_STR_UI16_STRING_ALLOC(&dev->manufacturer),
 602                              SILC_STR_UI16_STRING_ALLOC(&dev->version),
 603                              SILC_STR_UI16_STRING_ALLOC(&dev->model),
 604                              SILC_STR_UI16_STRING_ALLOC(&dev->language),
 605                              SILC_STR_END);
 606       if (res == -1)
 607         break;
 608       dev->type = type;
 609       ret = TRUE;
 610     }
 611     break;
 612
 613   case SILC_ATTRIBUTE_USER_PUBLIC_KEY:
 614   case SILC_ATTRIBUTE_SERVER_PUBLIC_KEY:
 615     {
 616       SilcAttributeObjPk *pk = object;
 617       SilcBufferStruct buffer;
 618       int res;
 619       if (object_size != sizeof(*pk))
 620         break;
 621       silc_buffer_set(&buffer, (unsigned char *)payload->data,
 622                       payload->data_len);
 623       res =
 624         silc_buffer_unformat(&buffer,
 625                              SILC_STR_UI16_NSTRING_ALLOC(&pk->type, &len),
 626                              SILC_STR_END);
 627       if (res == -1 || len > silc_buffer_len(&buffer) - 2)
 628         break;
 629       pk->data = silc_memdup(payload->data + 2 + len,
 630                              payload->data_len - 2 - len);
 631       pk->data_len = payload->data_len - 2 - len;
 632       ret = TRUE;
 633     }
 634     break;
 635
 636   case SILC_ATTRIBUTE_USER_DIGITAL_SIGNATURE:
 637   case SILC_ATTRIBUTE_SERVER_DIGITAL_SIGNATURE:
 638     {
 639       SilcAttributeObjPk *pk = object;
 640       if (object_size != sizeof(*pk))
 641         break;
 642       pk->type = NULL;
 643       pk->data = silc_memdup(payload->data, payload->data_len);
 644       pk->data_len = payload->data_len;
 645       ret = TRUE;
 646     }
 647     break;
 648
 649   default:
 650     break;
 651   }
 652
 653   return ret;
 654 }