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 blen %dB seq %d] [%s] proto %d",
 368                         sock->hostname, sock->port,
 369                         silc_get_packet_name(header[3]),
 370                         header[3], paddedlen, sock->inbuf->len, 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                         sock->protocol ? sock->protocol->protocol->type : -1));
 376       memset(tmp, 0, sizeof(tmp));
 377       silc_buffer_clear(sock->inbuf);
 378       return FALSE;
 379     }
 380
 381     SILC_UNSET_INBUF_PENDING(sock);
 382     parse_ctx = silc_calloc(1, sizeof(*parse_ctx));
 383     if (!parse_ctx)
 384       return FALSE;
 385     parse_ctx->packet = silc_packet_context_alloc();
 386     parse_ctx->packet->buffer = silc_buffer_alloc_size(paddedlen);
 387     parse_ctx->packet->type = (SilcPacketType)header[3];
 388     parse_ctx->packet->padlen = (SilcUInt8)header[4];
 389     parse_ctx->packet->sequence = sequence++;
 390     parse_ctx->sock = silc_socket_dup(sock);
 391     parse_ctx->context = parser_context;
 392
 393     /* Check whether this is normal or special packet */
 394     if (local_is_router) {
 395       if (header[3] == SILC_PACKET_PRIVATE_MESSAGE &&
 396           (header[2] & SILC_PACKET_FLAG_PRIVMSG_KEY))
 397         parse_ctx->normal = FALSE;
 398       else if (header[3] != SILC_PACKET_CHANNEL_MESSAGE ||
 399                (header[3] == SILC_PACKET_CHANNEL_MESSAGE &&
 400                 sock->type == SILC_SOCKET_TYPE_ROUTER))
 401         parse_ctx->normal = TRUE;
 402     } else {
 403       if (header[3] == SILC_PACKET_PRIVATE_MESSAGE &&
 404           (header[2] & SILC_PACKET_FLAG_PRIVMSG_KEY))
 405         parse_ctx->normal = FALSE;
 406       else if (header[3] != SILC_PACKET_CHANNEL_MESSAGE)
 407         parse_ctx->normal = TRUE;
 408     }
 409
 410     SILC_LOG_HEXDUMP(("Incoming packet (%d) len %d",
 411                       sequence - 1, paddedlen + mac_len),
 412                      sock->inbuf->data, paddedlen + mac_len);
 413
 414     /* Put the decrypted part, and rest of the encrypted data, and decrypt */
 415     silc_buffer_put(parse_ctx->packet->buffer, header, block_len);
 416     silc_buffer_pull(parse_ctx->packet->buffer, block_len);
 417     silc_buffer_put(parse_ctx->packet->buffer, sock->inbuf->data + block_len,
 418                     paddedlen - block_len);
 419     if (cipher) {
 420       silc_cipher_set_iv(cipher, iv);
 421       ret = silc_packet_decrypt(cipher, hmac, parse_ctx->packet->sequence,
 422                                 parse_ctx->packet->buffer,
 423                                 parse_ctx->normal);
 424       if (ret < 0) {
 425         SILC_LOG_WARNING(("Packet decryption failed %s:%d [%s] [%s]",
 426                           sock->hostname, sock->port,
 427                           silc_get_packet_name(parse_ctx->packet->type),
 428                           (sock->type == SILC_SOCKET_TYPE_UNKNOWN ? "Unknown" :
 429                            sock->type == SILC_SOCKET_TYPE_CLIENT ? "Client" :
 430                            sock->type == SILC_SOCKET_TYPE_SERVER ? "Server" :
 431                            "Router")));
 432         memset(tmp, 0, sizeof(tmp));
 433         silc_packet_context_free(parse_ctx->packet);
 434         silc_free(parse_ctx);
 435         return FALSE;
 436       }
 437     }
 438     silc_buffer_push(parse_ctx->packet->buffer, block_len);
 439
 440     SILC_LOG_HEXDUMP(("Fully decrypted packet, len %d",
 441                       parse_ctx->packet->buffer->len),
 442                      parse_ctx->packet->buffer->data,
 443                      parse_ctx->packet->buffer->len);
 444
 445     /* Pull the packet from inbuf thus we'll get the next one
 446        in the inbuf. */
 447     silc_buffer_pull(sock->inbuf, paddedlen + mac_len);
 448
 449     /* Call the parser */
 450     cont = (*parser)(parse_ctx, parser_context);
 451
 452     /* See if socket disconnected while parsing the packet */
 453     if (SILC_IS_DISCONNECTING(sock) || SILC_IS_DISCONNECTED(sock)) {
 454       SILC_LOG_DEBUG(("Abandoning packet processing, socket disconnected"));
 455       cont = FALSE;
 456     }
 457
 458     memset(tmp, 0, sizeof(tmp));
 459   }
 460
 461   /* Don't clear buffer if pending data is in the buffer */
 462   if (cont == FALSE && sock->inbuf->len > 0)
 463     return TRUE;
 464
 465   /* Don't clear buffer if QoS data exists in the buffer */
 466   if (sock->qos && sock->qos->data_len > 0)
 467     return TRUE;
 468
 469   SILC_LOG_DEBUG(("Clearing inbound buffer"));
 470   silc_buffer_clear(sock->inbuf);
 471   return TRUE;
 472 }
 473
 474 /* Checks MAC in the packet. Returns TRUE if MAC is Ok. */
 475
 476 static bool silc_packet_check_mac(SilcHmac hmac,
 477                                   const unsigned char *data,
 478                                   SilcUInt32 data_len,
 479                                   const unsigned char *packet_mac,
 480                                   SilcUInt32 sequence)
 481 {
 482   /* Check MAC */
 483   if (hmac) {
 484     unsigned char mac[32], psn[4];
 485     SilcUInt32 mac_len;
 486
 487     SILC_LOG_DEBUG(("Verifying MAC"));
 488
 489     /* Compute HMAC of packet */
 490     silc_hmac_init(hmac);
 491     SILC_PUT32_MSB(sequence, psn);
 492     silc_hmac_update(hmac, psn, 4);
 493     silc_hmac_update(hmac, data, data_len);
 494     silc_hmac_final(hmac, mac, &mac_len);
 495
 496     /* Compare the MAC's */
 497     if (memcmp(packet_mac, mac, mac_len)) {
 498       SILC_LOG_ERROR(("MAC failed"));
 499       return FALSE;
 500     }
 501
 502     SILC_LOG_DEBUG(("MAC is Ok"));
 503   }
 504
 505   return TRUE;
 506 }
 507
 508 /* Decrypts SILC packet.  Handles both normal and special packet decryption.
 509    Return 0 when packet is normal and 1 when it it special, -1 on error. */
 510
 511 static int silc_packet_decrypt(SilcCipher cipher, SilcHmac hmac,
 512                                SilcUInt32 sequence, SilcBuffer buffer,
 513                                bool normal)
 514 {
 515   /* If the packet type is not any special type lets decrypt rest
 516      of the packet here. */
 517   if (normal == TRUE) {
 518     if (cipher) {
 519       /* Decrypt rest of the packet */
 520       SILC_LOG_DEBUG(("Decrypting the packet"));
 521       if (!silc_cipher_decrypt(cipher, buffer->data, buffer->data,
 522                                buffer->len, NULL)) {
 523         SILC_LOG_ERROR(("silc_cipher_decrypt failed"));
 524         return -1;
 525       }
 526     }
 527     return 0;
 528
 529   } else {
 530     /* Decrypt rest of the header plus padding */
 531     if (cipher) {
 532       SilcUInt16 len;
 533       SilcUInt32 block_len = silc_cipher_get_block_len(cipher);
 534
 535       SILC_LOG_DEBUG(("Decrypting the header"));
 536
 537       /* padding length + src id len + dst id len + header length - 16
 538          bytes already decrypted, gives the rest of the encrypted packet */
 539       silc_buffer_push(buffer, block_len);
 540       len = (((SilcUInt8)buffer->data[4] + (SilcUInt8)buffer->data[6] +
 541               (SilcUInt8)buffer->data[7] + SILC_PACKET_HEADER_LEN) -
 542              block_len);
 543       silc_buffer_pull(buffer, block_len);
 544
 545       if (len > buffer->len) {
 546         SILC_LOG_ERROR(("Garbage in header of packet, bad packet length, "
 547                         "packet dropped"));
 548         return -1;
 549       }
 550       if (!silc_cipher_decrypt(cipher, buffer->data, buffer->data,
 551                                len, NULL)) {
 552         SILC_LOG_ERROR(("silc_cipher_decrypt failed"));
 553         return -1;
 554       }
 555     }
 556
 557     return 1;
 558   }
 559 }
 560
 561 /* Parses the packet. This is called when a whole packet is ready to be
 562    parsed. The buffer sent must be already decrypted before calling this
 563    function. The len argument must be the true length of the packet. This
 564    function returns the type of the packet. The data section of the
 565    buffer is parsed, not head or tail sections. */
 566
 567 SilcPacketType silc_packet_parse(SilcPacketContext *ctx, SilcCipher cipher)
 568 {
 569   SilcBuffer buffer = ctx->buffer;
 570   SilcUInt8 tmp;
 571   int len, ret;
 572   SilcUInt8 src_id_len, src_id_type, dst_id_len, dst_id_type, padlen;
 573
 574   SILC_LOG_DEBUG(("Parsing incoming packet"));
 575
 576   /* Check the length of the buffer */
 577   if (buffer->len < SILC_PACKET_MIN_LEN) {
 578     SILC_LOG_ERROR(("Bad packet length: %d, packet dropped", buffer->len));
 579     return SILC_PACKET_NONE;
 580   }
 581
 582   /* Parse the buffer. This parses the SILC header of the packet. */
 583   len = silc_buffer_unformat(buffer,
 584                              SILC_STR_UI_SHORT(&ctx->truelen),
 585                              SILC_STR_UI_CHAR(&ctx->flags),
 586                              SILC_STR_UI_CHAR(&ctx->type),
 587                              SILC_STR_UI_CHAR(&padlen),
 588                              SILC_STR_UI_CHAR(&tmp),
 589                              SILC_STR_UI_CHAR(&src_id_len),
 590                              SILC_STR_UI_CHAR(&dst_id_len),
 591                              SILC_STR_UI_CHAR(&src_id_type),
 592                              SILC_STR_END);
 593   if (len == -1 || tmp != 0)
 594     return SILC_PACKET_NONE;
 595
 596   if (src_id_len > SILC_PACKET_MAX_ID_LEN ||
 597       dst_id_len > SILC_PACKET_MAX_ID_LEN) {
 598     SILC_LOG_ERROR(("Bad ID lengths in packet (%d and %d)",
 599                     src_id_len, dst_id_len));
 600     return SILC_PACKET_NONE;
 601   }
 602
 603   silc_buffer_pull(buffer, len);
 604   ret = silc_buffer_unformat(buffer,
 605                              SILC_STR_UI_XNSTRING_ALLOC(&ctx->src_id,
 606                                                         src_id_len),
 607                              SILC_STR_UI_CHAR(&dst_id_type),
 608                              SILC_STR_UI_XNSTRING_ALLOC(&ctx->dst_id,
 609                                                         dst_id_len),
 610                              SILC_STR_UI_XNSTRING(NULL, padlen),
 611                              SILC_STR_END);
 612   if (ret == -1)
 613     return SILC_PACKET_NONE;
 614
 615   if (src_id_type > SILC_ID_CHANNEL || dst_id_type > SILC_ID_CHANNEL) {
 616     SILC_LOG_ERROR(("Bad ID types in packet (%d and %d)",
 617                    src_id_type, dst_id_type));
 618     return SILC_PACKET_NONE;
 619   }
 620
 621   ctx->src_id_len = src_id_len;
 622   ctx->dst_id_len = dst_id_len;
 623   ctx->src_id_type = src_id_type;
 624   ctx->dst_id_type = dst_id_type;
 625   ctx->padlen = padlen;
 626
 627   silc_buffer_push(buffer, len);
 628
 629   SILC_LOG_HEXDUMP(("parsed packet, len %d", ctx->buffer->len),
 630                    ctx->buffer->data, ctx->buffer->len);
 631
 632   /* Pull SILC header and padding from packet */
 633   silc_buffer_pull(buffer, SILC_PACKET_HEADER_LEN +
 634                    ctx->src_id_len + ctx->dst_id_len + ctx->padlen);
 635
 636   SILC_LOG_DEBUG(("Incoming packet type: %d", ctx->type));
 637
 638   return ctx->type;
 639 }
 640
 641 /* Perform special SILC Packet header parsing. This is required to some
 642    packet types that have the data payload encrypted with different key
 643    than the header area plus padding of the packet. Hence, this parses
 644    the header in a way that it does not take the data area into account
 645    and parses the header and padding area only. */
 646
 647 SilcPacketType silc_packet_parse_special(SilcPacketContext *ctx,
 648                                          SilcCipher cipher)
 649 {
 650   SilcBuffer buffer = ctx->buffer;
 651   SilcUInt8 tmp;
 652   int len, ret;
 653   SilcUInt8 src_id_len, src_id_type, dst_id_len, dst_id_type, padlen;
 654
 655   SILC_LOG_DEBUG(("Parsing incoming packet"));
 656
 657   /* Check the length of the buffer */
 658   if (buffer->len < SILC_PACKET_MIN_LEN) {
 659     SILC_LOG_ERROR(("Bad packet length: %d, packet dropped", buffer->len));
 660     return SILC_PACKET_NONE;
 661   }
 662
 663   /* Parse the buffer. This parses the SILC header of the packet. */
 664   len = silc_buffer_unformat(buffer,
 665                              SILC_STR_UI_SHORT(&ctx->truelen),
 666                              SILC_STR_UI_CHAR(&ctx->flags),
 667                              SILC_STR_UI_CHAR(&ctx->type),
 668                              SILC_STR_UI_CHAR(&padlen),
 669                              SILC_STR_UI_CHAR(&tmp),
 670                              SILC_STR_UI_CHAR(&src_id_len),
 671                              SILC_STR_UI_CHAR(&dst_id_len),
 672                              SILC_STR_UI_CHAR(&src_id_type),
 673                              SILC_STR_END);
 674   if (len == -1 || tmp != 0) {
 675     SILC_LOG_ERROR(("Malformed packet header, packet dropped"));
 676     return SILC_PACKET_NONE;
 677   }
 678
 679   if (src_id_len > SILC_PACKET_MAX_ID_LEN ||
 680       dst_id_len > SILC_PACKET_MAX_ID_LEN) {
 681     SILC_LOG_ERROR(("Bad ID lengths in packet (%d and %d)",
 682                     src_id_len, dst_id_len));
 683     return SILC_PACKET_NONE;
 684   }
 685
 686   silc_buffer_pull(buffer, len);
 687   ret = silc_buffer_unformat(buffer,
 688                              SILC_STR_UI_XNSTRING_ALLOC(&ctx->src_id,
 689                                                         src_id_len),
 690                              SILC_STR_UI_CHAR(&dst_id_type),
 691                              SILC_STR_UI_XNSTRING_ALLOC(&ctx->dst_id,
 692                                                         dst_id_len),
 693                              SILC_STR_UI_XNSTRING(NULL, padlen),
 694                              SILC_STR_END);
 695   if (ret == -1) {
 696     SILC_LOG_ERROR(("Malformed packet header, packet dropped"));
 697     return SILC_PACKET_NONE;
 698   }
 699
 700   if (src_id_type > SILC_ID_CHANNEL || dst_id_type > SILC_ID_CHANNEL) {
 701     SILC_LOG_ERROR(("Bad ID types in packet (%d and %d)",
 702                    src_id_type, dst_id_type));
 703     return SILC_PACKET_NONE;
 704   }
 705
 706   ctx->src_id_len = src_id_len;
 707   ctx->dst_id_len = dst_id_len;
 708   ctx->src_id_type = src_id_type;
 709   ctx->dst_id_type = dst_id_type;
 710   ctx->padlen = padlen;
 711
 712   silc_buffer_push(buffer, len);
 713
 714   SILC_LOG_HEXDUMP(("parsed packet, len %d", ctx->buffer->len),
 715                    ctx->buffer->data, ctx->buffer->len);
 716
 717   /* Pull SILC header and padding from packet */
 718   silc_buffer_pull(buffer, SILC_PACKET_HEADER_LEN +
 719                    ctx->src_id_len + ctx->dst_id_len + ctx->padlen);
 720
 721   SILC_LOG_DEBUG(("Incoming packet type: %d", ctx->type));
 722
 723   return ctx->type;
 724 }
 725
 726 /* Allocate packet context */
 727
 728 SilcPacketContext *silc_packet_context_alloc(void)
 729 {
 730   SilcPacketContext *ctx = silc_calloc(1, sizeof(*ctx));
 731   if (!ctx)
 732     return NULL;
 733   ctx->users++;
 734   return ctx;
 735 }
 736
 737 /* Increse the reference count of the packet context. */
 738
 739 SilcPacketContext *silc_packet_context_dup(SilcPacketContext *ctx)
 740 {
 741   ctx->users++;
 742   SILC_LOG_DEBUG(("Packet context %p refcnt %d->%d", ctx, ctx->users - 1,
 743                   ctx->users));
 744   return ctx;
 745 }
 746
 747 /* Decrese the reference count of the packet context and free it only if
 748    it is zero. */
 749
 750 void silc_packet_context_free(SilcPacketContext *ctx)
 751 {
 752   ctx->users--;
 753   SILC_LOG_DEBUG(("Packet context %p refcnt %d->%d", ctx, ctx->users + 1,
 754                   ctx->users));
 755   if (ctx->users < 1)
 756     {
 757       if (ctx->buffer)
 758         silc_buffer_free(ctx->buffer);
 759       if (ctx->src_id)
 760         silc_free(ctx->src_id);
 761       if (ctx->dst_id)
 762         silc_free(ctx->dst_id);
 763       silc_free(ctx);
 764     }
 765 }