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