lib/silccore/silcpacket.c

   1 /*
   2
   3   silcpacket.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   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; 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_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     memset(tmp, 0, sizeof(tmp));
 451   }
 452
 453   if (cont == FALSE && sock->inbuf->len > 0)
 454     return TRUE;
 455
 456   SILC_LOG_DEBUG(("Clearing inbound buffer"));
 457   silc_buffer_clear(sock->inbuf);
 458   return TRUE;
 459 }
 460
 461 /* Checks MAC in the packet. Returns TRUE if MAC is Ok. */
 462
 463 static bool silc_packet_check_mac(SilcHmac hmac,
 464                                   const unsigned char *data,
 465                                   SilcUInt32 data_len,
 466                                   const unsigned char *packet_mac,
 467                                   SilcUInt32 sequence)
 468 {
 469   /* Check MAC */
 470   if (hmac) {
 471     unsigned char mac[32], psn[4];
 472     SilcUInt32 mac_len;
 473
 474     SILC_LOG_DEBUG(("Verifying MAC"));
 475
 476     /* Compute HMAC of packet */
 477     silc_hmac_init(hmac);
 478     SILC_PUT32_MSB(sequence, psn);
 479     silc_hmac_update(hmac, psn, 4);
 480     silc_hmac_update(hmac, data, data_len);
 481     silc_hmac_final(hmac, mac, &mac_len);
 482
 483     /* Compare the MAC's */
 484     if (memcmp(packet_mac, mac, mac_len)) {
 485       SILC_LOG_ERROR(("MAC failed"));
 486       return FALSE;
 487     }
 488
 489     SILC_LOG_DEBUG(("MAC is Ok"));
 490   }
 491
 492   return TRUE;
 493 }
 494
 495 /* Decrypts SILC packet.  Handles both normal and special packet decryption.
 496    Return 0 when packet is normal and 1 when it it special, -1 on error. */
 497
 498 static int silc_packet_decrypt(SilcCipher cipher, SilcHmac hmac,
 499                                SilcUInt32 sequence, SilcBuffer buffer,
 500                                bool normal)
 501 {
 502   /* If the packet type is not any special type lets decrypt rest
 503      of the packet here. */
 504   if (normal == TRUE) {
 505     if (cipher) {
 506       /* Decrypt rest of the packet */
 507       SILC_LOG_DEBUG(("Decrypting the packet"));
 508       if (!silc_cipher_decrypt(cipher, buffer->data, buffer->data,
 509                                buffer->len, NULL)) {
 510         SILC_LOG_ERROR(("silc_cipher_decrypt failed"));
 511         return -1;
 512       }
 513     }
 514     return 0;
 515
 516   } else {
 517     /* Decrypt rest of the header plus padding */
 518     if (cipher) {
 519       SilcUInt16 len;
 520       SilcUInt32 block_len = silc_cipher_get_block_len(cipher);
 521
 522       SILC_LOG_DEBUG(("Decrypting the header"));
 523
 524       /* padding length + src id len + dst id len + header length - 16
 525          bytes already decrypted, gives the rest of the encrypted packet */
 526       silc_buffer_push(buffer, block_len);
 527       len = (((SilcUInt8)buffer->data[4] + (SilcUInt8)buffer->data[6] +
 528               (SilcUInt8)buffer->data[7] + SILC_PACKET_HEADER_LEN) -
 529              block_len);
 530
 531       if (len > buffer->len) {
 532         SILC_LOG_ERROR(("Garbage in header of packet, bad packet length, "
 533                         "packet dropped"));
 534         return -1;
 535       }
 536       silc_buffer_pull(buffer, block_len);
 537       if (!silc_cipher_decrypt(cipher, buffer->data, buffer->data,
 538                                len, NULL)) {
 539         SILC_LOG_ERROR(("silc_cipher_decrypt failed"));
 540         return -1;
 541       }
 542     }
 543
 544     return 1;
 545   }
 546 }
 547
 548 /* Parses the packet. This is called when a whole packet is ready to be
 549    parsed. The buffer sent must be already decrypted before calling this
 550    function. The len argument must be the true length of the packet. This
 551    function returns the type of the packet. The data section of the
 552    buffer is parsed, not head or tail sections. */
 553
 554 SilcPacketType silc_packet_parse(SilcPacketContext *ctx, SilcCipher cipher)
 555 {
 556   SilcBuffer buffer = ctx->buffer;
 557   SilcUInt8 tmp;
 558   int len, ret;
 559   SilcUInt8 src_id_len, src_id_type, dst_id_len, dst_id_type, padlen;
 560
 561   SILC_LOG_DEBUG(("Parsing incoming packet"));
 562
 563   /* Check the length of the buffer */
 564   if (buffer->len < SILC_PACKET_MIN_LEN) {
 565     SILC_LOG_ERROR(("Bad packet length: %d, packet dropped", buffer->len));
 566     return SILC_PACKET_NONE;
 567   }
 568
 569   /* Parse the buffer. This parses the SILC header of the packet. */
 570   len = silc_buffer_unformat(buffer,
 571                              SILC_STR_UI_SHORT(&ctx->truelen),
 572                              SILC_STR_UI_CHAR(&ctx->flags),
 573                              SILC_STR_UI_CHAR(&ctx->type),
 574                              SILC_STR_UI_CHAR(&padlen),
 575                              SILC_STR_UI_CHAR(&tmp),
 576                              SILC_STR_UI_CHAR(&src_id_len),
 577                              SILC_STR_UI_CHAR(&dst_id_len),
 578                              SILC_STR_UI_CHAR(&src_id_type),
 579                              SILC_STR_END);
 580   if (len == -1 || tmp != 0)
 581     return SILC_PACKET_NONE;
 582
 583   if (src_id_len > SILC_PACKET_MAX_ID_LEN ||
 584       dst_id_len > SILC_PACKET_MAX_ID_LEN) {
 585     SILC_LOG_ERROR(("Bad ID lengths in packet (%d and %d)",
 586                     src_id_len, dst_id_len));
 587     return SILC_PACKET_NONE;
 588   }
 589
 590   silc_buffer_pull(buffer, len);
 591   ret = silc_buffer_unformat(buffer,
 592                              SILC_STR_UI_XNSTRING_ALLOC(&ctx->src_id,
 593                                                         src_id_len),
 594                              SILC_STR_UI_CHAR(&dst_id_type),
 595                              SILC_STR_UI_XNSTRING_ALLOC(&ctx->dst_id,
 596                                                         dst_id_len),
 597                              SILC_STR_UI_XNSTRING(NULL, padlen),
 598                              SILC_STR_END);
 599   if (ret == -1)
 600     return SILC_PACKET_NONE;
 601
 602   if (src_id_type > SILC_ID_CHANNEL || dst_id_type > SILC_ID_CHANNEL) {
 603     SILC_LOG_ERROR(("Bad ID types in packet (%d and %d)",
 604                    src_id_type, dst_id_type));
 605     return SILC_PACKET_NONE;
 606   }
 607
 608   ctx->src_id_len = src_id_len;
 609   ctx->dst_id_len = dst_id_len;
 610   ctx->src_id_type = src_id_type;
 611   ctx->dst_id_type = dst_id_type;
 612   ctx->padlen = padlen;
 613
 614   silc_buffer_push(buffer, len);
 615
 616   SILC_LOG_HEXDUMP(("parsed packet, len %d", ctx->buffer->len),
 617                    ctx->buffer->data, ctx->buffer->len);
 618
 619   /* Pull SILC header and padding from packet */
 620   silc_buffer_pull(buffer, SILC_PACKET_HEADER_LEN +
 621                    ctx->src_id_len + ctx->dst_id_len + ctx->padlen);
 622
 623   SILC_LOG_DEBUG(("Incoming packet type: %d", ctx->type));
 624
 625   return ctx->type;
 626 }
 627
 628 /* Perform special SILC Packet header parsing. This is required to some
 629    packet types that have the data payload encrypted with different key
 630    than the header area plus padding of the packet. Hence, this parses
 631    the header in a way that it does not take the data area into account
 632    and parses the header and padding area only. */
 633
 634 SilcPacketType silc_packet_parse_special(SilcPacketContext *ctx,
 635                                          SilcCipher cipher)
 636 {
 637   SilcBuffer buffer = ctx->buffer;
 638   SilcUInt8 tmp;
 639   int len, ret;
 640   SilcUInt8 src_id_len, src_id_type, dst_id_len, dst_id_type, padlen;
 641
 642   SILC_LOG_DEBUG(("Parsing incoming packet"));
 643
 644   /* Check the length of the buffer */
 645   if (buffer->len < SILC_PACKET_MIN_LEN) {
 646     SILC_LOG_ERROR(("Bad packet length: %d, packet dropped", buffer->len));
 647     return SILC_PACKET_NONE;
 648   }
 649
 650   /* Parse the buffer. This parses the SILC header of the packet. */
 651   len = silc_buffer_unformat(buffer,
 652                              SILC_STR_UI_SHORT(&ctx->truelen),
 653                              SILC_STR_UI_CHAR(&ctx->flags),
 654                              SILC_STR_UI_CHAR(&ctx->type),
 655                              SILC_STR_UI_CHAR(&padlen),
 656                              SILC_STR_UI_CHAR(&tmp),
 657                              SILC_STR_UI_CHAR(&src_id_len),
 658                              SILC_STR_UI_CHAR(&dst_id_len),
 659                              SILC_STR_UI_CHAR(&src_id_type),
 660                              SILC_STR_END);
 661   if (len == -1 || tmp != 0) {
 662     SILC_LOG_ERROR(("Malformed packet header, packet dropped"));
 663     return SILC_PACKET_NONE;
 664   }
 665
 666   if (src_id_len > SILC_PACKET_MAX_ID_LEN ||
 667       dst_id_len > SILC_PACKET_MAX_ID_LEN) {
 668     SILC_LOG_ERROR(("Bad ID lengths in packet (%d and %d)",
 669                     src_id_len, dst_id_len));
 670     return SILC_PACKET_NONE;
 671   }
 672
 673   silc_buffer_pull(buffer, len);
 674   ret = silc_buffer_unformat(buffer,
 675                              SILC_STR_UI_XNSTRING_ALLOC(&ctx->src_id,
 676                                                         src_id_len),
 677                              SILC_STR_UI_CHAR(&dst_id_type),
 678                              SILC_STR_UI_XNSTRING_ALLOC(&ctx->dst_id,
 679                                                         dst_id_len),
 680                              SILC_STR_UI_XNSTRING(NULL, padlen),
 681                              SILC_STR_END);
 682   if (ret == -1) {
 683     SILC_LOG_ERROR(("Malformed packet header, packet dropped"));
 684     return SILC_PACKET_NONE;
 685   }
 686
 687   if (src_id_type > SILC_ID_CHANNEL || dst_id_type > SILC_ID_CHANNEL) {
 688     SILC_LOG_ERROR(("Bad ID types in packet (%d and %d)",
 689                    src_id_type, dst_id_type));
 690     return SILC_PACKET_NONE;
 691   }
 692
 693   ctx->src_id_len = src_id_len;
 694   ctx->dst_id_len = dst_id_len;
 695   ctx->src_id_type = src_id_type;
 696   ctx->dst_id_type = dst_id_type;
 697   ctx->padlen = padlen;
 698
 699   silc_buffer_push(buffer, len);
 700
 701   SILC_LOG_HEXDUMP(("parsed packet, len %d", ctx->buffer->len),
 702                    ctx->buffer->data, ctx->buffer->len);
 703
 704   /* Pull SILC header and padding from packet */
 705   silc_buffer_pull(buffer, SILC_PACKET_HEADER_LEN +
 706                    ctx->src_id_len + ctx->dst_id_len + ctx->padlen);
 707
 708   SILC_LOG_DEBUG(("Incoming packet type: %d", ctx->type));
 709
 710   return ctx->type;
 711 }
 712
 713 /* Allocate packet context */
 714
 715 SilcPacketContext *silc_packet_context_alloc(void)
 716 {
 717   SilcPacketContext *ctx = silc_calloc(1, sizeof(*ctx));
 718   if (!ctx)
 719     return NULL;
 720   ctx->users++;
 721   return ctx;
 722 }
 723
 724 /* Increse the reference count of the packet context. */
 725
 726 SilcPacketContext *silc_packet_context_dup(SilcPacketContext *ctx)
 727 {
 728   ctx->users++;
 729   SILC_LOG_DEBUG(("Packet context %p refcnt %d->%d", ctx, ctx->users - 1,
 730                   ctx->users));
 731   return ctx;
 732 }
 733
 734 /* Decrese the reference count of the packet context and free it only if
 735    it is zero. */
 736
 737 void silc_packet_context_free(SilcPacketContext *ctx)
 738 {
 739   ctx->users--;
 740   SILC_LOG_DEBUG(("Packet context %p refcnt %d->%d", ctx, ctx->users + 1,
 741                   ctx->users));
 742   if (ctx->users < 1)
 743     {
 744       if (ctx->buffer)
 745         silc_buffer_free(ctx->buffer);
 746       if (ctx->src_id)
 747         silc_free(ctx->src_id);
 748       if (ctx->dst_id)
 749         silc_free(ctx->dst_id);
 750       silc_free(ctx);
 751     }
 752 }