lib/silccore/silcpacket.c

   1 /*
   2
   3   silcpacket.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 1997 - 2003 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 /*
  20  * Created: Fri Jul 25 18:52:14 1997
  21  */
  22 /* $Id$ */
  23
  24 #include "silcincludes.h"
  25
  26 /******************************************************************************
  27
  28                           Packet Sending Routines
  29
  30 ******************************************************************************/
  31
  32 /* Actually sends the packet. This flushes the connections outgoing data
  33    buffer. If data is sent directly to the network this returns the bytes
  34    written, if error occured this returns -1 and if the data could not
  35    be written directly to the network at this time this returns -2, in
  36    which case the data should be queued by the caller and sent at some
  37    later time. If `force_send' is TRUE this attempts to write the data
  38    directly to the network, if FALSE, this returns -2. */
  39
  40 int silc_packet_send(SilcSocketConnection sock, bool force_send)
  41 {
  42   SILC_LOG_DEBUG(("Sending packet to %s:%d [%s]", sock->hostname,
  43                   sock->port,
  44                   (sock->type == SILC_SOCKET_TYPE_UNKNOWN ? "Unknown" :
  45                    sock->type == SILC_SOCKET_TYPE_CLIENT ? "Client" :
  46                    sock->type == SILC_SOCKET_TYPE_SERVER ? "Server" :
  47                    "Router")));
  48
  49   /* Send now if forced to do so */
  50   if (force_send == TRUE) {
  51     int ret;
  52
  53     SILC_LOG_DEBUG(("Forcing packet send, packet sent immediately"));
  54
  55     /* Write to network */
  56     ret = silc_socket_write(sock);
  57
  58     if (ret == -1) {
  59       SILC_LOG_ERROR(("Error sending packet, dropped: %s",
  60                       strerror(errno)));
  61     }
  62     if (ret != -2)
  63       return ret;
  64
  65     SILC_LOG_DEBUG(("Could not force the send, packet put to queue"));
  66   }
  67
  68   SILC_LOG_DEBUG(("Packet in queue"));
  69
  70   return -2;
  71 }
  72
  73 /* Encrypts a packet. This also creates HMAC of the packet before
  74    encryption and adds the HMAC at the end of the buffer. This assumes
  75    that there is enough free space at the end of the buffer to add the
  76    computed HMAC. This is the normal way of encrypting packets, if some
  77    other process of HMAC computing and encryption is needed this function
  78    cannot be used. */
  79
  80 void silc_packet_encrypt(SilcCipher cipher, SilcHmac hmac, SilcUInt32 sequence,
  81                          SilcBuffer buffer, SilcUInt32 len)
  82 {
  83
  84   /* Encrypt the data area of the packet. */
  85   if (cipher) {
  86     SILC_LOG_DEBUG(("Encrypting packet (%d), cipher %s, len %d",
  87                     sequence, silc_cipher_get_name(cipher), len));
  88     silc_cipher_encrypt(cipher, buffer->data, buffer->data, len, NULL);
  89   }
  90
  91   /* Compute HMAC. This assumes that MAC is computed from the entire
  92      data area thus this uses the length found in buffer, not the length
  93      sent as argument. */
  94   if (hmac) {
  95     unsigned char mac[32], psn[4];
  96     SilcUInt32 mac_len;
  97
  98     silc_hmac_init(hmac);
  99     SILC_PUT32_MSB(sequence, psn);
 100     silc_hmac_update(hmac, psn, 4);
 101     silc_hmac_update(hmac, buffer->data, buffer->len);
 102     silc_hmac_final(hmac, mac, &mac_len);
 103
 104     /* Put MAC and pull the it into the visible data area in the buffer */
 105     silc_buffer_put_tail(buffer, mac, mac_len);
 106     silc_buffer_pull_tail(buffer, mac_len);
 107   }
 108 }
 109
 110 /* Assembles a new packet to be ready for send out. */
 111
 112 bool silc_packet_assemble(SilcPacketContext *packet, SilcRng rng,
 113                           SilcCipher cipher, SilcHmac hmac,
 114                           SilcSocketConnection sock,
 115                           const unsigned char *data, SilcUInt32 data_len,
 116                           const SilcBuffer assembled_packet)
 117 {
 118   unsigned char tmppad[SILC_PACKET_MAX_PADLEN];
 119   unsigned int block_len = cipher ? silc_cipher_get_block_len(cipher) : 0;
 120   int i, ret;
 121
 122   SILC_LOG_DEBUG(("Assembling outgoing packet"));
 123
 124   /* Calculate the packet's length and padding length if upper layer
 125      didn't already do it. */
 126
 127   /* Get the true length of the packet. This is saved as payload length
 128      into the packet header. This does not include the length of the
 129      padding. */
 130   if (!packet->truelen) {
 131     data_len = SILC_PACKET_DATALEN(data_len, SILC_PACKET_HEADER_LEN +
 132                                    packet->src_id_len + packet->dst_id_len);
 133     packet->truelen = data_len + SILC_PACKET_HEADER_LEN +
 134       packet->src_id_len + packet->dst_id_len;
 135   }
 136
 137   /* Calculate the length of the padding. The padding is calculated from
 138      the data that will be encrypted. */
 139   if (!packet->padlen) {
 140     if (packet->long_pad)
 141       SILC_PACKET_PADLEN_MAX(packet->truelen, block_len, packet->padlen);
 142     else
 143       SILC_PACKET_PADLEN(packet->truelen, block_len, packet->padlen);
 144   }
 145
 146   /* Now prepare the outgoing data buffer for packet sending and start
 147      assembling the packet. */
 148
 149   /* Return pointer to the assembled packet */
 150   if (!silc_packet_send_prepare(sock, packet->truelen - data_len,
 151                                 packet->padlen, data_len, hmac,
 152                                 assembled_packet))
 153     return FALSE;
 154
 155   /* Get random padding */
 156   if (rng)
 157     for (i = 0; i < packet->padlen; i++) tmppad[i] =
 158                                            silc_rng_get_byte_fast(rng);
 159   else
 160     for (i = 0; i < packet->padlen; i++) tmppad[i] =
 161                                            silc_rng_global_get_byte_fast();
 162
 163   /* Create the packet. This creates the SILC header, adds padding, and
 164      the actual packet data. */
 165   ret =
 166     silc_buffer_format(assembled_packet,
 167                        SILC_STR_UI_SHORT(packet->truelen),
 168                        SILC_STR_UI_CHAR(packet->flags),
 169                        SILC_STR_UI_CHAR(packet->type),
 170                        SILC_STR_UI_CHAR(packet->padlen),
 171                        SILC_STR_UI_CHAR(0),
 172                        SILC_STR_UI_CHAR(packet->src_id_len),
 173                        SILC_STR_UI_CHAR(packet->dst_id_len),
 174                        SILC_STR_UI_CHAR(packet->src_id_type),
 175                        SILC_STR_UI_XNSTRING(packet->src_id,
 176                                             packet->src_id_len),
 177                        SILC_STR_UI_CHAR(packet->dst_id_type),
 178                        SILC_STR_UI_XNSTRING(packet->dst_id,
 179                                             packet->dst_id_len),
 180                        SILC_STR_UI_XNSTRING(tmppad, packet->padlen),
 181                        SILC_STR_UI_XNSTRING(data, data_len),
 182                        SILC_STR_END);
 183   if (ret < 0)
 184     return FALSE;
 185
 186   SILC_LOG_HEXDUMP(("Assembled packet, len %d", assembled_packet->len),
 187                    assembled_packet->data, assembled_packet->len);
 188
 189   return TRUE;
 190 }
 191
 192 /* Prepare outgoing data buffer for packet sending. This moves the data
 193    area so that new packet may be added into it. If needed this allocates
 194    more space to the buffer. This handles directly the connection's
 195    outgoing buffer in SilcSocketConnection object, and returns the
 196    pointer to that buffer into the `packet'. */
 197
 198 bool silc_packet_send_prepare(SilcSocketConnection sock,
 199                               SilcUInt32 header_len,
 200                               SilcUInt32 pad_len,
 201                               SilcUInt32 data_len,
 202                               SilcHmac hmac,
 203                               const SilcBuffer packet)
 204 {
 205   SilcUInt32 totlen;
 206   unsigned char *oldptr;
 207   unsigned int mac_len = hmac ? silc_hmac_len(hmac) : 0;
 208
 209   if (!packet)
 210     return FALSE;
 211
 212   totlen = header_len + pad_len + data_len;
 213
 214   /* Prepare the outgoing buffer for packet sending. */
 215   if (!sock->outbuf) {
 216     /* Allocate new buffer. This is done only once per connection. */
 217     SILC_LOG_DEBUG(("Allocating outgoing data buffer"));
 218
 219     sock->outbuf = silc_buffer_alloc(totlen > SILC_PACKET_DEFAULT_SIZE ?
 220                                      totlen : SILC_PACKET_DEFAULT_SIZE);
 221     if (!sock->outbuf)
 222       return FALSE;
 223   } else {
 224     if (!SILC_IS_OUTBUF_PENDING(sock)) {
 225       /* Buffer is free for use */
 226       silc_buffer_clear(sock->outbuf);
 227     }
 228   }
 229
 230   /* Allocate more space if needed */
 231   if ((sock->outbuf->end - sock->outbuf->tail) < (totlen + mac_len)) {
 232     SILC_LOG_DEBUG(("Reallocating outgoing data buffer"));
 233     sock->outbuf = silc_buffer_realloc(sock->outbuf,
 234                                        sock->outbuf->truelen + (totlen * 2));
 235     if (!sock->outbuf)
 236       return FALSE;
 237   }
 238
 239   /* Pull data area for the new packet, and return pointer to the start of
 240      the data area and save the pointer in to the `packet'. */
 241   oldptr = silc_buffer_pull_tail(sock->outbuf, totlen + mac_len);
 242   silc_buffer_set(packet, oldptr, totlen + mac_len);
 243   silc_buffer_push_tail(packet, mac_len);
 244
 245   return TRUE;
 246 }
 247
 248 /******************************************************************************
 249
 250                          Packet Reception Routines
 251
 252 ******************************************************************************/
 253
 254 static int silc_packet_decrypt(SilcCipher cipher, SilcHmac hmac,
 255                                SilcUInt32 sequence, SilcBuffer buffer,
 256                                bool normal);
 257 static bool silc_packet_check_mac(SilcHmac hmac,
 258                                   const unsigned char *data,
 259                                   SilcUInt32 data_len,
 260                                   const unsigned char *packet_mac,
 261                                   SilcUInt32 sequence);
 262
 263 /* Receives packet from network and reads the data into connection's
 264    incoming data buffer. If the data was read directly this returns the
 265    read bytes, if error occured this returns -1, if the data could not
 266    be read directly at this time this returns -2 in which case the data
 267    should be read again at some later time, or If EOF occured this returns
 268    0. */
 269
 270 int silc_packet_receive(SilcSocketConnection sock)
 271 {
 272   int ret;
 273
 274   SILC_LOG_DEBUG(("Receiving packet from %s:%d [%s]", sock->hostname,
 275                   sock->port,
 276                   (sock->type == SILC_SOCKET_TYPE_UNKNOWN ? "Unknown" :
 277                    sock->type == SILC_SOCKET_TYPE_CLIENT ? "Client" :
 278                    sock->type == SILC_SOCKET_TYPE_SERVER ? "Server" :
 279                    "Router")));
 280
 281   /* Read some data from connection */
 282   ret = silc_socket_read(sock);
 283
 284   return ret;
 285 }
 286
 287 /* Processes and decrypts the incmoing data, and calls parser callback
 288    for each received packet that will handle the actual packet parsing.
 289    If more than one packet was received this calls the parser multiple
 290    times.  The parser callback will get context SilcPacketParserContext
 291    that includes the packet and the `parser_context' sent to this
 292    function.
 293
 294    The `local_is_router' indicates whether the caller is router server
 295    in which case the receiving process of a certain packet types may
 296    be special.  Normal server and client must set it to FALSE.  The
 297    SilcPacketParserContext will indicate also whether the received
 298    packet was normal or special packet. */
 299
 300 bool silc_packet_receive_process(SilcSocketConnection sock,
 301                                  bool local_is_router,
 302                                  SilcCipher cipher, SilcHmac hmac,
 303                                  SilcUInt32 sequence,
 304                                  SilcPacketParserCallback parser,
 305                                  void *parser_context)
 306 {
 307   SilcPacketParserContext *parse_ctx;
 308   SilcUInt16 packetlen;
 309   SilcUInt32 paddedlen, mac_len = 0, block_len;
 310   int ret;
 311   bool cont = TRUE;
 312   unsigned char tmp[SILC_PACKET_MIN_HEADER_LEN], *header;
 313   unsigned char iv[SILC_CIPHER_MAX_IV_SIZE];
 314
 315   /* Do not process for disconnected connection */
 316   if (SILC_IS_DISCONNECTING(sock) || SILC_IS_DISCONNECTED(sock))
 317     return TRUE;
 318
 319   if (sock->inbuf->len < SILC_PACKET_MIN_HEADER_LEN)
 320     return TRUE;
 321
 322   if (hmac)
 323     mac_len = silc_hmac_len(hmac);
 324
 325   /* Parse the packets from the data */
 326   while (sock->inbuf->len > 0 && cont) {
 327
 328     if (sock->inbuf->len < SILC_PACKET_MIN_HEADER_LEN) {
 329       SILC_LOG_DEBUG(("Partial packet in queue, waiting for the rest"));
 330       return TRUE;
 331     }
 332
 333     /* Decrypt first block of the packet to get the length field out */
 334     if (cipher) {
 335       block_len = silc_cipher_get_block_len(cipher);
 336       memcpy(iv, silc_cipher_get_iv(cipher), block_len);
 337       silc_cipher_decrypt(cipher, sock->inbuf->data, tmp, block_len, iv);
 338       header = tmp;
 339     } else {
 340       block_len = SILC_PACKET_MIN_HEADER_LEN;
 341       header = sock->inbuf->data;
 342     }
 343
 344     /* Get packet lenght and full packet length with padding */
 345     SILC_PACKET_LENGTH(header, packetlen, paddedlen);
 346
 347     /* Sanity checks */
 348     if (packetlen < SILC_PACKET_MIN_LEN) {
 349       SILC_LOG_ERROR(("Received too short packet"));
 350       memset(header, 0, sizeof(header));
 351       silc_buffer_clear(sock->inbuf);
 352       return FALSE;
 353     }
 354
 355     if (sock->inbuf->len < paddedlen + mac_len) {
 356       SILC_LOG_DEBUG(("Received partial packet, waiting for the rest "
 357                       "(%d bytes)", paddedlen + mac_len - sock->inbuf->len));
 358       SILC_SET_INBUF_PENDING(sock);
 359       memset(tmp, 0, sizeof(tmp));
 360       return TRUE;
 361     }
 362
 363     /* Check MAC of the packet */
 364     if (!silc_packet_check_mac(hmac, sock->inbuf->data, paddedlen,
 365                                sock->inbuf->data + paddedlen, sequence)) {
 366       SILC_LOG_WARNING(("Packet MAC check failed %s:%d "
 367                         "[%s type %d len %dB seq %d] [%s]",
 368                         sock->hostname, sock->port,
 369                         silc_get_packet_name(header[3]),
 370                         header[3], paddedlen, sequence,
 371                         (sock->type == SILC_SOCKET_TYPE_UNKNOWN ? "Unknown" :
 372                          sock->type == SILC_SOCKET_TYPE_CLIENT ? "Client" :
 373                          sock->type == SILC_SOCKET_TYPE_SERVER ? "Server" :
 374                          "Router")));
 375       memset(tmp, 0, sizeof(tmp));
 376       silc_buffer_clear(sock->inbuf);
 377       return FALSE;
 378     }
 379
 380     SILC_UNSET_INBUF_PENDING(sock);
 381     parse_ctx = silc_calloc(1, sizeof(*parse_ctx));
 382     if (!parse_ctx)
 383       return FALSE;
 384     parse_ctx->packet = silc_packet_context_alloc();
 385     parse_ctx->packet->buffer = silc_buffer_alloc_size(paddedlen);
 386     parse_ctx->packet->type = (SilcPacketType)header[3];
 387     parse_ctx->packet->padlen = (SilcUInt8)header[4];
 388     parse_ctx->packet->sequence = sequence++;
 389     parse_ctx->sock = sock;
 390     parse_ctx->context = parser_context;
 391
 392     /* Check whether this is normal or special packet */
 393     if (local_is_router) {
 394       if (header[3] == SILC_PACKET_PRIVATE_MESSAGE &&
 395           (header[2] & SILC_PACKET_FLAG_PRIVMSG_KEY))
 396         parse_ctx->normal = FALSE;
 397       else if (header[3] != SILC_PACKET_CHANNEL_MESSAGE ||
 398                (header[3] == SILC_PACKET_CHANNEL_MESSAGE &&
 399                 sock->type == SILC_SOCKET_TYPE_ROUTER))
 400         parse_ctx->normal = TRUE;
 401     } else {
 402       if (header[3] == SILC_PACKET_PRIVATE_MESSAGE &&
 403           (header[2] & SILC_PACKET_FLAG_PRIVMSG_KEY))
 404         parse_ctx->normal = FALSE;
 405       else if (header[3] != SILC_PACKET_CHANNEL_MESSAGE)
 406         parse_ctx->normal = TRUE;
 407     }
 408
 409     SILC_LOG_HEXDUMP(("Incoming packet (%d) len %d",
 410                       sequence - 1, paddedlen + mac_len),
 411                      sock->inbuf->data, paddedlen + mac_len);
 412
 413     /* Put the decrypted part, and rest of the encrypted data, and decrypt */
 414     silc_buffer_put(parse_ctx->packet->buffer, header, block_len);
 415     silc_buffer_pull(parse_ctx->packet->buffer, block_len);
 416     silc_buffer_put(parse_ctx->packet->buffer, sock->inbuf->data + block_len,
 417                     paddedlen - block_len);
 418     if (cipher) {
 419       silc_cipher_set_iv(cipher, iv);
 420       ret = silc_packet_decrypt(cipher, hmac, parse_ctx->packet->sequence,
 421                                 parse_ctx->packet->buffer,
 422                                 parse_ctx->normal);
 423       if (ret < 0) {
 424         SILC_LOG_WARNING(("Packet decryption failed %s:%d [%s] [%s]",
 425                           sock->hostname, sock->port,
 426                           silc_get_packet_name(parse_ctx->packet->type),
 427                           (sock->type == SILC_SOCKET_TYPE_UNKNOWN ? "Unknown" :
 428                            sock->type == SILC_SOCKET_TYPE_CLIENT ? "Client" :
 429                            sock->type == SILC_SOCKET_TYPE_SERVER ? "Server" :
 430                            "Router")));
 431         memset(tmp, 0, sizeof(tmp));
 432         silc_packet_context_free(parse_ctx->packet);
 433         silc_free(parse_ctx);
 434         return FALSE;
 435       }
 436     }
 437     silc_buffer_push(parse_ctx->packet->buffer, block_len);
 438
 439     SILC_LOG_HEXDUMP(("Fully decrypted packet, len %d",
 440                       parse_ctx->packet->buffer->len),
 441                      parse_ctx->packet->buffer->data,
 442                      parse_ctx->packet->buffer->len);
 443
 444     /* Pull the packet from inbuf thus we'll get the next one
 445        in the inbuf. */
 446     silc_buffer_pull(sock->inbuf, paddedlen + mac_len);
 447
 448     /* Call the parser */
 449     cont = (*parser)(parse_ctx, parser_context);
 450
 451     /* See if socket disconnected while parsing the packet */
 452     if (SILC_IS_DISCONNECTING(sock) || SILC_IS_DISCONNECTED(sock)) {
 453       SILC_LOG_DEBUG(("Abandoning packet processing, socket disconnected"));
 454       cont = FALSE;
 455     }
 456
 457     memset(tmp, 0, sizeof(tmp));
 458   }
 459
 460   if (cont == FALSE && sock->inbuf->len > 0)
 461     return TRUE;
 462
 463   SILC_LOG_DEBUG(("Clearing inbound buffer"));
 464   silc_buffer_clear(sock->inbuf);
 465   return TRUE;
 466 }
 467
 468 /* Checks MAC in the packet. Returns TRUE if MAC is Ok. */
 469
 470 static bool silc_packet_check_mac(SilcHmac hmac,
 471                                   const unsigned char *data,
 472                                   SilcUInt32 data_len,
 473                                   const unsigned char *packet_mac,
 474                                   SilcUInt32 sequence)
 475 {
 476   /* Check MAC */
 477   if (hmac) {
 478     unsigned char mac[32], psn[4];
 479     SilcUInt32 mac_len;
 480
 481     SILC_LOG_DEBUG(("Verifying MAC"));
 482
 483     /* Compute HMAC of packet */
 484     silc_hmac_init(hmac);
 485     SILC_PUT32_MSB(sequence, psn);
 486     silc_hmac_update(hmac, psn, 4);
 487     silc_hmac_update(hmac, data, data_len);
 488     silc_hmac_final(hmac, mac, &mac_len);
 489
 490     /* Compare the MAC's */
 491     if (memcmp(packet_mac, mac, mac_len)) {
 492       SILC_LOG_ERROR(("MAC failed"));
 493       return FALSE;
 494     }
 495
 496     SILC_LOG_DEBUG(("MAC is Ok"));
 497   }
 498
 499   return TRUE;
 500 }
 501
 502 /* Decrypts SILC packet.  Handles both normal and special packet decryption.
 503    Return 0 when packet is normal and 1 when it it special, -1 on error. */
 504
 505 static int silc_packet_decrypt(SilcCipher cipher, SilcHmac hmac,
 506                                SilcUInt32 sequence, SilcBuffer buffer,
 507                                bool normal)
 508 {
 509   /* If the packet type is not any special type lets decrypt rest
 510      of the packet here. */
 511   if (normal == TRUE) {
 512     if (cipher) {
 513       /* Decrypt rest of the packet */
 514       SILC_LOG_DEBUG(("Decrypting the packet"));
 515       if (!silc_cipher_decrypt(cipher, buffer->data, buffer->data,
 516                                buffer->len, NULL)) {
 517         SILC_LOG_ERROR(("silc_cipher_decrypt failed"));
 518         return -1;
 519       }
 520     }
 521     return 0;
 522
 523   } else {
 524     /* Decrypt rest of the header plus padding */
 525     if (cipher) {
 526       SilcUInt16 len;
 527       SilcUInt32 block_len = silc_cipher_get_block_len(cipher);
 528
 529       SILC_LOG_DEBUG(("Decrypting the header"));
 530
 531       /* padding length + src id len + dst id len + header length - 16
 532          bytes already decrypted, gives the rest of the encrypted packet */
 533       silc_buffer_push(buffer, block_len);
 534       len = (((SilcUInt8)buffer->data[4] + (SilcUInt8)buffer->data[6] +
 535               (SilcUInt8)buffer->data[7] + SILC_PACKET_HEADER_LEN) -
 536              block_len);
 537       silc_buffer_pull(buffer, block_len);
 538
 539       if (len > buffer->len) {
 540         SILC_LOG_ERROR(("Garbage in header of packet, bad packet length, "
 541                         "packet dropped"));
 542         return -1;
 543       }
 544       if (!silc_cipher_decrypt(cipher, buffer->data, buffer->data,
 545                                len, NULL)) {
 546         SILC_LOG_ERROR(("silc_cipher_decrypt failed"));
 547         return -1;
 548       }
 549     }
 550
 551     return 1;
 552   }
 553 }
 554
 555 /* Parses the packet. This is called when a whole packet is ready to be
 556    parsed. The buffer sent must be already decrypted before calling this
 557    function. The len argument must be the true length of the packet. This
 558    function returns the type of the packet. The data section of the
 559    buffer is parsed, not head or tail sections. */
 560
 561 SilcPacketType silc_packet_parse(SilcPacketContext *ctx, SilcCipher cipher)
 562 {
 563   SilcBuffer buffer = ctx->buffer;
 564   SilcUInt8 tmp;
 565   int len, ret;
 566   SilcUInt8 src_id_len, src_id_type, dst_id_len, dst_id_type, padlen;
 567
 568   SILC_LOG_DEBUG(("Parsing incoming packet"));
 569
 570   /* Check the length of the buffer */
 571   if (buffer->len < SILC_PACKET_MIN_LEN) {
 572     SILC_LOG_ERROR(("Bad packet length: %d, packet dropped", buffer->len));
 573     return SILC_PACKET_NONE;
 574   }
 575
 576   /* Parse the buffer. This parses the SILC header of the packet. */
 577   len = silc_buffer_unformat(buffer,
 578                              SILC_STR_UI_SHORT(&ctx->truelen),
 579                              SILC_STR_UI_CHAR(&ctx->flags),
 580                              SILC_STR_UI_CHAR(&ctx->type),
 581                              SILC_STR_UI_CHAR(&padlen),
 582                              SILC_STR_UI_CHAR(&tmp),
 583                              SILC_STR_UI_CHAR(&src_id_len),
 584                              SILC_STR_UI_CHAR(&dst_id_len),
 585                              SILC_STR_UI_CHAR(&src_id_type),
 586                              SILC_STR_END);
 587   if (len == -1 || tmp != 0)
 588     return SILC_PACKET_NONE;
 589
 590   if (src_id_len > SILC_PACKET_MAX_ID_LEN ||
 591       dst_id_len > SILC_PACKET_MAX_ID_LEN) {
 592     SILC_LOG_ERROR(("Bad ID lengths in packet (%d and %d)",
 593                     src_id_len, dst_id_len));
 594     return SILC_PACKET_NONE;
 595   }
 596
 597   silc_buffer_pull(buffer, len);
 598   ret = silc_buffer_unformat(buffer,
 599                              SILC_STR_UI_XNSTRING_ALLOC(&ctx->src_id,
 600                                                         src_id_len),
 601                              SILC_STR_UI_CHAR(&dst_id_type),
 602                              SILC_STR_UI_XNSTRING_ALLOC(&ctx->dst_id,
 603                                                         dst_id_len),
 604                              SILC_STR_UI_XNSTRING(NULL, padlen),
 605                              SILC_STR_END);
 606   if (ret == -1)
 607     return SILC_PACKET_NONE;
 608
 609   if (src_id_type > SILC_ID_CHANNEL || dst_id_type > SILC_ID_CHANNEL) {
 610     SILC_LOG_ERROR(("Bad ID types in packet (%d and %d)",
 611                    src_id_type, dst_id_type));
 612     return SILC_PACKET_NONE;
 613   }
 614
 615   ctx->src_id_len = src_id_len;
 616   ctx->dst_id_len = dst_id_len;
 617   ctx->src_id_type = src_id_type;
 618   ctx->dst_id_type = dst_id_type;
 619   ctx->padlen = padlen;
 620
 621   silc_buffer_push(buffer, len);
 622
 623   SILC_LOG_HEXDUMP(("parsed packet, len %d", ctx->buffer->len),
 624                    ctx->buffer->data, ctx->buffer->len);
 625
 626   /* Pull SILC header and padding from packet */
 627   silc_buffer_pull(buffer, SILC_PACKET_HEADER_LEN +
 628                    ctx->src_id_len + ctx->dst_id_len + ctx->padlen);
 629
 630   SILC_LOG_DEBUG(("Incoming packet type: %d", ctx->type));
 631
 632   return ctx->type;
 633 }
 634
 635 /* Perform special SILC Packet header parsing. This is required to some
 636    packet types that have the data payload encrypted with different key
 637    than the header area plus padding of the packet. Hence, this parses
 638    the header in a way that it does not take the data area into account
 639    and parses the header and padding area only. */
 640
 641 SilcPacketType silc_packet_parse_special(SilcPacketContext *ctx,
 642                                          SilcCipher cipher)
 643 {
 644   SilcBuffer buffer = ctx->buffer;
 645   SilcUInt8 tmp;
 646   int len, ret;
 647   SilcUInt8 src_id_len, src_id_type, dst_id_len, dst_id_type, padlen;
 648
 649   SILC_LOG_DEBUG(("Parsing incoming packet"));
 650
 651   /* Check the length of the buffer */
 652   if (buffer->len < SILC_PACKET_MIN_LEN) {
 653     SILC_LOG_ERROR(("Bad packet length: %d, packet dropped", buffer->len));
 654     return SILC_PACKET_NONE;
 655   }
 656
 657   /* Parse the buffer. This parses the SILC header of the packet. */
 658   len = silc_buffer_unformat(buffer,
 659                              SILC_STR_UI_SHORT(&ctx->truelen),
 660                              SILC_STR_UI_CHAR(&ctx->flags),
 661                              SILC_STR_UI_CHAR(&ctx->type),
 662                              SILC_STR_UI_CHAR(&padlen),
 663                              SILC_STR_UI_CHAR(&tmp),
 664                              SILC_STR_UI_CHAR(&src_id_len),
 665                              SILC_STR_UI_CHAR(&dst_id_len),
 666                              SILC_STR_UI_CHAR(&src_id_type),
 667                              SILC_STR_END);
 668   if (len == -1 || tmp != 0) {
 669     SILC_LOG_ERROR(("Malformed packet header, packet dropped"));
 670     return SILC_PACKET_NONE;
 671   }
 672
 673   if (src_id_len > SILC_PACKET_MAX_ID_LEN ||
 674       dst_id_len > SILC_PACKET_MAX_ID_LEN) {
 675     SILC_LOG_ERROR(("Bad ID lengths in packet (%d and %d)",
 676                     src_id_len, dst_id_len));
 677     return SILC_PACKET_NONE;
 678   }
 679
 680   silc_buffer_pull(buffer, len);
 681   ret = silc_buffer_unformat(buffer,
 682                              SILC_STR_UI_XNSTRING_ALLOC(&ctx->src_id,
 683                                                         src_id_len),
 684                              SILC_STR_UI_CHAR(&dst_id_type),
 685                              SILC_STR_UI_XNSTRING_ALLOC(&ctx->dst_id,
 686                                                         dst_id_len),
 687                              SILC_STR_UI_XNSTRING(NULL, padlen),
 688                              SILC_STR_END);
 689   if (ret == -1) {
 690     SILC_LOG_ERROR(("Malformed packet header, packet dropped"));
 691     return SILC_PACKET_NONE;
 692   }
 693
 694   if (src_id_type > SILC_ID_CHANNEL || dst_id_type > SILC_ID_CHANNEL) {
 695     SILC_LOG_ERROR(("Bad ID types in packet (%d and %d)",
 696                    src_id_type, dst_id_type));
 697     return SILC_PACKET_NONE;
 698   }
 699
 700   ctx->src_id_len = src_id_len;
 701   ctx->dst_id_len = dst_id_len;
 702   ctx->src_id_type = src_id_type;
 703   ctx->dst_id_type = dst_id_type;
 704   ctx->padlen = padlen;
 705
 706   silc_buffer_push(buffer, len);
 707
 708   SILC_LOG_HEXDUMP(("parsed packet, len %d", ctx->buffer->len),
 709                    ctx->buffer->data, ctx->buffer->len);
 710
 711   /* Pull SILC header and padding from packet */
 712   silc_buffer_pull(buffer, SILC_PACKET_HEADER_LEN +
 713                    ctx->src_id_len + ctx->dst_id_len + ctx->padlen);
 714
 715   SILC_LOG_DEBUG(("Incoming packet type: %d", ctx->type));
 716
 717   return ctx->type;
 718 }
 719
 720 /* Allocate packet context */
 721
 722 SilcPacketContext *silc_packet_context_alloc(void)
 723 {
 724   SilcPacketContext *ctx = silc_calloc(1, sizeof(*ctx));
 725   if (!ctx)
 726     return NULL;
 727   ctx->users++;
 728   return ctx;
 729 }
 730
 731 /* Increse the reference count of the packet context. */
 732
 733 SilcPacketContext *silc_packet_context_dup(SilcPacketContext *ctx)
 734 {
 735   ctx->users++;
 736   SILC_LOG_DEBUG(("Packet context %p refcnt %d->%d", ctx, ctx->users - 1,
 737                   ctx->users));
 738   return ctx;
 739 }
 740
 741 /* Decrese the reference count of the packet context and free it only if
 742    it is zero. */
 743
 744 void silc_packet_context_free(SilcPacketContext *ctx)
 745 {
 746   ctx->users--;
 747   SILC_LOG_DEBUG(("Packet context %p refcnt %d->%d", ctx, ctx->users + 1,
 748                   ctx->users));
 749   if (ctx->users < 1)
 750     {
 751       if (ctx->buffer)
 752         silc_buffer_free(ctx->buffer);
 753       if (ctx->src_id)
 754         silc_free(ctx->src_id);
 755       if (ctx->dst_id)
 756         silc_free(ctx->dst_id);
 757       silc_free(ctx);
 758     }
 759 }