lib/silccore/silcpacket.c

   1 /*
   2
   3   silcpacket.c
   4
   5   Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
   6
   7   Copyright (C) 1997 - 2001 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; either version 2 of the License, or
  12   (at your option) any later version.
  13
  14   This program is distributed in the hope that it will be useful,
  15   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17   GNU General Public License for more details.
  18
  19 */
  20 /*
  21  * Created: Fri Jul 25 18:52:14 1997
  22  */
  23 /* $Id$ */
  24
  25 #include "silcincludes.h"
  26
  27 /******************************************************************************
  28
  29                           Packet Sending Routines
  30
  31 ******************************************************************************/
  32
  33 /* Writes data from encrypted buffer to the socket connection. If the
  34    data cannot be written at once, it will be written later with a timeout.
  35    The data is written from the data section of the buffer, not from head
  36    or tail section. This automatically pulls the data section towards end
  37    after writing the data. */
  38
  39 int silc_packet_write(int sock, SilcBuffer src)
  40 {
  41   int ret = 0;
  42
  43   SILC_LOG_DEBUG(("Writing data to socket %d", sock));
  44
  45   if (src->len > 0) {
  46     ret = write(sock, src->data, src->len);
  47     if (ret < 0) {
  48       if (errno == EAGAIN) {
  49         SILC_LOG_DEBUG(("Could not write immediately, will do it later"));
  50         return -2;
  51       }
  52       SILC_LOG_ERROR(("Cannot write to socket: %s", strerror(errno)));
  53       return -1;
  54     }
  55
  56     silc_buffer_pull(src, ret);
  57   }
  58
  59   SILC_LOG_DEBUG(("Wrote data %d bytes", ret));
  60
  61   return ret;
  62 }
  63
  64 /* Actually sends the packet. This flushes the connections outgoing data
  65    buffer. If data is sent directly to the network this returns the bytes
  66    written, if error occured this returns -1 and if the data could not
  67    be written directly to the network at this time this returns -2, in
  68    which case the data should be queued by the caller and sent at some
  69    later time. If `force_send' is TRUE this attempts to write the data
  70    directly to the network, if FALSE, this returns -2. */
  71
  72 int silc_packet_send(SilcSocketConnection sock, int force_send)
  73 {
  74   SILC_LOG_DEBUG(("Sending packet to %s:%d [%s]", sock->hostname,
  75                   sock->port,
  76                   (sock->type == SILC_SOCKET_TYPE_UNKNOWN ? "Unknown" :
  77                    sock->type == SILC_SOCKET_TYPE_CLIENT ? "Client" :
  78                    sock->type == SILC_SOCKET_TYPE_SERVER ? "Server" :
  79                    "Router")));
  80
  81   /* Send now if forced to do so */
  82   if (force_send == TRUE) {
  83     int ret;
  84
  85     SILC_LOG_DEBUG(("Forcing packet send, packet sent immediately"));
  86
  87     /* Write to network */
  88     ret = silc_packet_write(sock->sock, sock->outbuf);
  89
  90     if (ret == -1) {
  91       SILC_LOG_ERROR(("Error sending packet, dropped"));
  92     }
  93     if (ret != -2)
  94       return ret;
  95
  96     SILC_LOG_DEBUG(("Could not force the send, packet put to queue"));
  97   }
  98
  99   SILC_LOG_DEBUG(("Packet in queue"));
 100
 101   return -2;
 102 }
 103
 104 /* Encrypts a packet. This also creates HMAC of the packet before
 105    encryption and adds the HMAC at the end of the buffer. This assumes
 106    that there is enough free space at the end of the buffer to add the
 107    computed HMAC. This is the normal way of encrypting packets, if some
 108    other process of HMAC computing and encryption is needed this function
 109    cannot be used. */
 110
 111 void silc_packet_encrypt(SilcCipher cipher, SilcHmac hmac,
 112                          SilcBuffer buffer, uint32 len)
 113 {
 114   unsigned char mac[32];
 115   uint32 mac_len;
 116
 117   /* Compute HMAC. This assumes that HMAC is created from the entire
 118      data area thus this uses the length found in buffer, not the length
 119      sent as argument. */
 120   if (hmac) {
 121     silc_hmac_make(hmac, buffer->data, buffer->len, mac, &mac_len);
 122     silc_buffer_put_tail(buffer, mac, mac_len);
 123     memset(mac, 0, sizeof(mac));
 124   }
 125
 126   /* Encrypt the data area of the packet. 2 bytes of the packet
 127      are not encrypted. */
 128   if (cipher) {
 129     SILC_LOG_DEBUG(("Encrypting packet, cipher %s, len %d (%d)",
 130                     cipher->cipher->name, len, len - 2));
 131     cipher->cipher->encrypt(cipher->context, buffer->data + 2,
 132                             buffer->data + 2, len - 2, cipher->iv);
 133   }
 134
 135   /* Pull the HMAC into the visible data area in the buffer */
 136   if (hmac)
 137     silc_buffer_pull_tail(buffer, mac_len);
 138 }
 139
 140 /* Assembles a new packet to be ready for send out. The buffer sent as
 141    argument must include the data to be sent and it must not be encrypted.
 142    The packet also must have enough free space so that the SILC header
 143    and padding maybe added to the packet. The packet is encrypted after
 144    this function has returned.
 145
 146    The buffer sent as argument should be something like following:
 147
 148    --------------------------------------------
 149    | head             | data           | tail |
 150    --------------------------------------------
 151    ^                  ^
 152    58 bytes           x bytes
 153
 154    So that the SILC header and 1 - 16 bytes of padding can fit to
 155    the buffer. After assembly the buffer might look like this:
 156
 157    --------------------------------------------
 158    | data                              |      |
 159    --------------------------------------------
 160    ^                                   ^
 161    Start of assembled packet
 162
 163    Packet construct is as follows (* = won't be encrypted):
 164
 165    x bytes       SILC Header
 166       2 bytes     Payload length  (*)
 167       1 byte      Flags
 168       1 byte      Packet type
 169       1 byte      Source ID Type
 170       2 bytes     Source ID Length
 171       x bytes     Source ID
 172       1 byte      Destination ID Type
 173       2 bytes     Destination ID Length
 174       x bytes     Destination ID
 175
 176    1 - 16 bytes    Padding
 177
 178    x bytes        Data payload
 179
 180    All fields in the packet will be authenticated by MAC. The MAC is
 181    not computed here, it must be computed differently before encrypting
 182    the packet.
 183
 184 */
 185
 186 void silc_packet_assemble(SilcPacketContext *ctx)
 187 {
 188   unsigned char tmppad[SILC_PACKET_MAX_PADLEN];
 189   int i;
 190
 191   SILC_LOG_DEBUG(("Assembling outgoing packet"));
 192
 193   /* Get the true length of the packet. This is saved as payload length
 194      into the packet header. This does not include the length of the
 195      padding. */
 196   if (!ctx->truelen)
 197     ctx->truelen = ctx->buffer->len + SILC_PACKET_HEADER_LEN +
 198       ctx->src_id_len + ctx->dst_id_len;
 199
 200   /* Calculate the length of the padding. The padding is calculated from
 201      the data that will be encrypted. As protocol states 3 first bytes
 202      of the packet are not encrypted they are not included in the
 203      padding calculation. */
 204   if (!ctx->padlen)
 205     ctx->padlen = SILC_PACKET_PADLEN(ctx->truelen);
 206
 207   /* Put the start of the data section to the right place. */
 208   silc_buffer_push(ctx->buffer, SILC_PACKET_HEADER_LEN +
 209                    ctx->src_id_len + ctx->dst_id_len + ctx->padlen);
 210
 211   /* Get random padding */
 212 #if 1
 213   for (i = 0; i < ctx->padlen; i++) tmppad[i] = silc_rng_global_get_byte();
 214 #else
 215   /* XXX: For testing - to be removed */
 216   memset(tmppad, 65, sizeof(tmppad));
 217 #endif
 218
 219   /* Create the packet. This creates the SILC header and adds padding,
 220      rest of the buffer remains as it is. */
 221   silc_buffer_format(ctx->buffer,
 222                      SILC_STR_UI_SHORT(ctx->truelen),
 223                      SILC_STR_UI_CHAR(ctx->flags),
 224                      SILC_STR_UI_CHAR(ctx->type),
 225                      SILC_STR_UI_SHORT(ctx->src_id_len),
 226                      SILC_STR_UI_SHORT(ctx->dst_id_len),
 227                      SILC_STR_UI_CHAR(ctx->src_id_type),
 228                      SILC_STR_UI_XNSTRING(ctx->src_id, ctx->src_id_len),
 229                      SILC_STR_UI_CHAR(ctx->dst_id_type),
 230                      SILC_STR_UI_XNSTRING(ctx->dst_id, ctx->dst_id_len),
 231                      SILC_STR_UI_XNSTRING(tmppad, ctx->padlen),
 232                      SILC_STR_END);
 233
 234   SILC_LOG_HEXDUMP(("Assembled packet, len %d", ctx->buffer->len),
 235                    ctx->buffer->data, ctx->buffer->len);
 236
 237   SILC_LOG_DEBUG(("Outgoing packet assembled"));
 238 }
 239
 240 /* Prepare outgoing data buffer for packet sending. This moves the data
 241    area so that new packet may be added into it. If needed this allocates
 242    more space to the buffer. This handles directly the connection's
 243    outgoing buffer in SilcSocketConnection object. */
 244
 245 void silc_packet_send_prepare(SilcSocketConnection sock,
 246                               uint32 header_len,
 247                               uint32 padlen,
 248                               uint32 data_len)
 249 {
 250   int totlen, oldlen;
 251
 252   totlen = header_len + padlen + data_len;
 253
 254   /* Prepare the outgoing buffer for packet sending. */
 255   if (!sock->outbuf) {
 256     /* Allocate new buffer. This is done only once per connection. */
 257     SILC_LOG_DEBUG(("Allocating outgoing data buffer"));
 258
 259     sock->outbuf = silc_buffer_alloc(SILC_PACKET_DEFAULT_SIZE);
 260     silc_buffer_pull_tail(sock->outbuf, totlen);
 261     silc_buffer_pull(sock->outbuf, header_len + padlen);
 262   } else {
 263     if (SILC_IS_OUTBUF_PENDING(sock)) {
 264       /* There is some pending data in the buffer. */
 265
 266       /* Allocate more space if needed */
 267       if ((sock->outbuf->end - sock->outbuf->tail) < data_len) {
 268         SILC_LOG_DEBUG(("Reallocating outgoing data buffer"));
 269         sock->outbuf = silc_buffer_realloc(sock->outbuf,
 270                                            sock->outbuf->truelen + totlen);
 271       }
 272
 273       oldlen = sock->outbuf->len;
 274       silc_buffer_pull_tail(sock->outbuf, totlen);
 275       silc_buffer_pull(sock->outbuf, header_len + padlen + oldlen);
 276     } else {
 277       /* Buffer is free for use */
 278       silc_buffer_clear(sock->outbuf);
 279       silc_buffer_pull_tail(sock->outbuf, totlen);
 280       silc_buffer_pull(sock->outbuf, header_len + padlen);
 281     }
 282   }
 283 }
 284
 285 /******************************************************************************
 286
 287                          Packet Reception Routines
 288
 289 ******************************************************************************/
 290
 291 /* Reads data from the socket connection into the incoming data buffer.
 292    However, this does not parse the packet, it only reads some amount from
 293    the network. If there are more data available that can be read at a time
 294    the rest of the data will be read later with a timeout and only after
 295    that the packet is ready to be parsed.
 296
 297    The destination buffer sent as argument must be initialized before
 298    calling this function, and, the data section and the start of the tail
 299    section must be same. Ie. we add the read data to the tail section of
 300    the buffer hence the data section is the start of the buffer.
 301
 302    This returns amount of bytes read or -1 on error or -2 on case where
 303    all of the data could not be read at once. */
 304
 305 int silc_packet_read(int sock, SilcBuffer dest)
 306 {
 307   int len = 0;
 308   unsigned char buf[SILC_PACKET_READ_SIZE];
 309
 310   SILC_LOG_DEBUG(("Reading data from socket %d", sock));
 311
 312   /* Read the data from the socket. */
 313   len = read(sock, buf, sizeof(buf));
 314   if (len < 0) {
 315     if (errno == EAGAIN || errno == EINTR) {
 316       SILC_LOG_DEBUG(("Could not read immediately, will do it later"));
 317       return -2;
 318     }
 319     SILC_LOG_ERROR(("Cannot read from socket: %d:%s", sock, strerror(errno)));
 320     return -1;
 321   }
 322
 323   if (!len)
 324     return 0;
 325
 326   /* Insert the data to the buffer. If the data doesn't fit to the
 327      buffer space is allocated for the buffer. */
 328   /* XXX: This may actually be bad thing as if there is pending data in
 329      the buffer they will be lost! */
 330   if (dest) {
 331
 332     /* If the data doesn't fit we just have to allocate a whole new
 333        data area */
 334     if (dest->truelen <= len) {
 335
 336       /* Free the old buffer */
 337       memset(dest->head, 'F', dest->truelen);
 338       silc_free(dest->head);
 339
 340       /* Allocate new data area */
 341       len += SILC_PACKET_DEFAULT_SIZE;
 342       dest->data = silc_calloc(len, sizeof(char));
 343       dest->truelen = len;
 344       dest->len = 0;
 345       dest->head = dest->data;
 346       dest->data = dest->data;
 347       dest->tail = dest->data;
 348       dest->end = dest->data + dest->truelen;
 349       len -= SILC_PACKET_DEFAULT_SIZE;
 350     }
 351
 352     silc_buffer_put_tail(dest, buf, len);
 353     silc_buffer_pull_tail(dest, len);
 354   }
 355
 356   SILC_LOG_DEBUG(("Read %d bytes", len));
 357
 358   return len;
 359 }
 360
 361 /* Processes the received data. This checks the received data and
 362    calls parser callback that handles the actual packet decryption
 363    and parsing. If more than one packet was received this calls the
 364    parser multiple times. The parser callback will get context
 365    SilcPacketParserContext that includes the packet and the `context'
 366    sent to this function. */
 367
 368 void silc_packet_receive_process(SilcSocketConnection sock,
 369                                  SilcCipher cipher, SilcHmac hmac,
 370                                  SilcPacketParserCallback parser,
 371                                  void *context)
 372 {
 373   SilcPacketParserContext *parse_ctx;
 374   int packetlen, paddedlen, count, mac_len = 0;
 375
 376   /* We need at least 2 bytes of data to be able to start processing
 377      the packet. */
 378   if (sock->inbuf->len < 2)
 379     return;
 380
 381   if (hmac)
 382     mac_len = hmac->hmac->len;
 383
 384   /* Parse the packets from the data */
 385   count = 0;
 386   while (sock->inbuf->len > 0) {
 387     SILC_PACKET_LENGTH(sock->inbuf, packetlen, paddedlen);
 388     paddedlen += 2;
 389     count++;
 390
 391     if (packetlen < SILC_PACKET_MIN_LEN) {
 392       SILC_LOG_DEBUG(("Received invalid packet, dropped"));
 393       silc_buffer_clear(sock->inbuf);
 394       return;
 395     }
 396
 397     if (sock->inbuf->len < paddedlen + mac_len) {
 398       SILC_LOG_DEBUG(("Received partial packet, waiting for the rest"));
 399       return;
 400     }
 401
 402     parse_ctx = silc_calloc(1, sizeof(*parse_ctx));
 403     parse_ctx->packet = silc_packet_context_alloc();
 404     parse_ctx->packet->buffer = silc_buffer_alloc(paddedlen + mac_len);
 405     parse_ctx->sock = sock;
 406     parse_ctx->context = context;
 407
 408     silc_buffer_pull_tail(parse_ctx->packet->buffer,
 409                           SILC_BUFFER_END(parse_ctx->packet->buffer));
 410     silc_buffer_put(parse_ctx->packet->buffer, sock->inbuf->data,
 411                     paddedlen + mac_len);
 412
 413     SILC_LOG_HEXDUMP(("Incoming packet, len %d",
 414                       parse_ctx->packet->buffer->len),
 415                      parse_ctx->packet->buffer->data,
 416                      parse_ctx->packet->buffer->len);
 417
 418     /* Call the parser */
 419     if (parser)
 420       (*parser)(parse_ctx);
 421
 422     /* Pull the packet from inbuf thus we'll get the next one
 423        in the inbuf. */
 424     silc_buffer_pull(sock->inbuf, paddedlen);
 425     if (hmac)
 426       silc_buffer_pull(sock->inbuf, mac_len);
 427   }
 428
 429   SILC_LOG_DEBUG(("Clearing inbound buffer"));
 430   silc_buffer_clear(sock->inbuf);
 431 }
 432
 433 /* Receives packet from network and reads the data into connection's
 434    incoming data buffer. If the data was read directly this returns the
 435    read bytes, if error occured this returns -1, if the data could not
 436    be read directly at this time this returns -2 in which case the data
 437    should be read again at some later time, or If EOF occured this returns
 438    0. */
 439
 440 int silc_packet_receive(SilcSocketConnection sock)
 441 {
 442   int ret;
 443
 444   SILC_LOG_DEBUG(("Receiving packet from %s:%d [%s]", sock->hostname,
 445                   sock->port,
 446                   (sock->type == SILC_SOCKET_TYPE_UNKNOWN ? "Unknown" :
 447                    sock->type == SILC_SOCKET_TYPE_CLIENT ? "Client" :
 448                    sock->type == SILC_SOCKET_TYPE_SERVER ? "Server" :
 449                    "Router")));
 450
 451   /* Allocate the incoming data buffer if not done already. */
 452   if (!sock->inbuf)
 453     sock->inbuf = silc_buffer_alloc(SILC_PACKET_DEFAULT_SIZE);
 454
 455   /* Read some data from connection */
 456   ret = silc_packet_read(sock->sock, sock->inbuf);
 457
 458   return ret;
 459 }
 460
 461 /* Checks MAC in the packet. Returns TRUE if MAC is Ok. This is called
 462    after packet has been totally decrypted and parsed. */
 463
 464 static int silc_packet_check_mac(SilcHmac hmac, SilcBuffer buffer)
 465 {
 466   /* Check MAC */
 467   if (hmac) {
 468     unsigned char mac[32];
 469     uint32 mac_len;
 470
 471     SILC_LOG_DEBUG(("Verifying MAC"));
 472
 473     /* Compute HMAC of packet */
 474     memset(mac, 0, sizeof(mac));
 475     silc_hmac_make(hmac, buffer->data, buffer->len, mac, &mac_len);
 476
 477     /* Compare the HMAC's (buffer->tail has the packet's HMAC) */
 478     if (memcmp(mac, buffer->tail, mac_len)) {
 479       SILC_LOG_ERROR(("MAC failed"));
 480       return FALSE;
 481     }
 482
 483     SILC_LOG_DEBUG(("MAC is Ok"));
 484     memset(mac, 0, sizeof(mac));
 485   }
 486
 487   return TRUE;
 488 }
 489
 490 /* Decrypts rest of the packet (after decrypting just the SILC header).
 491    After calling this function the packet is ready to be parsed by calling
 492    silc_packet_parse. If everything goes without errors this returns TRUE,
 493    if packet is malformed this returns FALSE. */
 494
 495 static int silc_packet_decrypt_rest(SilcCipher cipher, SilcHmac hmac,
 496                                     SilcBuffer buffer)
 497 {
 498   if (cipher) {
 499
 500     /* Pull MAC from packet before decryption */
 501     if (hmac) {
 502       if ((buffer->len - hmac->hmac->len) > SILC_PACKET_MIN_LEN) {
 503         silc_buffer_push_tail(buffer, hmac->hmac->len);
 504       } else {
 505         SILC_LOG_DEBUG(("Bad MAC length in packet, packet dropped"));
 506         return FALSE;
 507       }
 508     }
 509
 510     SILC_LOG_DEBUG(("Decrypting rest of the packet"));
 511
 512     /* Decrypt rest of the packet */
 513     silc_buffer_pull(buffer, SILC_PACKET_MIN_HEADER_LEN - 2);
 514     cipher->cipher->decrypt(cipher->context, buffer->data + 2,
 515                             buffer->data + 2, buffer->len - 2,
 516                             cipher->iv);
 517     silc_buffer_push(buffer, SILC_PACKET_MIN_HEADER_LEN - 2);
 518
 519     SILC_LOG_HEXDUMP(("Fully decrypted packet, len %d", buffer->len),
 520                      buffer->data, buffer->len);
 521   }
 522
 523   return TRUE;
 524 }
 525
 526 /* Decrypts rest of the SILC Packet header that has been decrypted partly
 527    already. This decrypts the padding of the packet also. After calling
 528    this function the packet is ready to be parsed by calling function
 529    silc_packet_parse. This is used in special packet reception (protocol
 530    defines the way of decrypting special packets). */
 531
 532 static int silc_packet_decrypt_rest_special(SilcCipher cipher,
 533                                             SilcHmac hmac,
 534                                             SilcBuffer buffer)
 535 {
 536   /* Decrypt rest of the header plus padding */
 537   if (cipher) {
 538     uint16 truelen, len1, len2, padlen;
 539
 540     /* Pull MAC from packet before decryption */
 541     if (hmac) {
 542       if ((buffer->len - hmac->hmac->len) > SILC_PACKET_MIN_LEN) {
 543         silc_buffer_push_tail(buffer, hmac->hmac->len);
 544       } else {
 545         SILC_LOG_DEBUG(("Bad MAC length in packet, packet dropped"));
 546         return FALSE;
 547       }
 548     }
 549
 550     SILC_LOG_DEBUG(("Decrypting rest of the header"));
 551
 552     SILC_GET16_MSB(len1, &buffer->data[4]);
 553     SILC_GET16_MSB(len2, &buffer->data[6]);
 554
 555     truelen = SILC_PACKET_HEADER_LEN + len1 + len2;
 556     padlen = SILC_PACKET_PADLEN(truelen);
 557     len1 = (truelen + padlen) - (SILC_PACKET_MIN_HEADER_LEN - 2);
 558
 559     silc_buffer_pull(buffer, SILC_PACKET_MIN_HEADER_LEN - 2);
 560     cipher->cipher->decrypt(cipher->context, buffer->data + 2,
 561                             buffer->data + 2, len1 - 2,
 562                             cipher->iv);
 563     silc_buffer_push(buffer, SILC_PACKET_MIN_HEADER_LEN - 2);
 564   }
 565
 566   return TRUE;
 567 }
 568
 569 /* Decrypts a packet. This assumes that typical SILC packet is the
 570    packet to be decrypted and thus checks for normal and special SILC
 571    packets and can handle both of them. This also computes and checks
 572    the HMAC of the packet. If any other special or customized decryption
 573    processing is required this function cannot be used. This returns
 574    -1 on error, 0 when packet is normal packet and 1 when the packet
 575    is special and requires special processing.
 576
 577    The `check_packet' is a callback funtion that this function will
 578    call.  The callback relates to the checking whether the packet is
 579    normal packet or special packet and how it should be processed.  If
 580    the callback return TRUE the packet is normal and FALSE if the packet
 581    is special and requires special procesing. */
 582
 583 int silc_packet_decrypt(SilcCipher cipher, SilcHmac hmac,
 584                         SilcBuffer buffer, SilcPacketContext *packet,
 585                         SilcPacketCheckDecrypt check_packet,
 586                         void *context)
 587 {
 588   int check;
 589
 590   /* Decrypt start of the packet header */
 591   if (cipher)
 592     silc_cipher_decrypt(cipher, buffer->data + 2, buffer->data + 2,
 593                         SILC_PACKET_MIN_HEADER_LEN - 2, cipher->iv);
 594
 595   /* Do packet checking, whether the packet is normal or special */
 596   check = check_packet((SilcPacketType)buffer->data[3], buffer,
 597                        packet, context);
 598
 599   /* If the packet type is not any special type lets decrypt rest
 600      of the packet here. */
 601   if (check == TRUE) {
 602     /* Normal packet, decrypt rest of the packet */
 603     if (!silc_packet_decrypt_rest(cipher, hmac, buffer))
 604       return -1;
 605
 606     /* Check MAC */
 607     if (!silc_packet_check_mac(hmac, buffer))
 608       return -1;
 609
 610     return 0;
 611   } else {
 612     /* Packet requires special handling, decrypt rest of the header.
 613        This only decrypts. */
 614     if (!silc_packet_decrypt_rest_special(cipher, hmac, buffer))
 615       return -1;
 616
 617     /* Check MAC */
 618     if (!silc_packet_check_mac(hmac, buffer))
 619       return -1;
 620
 621     return 1;
 622   }
 623 }
 624
 625 /* Parses the packet. This is called when a whole packet is ready to be
 626    parsed. The buffer sent must be already decrypted before calling this
 627    function. The len argument must be the true length of the packet. This
 628    function returns the type of the packet. The data section of the
 629    buffer is parsed, not head or tail sections. */
 630
 631 SilcPacketType silc_packet_parse(SilcPacketContext *ctx)
 632 {
 633   SilcBuffer buffer = ctx->buffer;
 634   int len, ret;
 635
 636   SILC_LOG_DEBUG(("Parsing incoming packet"));
 637
 638   /* Check the length of the buffer */
 639   if (buffer->len < SILC_PACKET_MIN_LEN) {
 640     SILC_LOG_ERROR(("Bad packet length: %d, packet dropped", buffer->len));
 641     return SILC_PACKET_NONE;
 642   }
 643
 644   /* Parse the buffer. This parses the SILC header of the packet. */
 645   len = silc_buffer_unformat(buffer,
 646                              SILC_STR_UI_SHORT(&ctx->truelen),
 647                              SILC_STR_UI_CHAR(&ctx->flags),
 648                              SILC_STR_UI_CHAR(&ctx->type),
 649                              SILC_STR_UI_SHORT(&ctx->src_id_len),
 650                              SILC_STR_UI_SHORT(&ctx->dst_id_len),
 651                              SILC_STR_UI_CHAR(&ctx->src_id_type),
 652                              SILC_STR_END);
 653   if (len == -1)
 654     return SILC_PACKET_NONE;
 655
 656   if (ctx->src_id_len > SILC_PACKET_MAX_ID_LEN ||
 657       ctx->dst_id_len > SILC_PACKET_MAX_ID_LEN) {
 658     SILC_LOG_ERROR(("Bad ID lengths in packet"));
 659     return SILC_PACKET_NONE;
 660   }
 661
 662   /* Calculate length of padding in packet */
 663   ctx->padlen = SILC_PACKET_PADLEN(ctx->truelen);
 664
 665   silc_buffer_pull(buffer, len);
 666   ret = silc_buffer_unformat(buffer,
 667                              SILC_STR_UI_XNSTRING_ALLOC(&ctx->src_id,
 668                                                         ctx->src_id_len),
 669                              SILC_STR_UI_CHAR(&ctx->dst_id_type),
 670                              SILC_STR_UI_XNSTRING_ALLOC(&ctx->dst_id,
 671                                                         ctx->dst_id_len),
 672                              SILC_STR_UI_XNSTRING(NULL, ctx->padlen),
 673                              SILC_STR_END);
 674   if (ret == -1)
 675     return SILC_PACKET_NONE;
 676
 677   silc_buffer_push(buffer, len);
 678
 679   SILC_LOG_HEXDUMP(("parsed packet, len %d", ctx->buffer->len),
 680                    ctx->buffer->data, ctx->buffer->len);
 681
 682   /* Pull SILC header and padding from packet */
 683   silc_buffer_pull(buffer, SILC_PACKET_HEADER_LEN +
 684                    ctx->src_id_len + ctx->dst_id_len + ctx->padlen);
 685
 686   SILC_LOG_DEBUG(("Incoming packet type: %d", ctx->type));
 687
 688   return ctx->type;
 689 }
 690
 691 /* Perform special SILC Packet header parsing. This is required to some
 692    packet types that have the data payload encrypted with different key
 693    than the header area plus padding of the packet. Hence, this parses
 694    the header in a way that it does not take the data area into account
 695    and parses the header and padding area only. */
 696
 697 SilcPacketType silc_packet_parse_special(SilcPacketContext *ctx)
 698 {
 699   SilcBuffer buffer = ctx->buffer;
 700   int len, tmplen, ret;
 701
 702   SILC_LOG_DEBUG(("Parsing incoming packet"));
 703
 704   /* Check the length of the buffer */
 705   if (buffer->len < SILC_PACKET_MIN_LEN) {
 706     SILC_LOG_ERROR(("Bad packet length: %d, packet dropped", buffer->len));
 707     return SILC_PACKET_NONE;
 708   }
 709
 710   /* Parse the buffer. This parses the SILC header of the packet. */
 711   len = silc_buffer_unformat(buffer,
 712                              SILC_STR_UI_SHORT(&ctx->truelen),
 713                              SILC_STR_UI_CHAR(&ctx->flags),
 714                              SILC_STR_UI_CHAR(&ctx->type),
 715                              SILC_STR_UI_SHORT(&ctx->src_id_len),
 716                              SILC_STR_UI_SHORT(&ctx->dst_id_len),
 717                              SILC_STR_UI_CHAR(&ctx->src_id_type),
 718                              SILC_STR_END);
 719   if (len == -1)
 720     return SILC_PACKET_NONE;
 721
 722   if (ctx->src_id_len > SILC_PACKET_MAX_ID_LEN ||
 723       ctx->dst_id_len > SILC_PACKET_MAX_ID_LEN) {
 724     SILC_LOG_ERROR(("Bad ID lengths in packet"));
 725     return SILC_PACKET_NONE;
 726   }
 727
 728   /* Calculate length of padding in packet. As this is special packet
 729      the data area is not used in the padding calculation as it won't
 730      be decrypted by the caller. */
 731   tmplen = SILC_PACKET_HEADER_LEN + ctx->src_id_len + ctx->dst_id_len;
 732   ctx->padlen = SILC_PACKET_PADLEN(tmplen);
 733
 734   silc_buffer_pull(buffer, len);
 735   ret = silc_buffer_unformat(buffer,
 736                              SILC_STR_UI_XNSTRING_ALLOC(&ctx->src_id,
 737                                                         ctx->src_id_len),
 738                              SILC_STR_UI_CHAR(&ctx->dst_id_type),
 739                              SILC_STR_UI_XNSTRING_ALLOC(&ctx->dst_id,
 740                                                         ctx->dst_id_len),
 741                              SILC_STR_UI_XNSTRING(NULL, ctx->padlen),
 742                              SILC_STR_END);
 743   if (ret == -1)
 744     return SILC_PACKET_NONE;
 745
 746   silc_buffer_push(buffer, len);
 747
 748   SILC_LOG_HEXDUMP(("parsed packet, len %d", ctx->buffer->len),
 749                    ctx->buffer->data, ctx->buffer->len);
 750
 751   /* Pull SILC header and padding from packet */
 752   silc_buffer_pull(buffer, SILC_PACKET_HEADER_LEN +
 753                    ctx->src_id_len + ctx->dst_id_len + ctx->padlen);
 754
 755   SILC_LOG_DEBUG(("Incoming packet type: %d", ctx->type));
 756
 757   return ctx->type;
 758 }
 759
 760 /* Allocate packet context */
 761
 762 SilcPacketContext *silc_packet_context_alloc()
 763 {
 764   SilcPacketContext *ctx = silc_calloc(1, sizeof(*ctx));
 765   ctx->users++;
 766   return ctx;
 767 }
 768
 769 /* Increse the reference count of the packet context. */
 770
 771 SilcPacketContext *silc_packet_context_dup(SilcPacketContext *ctx)
 772 {
 773   ctx->users++;
 774   SILC_LOG_DEBUG(("Packet context %p refcnt %d->%d", ctx, ctx->users - 1,
 775                   ctx->users));
 776   return ctx;
 777 }
 778
 779 /* Decrese the reference count of the packet context and free it only if
 780    it is zero. */
 781
 782 void silc_packet_context_free(SilcPacketContext *ctx)
 783 {
 784   ctx->users--;
 785   SILC_LOG_DEBUG(("Packet context %p refcnt %d->%d", ctx, ctx->users + 1,
 786                   ctx->users));
 787   if (ctx->users < 1)
 788     {
 789       if (ctx->buffer)
 790         silc_buffer_free(ctx->buffer);
 791       if (ctx->src_id)
 792         silc_free(ctx->src_id);
 793       if (ctx->dst_id)
 794         silc_free(ctx->dst_id);
 795       silc_free(ctx);
 796     }
 797 }