apps/silcd/packet_send.c

   1 /*
   2
   3   packet_send.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; either version 2 of the License, or
  12   (at your option) any later version.
  13
  14   This program is distributed in the hope that it will be useful,
  15   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17   GNU General Public License for more details.
  18
  19 */
  20 /*
  21  * Server packet routines to send packets.
  22  */
  23 /* $Id$ */
  24
  25 #include "serverincludes.h"
  26 #include "server_internal.h"
  27
  28 /* Routine that sends packet or marks packet to be sent. This is used
  29    directly only in special cases. Normal cases should use
  30    silc_server_packet_send. Returns < 0 error. */
  31
  32 int silc_server_packet_send_real(SilcServer server,
  33                                  SilcSocketConnection sock,
  34                                  int force_send)
  35 {
  36   int ret;
  37
  38   /* If disconnecting, ignore the data */
  39   if (SILC_IS_DISCONNECTING(sock))
  40     return -1;
  41
  42   /* If rekey protocol is active we must assure that all packets are
  43      sent through packet queue. */
  44   if (SILC_SERVER_IS_REKEY(sock))
  45     force_send = FALSE;
  46
  47   /* Send the packet */
  48   ret = silc_packet_send(sock, force_send);
  49   if (ret != -2)
  50     return ret;
  51
  52   /* Mark that there is some outgoing data available for this connection.
  53      This call sets the connection both for input and output (the input
  54      is set always and this call keeps the input setting, actually).
  55      Actual data sending is performed by silc_server_packet_process. */
  56   SILC_SET_CONNECTION_FOR_OUTPUT(server->schedule, sock->sock);
  57
  58   /* Mark to socket that data is pending in outgoing buffer. This flag
  59      is needed if new data is added to the buffer before the earlier
  60      put data is sent to the network. */
  61   SILC_SET_OUTBUF_PENDING(sock);
  62
  63   return 0;
  64 }
  65
  66 /* Assembles a new packet to be sent out to network. This doesn't actually
  67    send the packet but creates the packet and fills the outgoing data
  68    buffer and marks the packet ready to be sent to network. However, If
  69    argument force_send is TRUE the packet is sent immediately and not put
  70    to queue. Normal case is that the packet is not sent immediately. */
  71
  72 void silc_server_packet_send(SilcServer server,
  73                              SilcSocketConnection sock,
  74                              SilcPacketType type,
  75                              SilcPacketFlags flags,
  76                              unsigned char *data,
  77                              uint32 data_len,
  78                              int force_send)
  79 {
  80   void *dst_id = NULL;
  81   SilcIdType dst_id_type = SILC_ID_NONE;
  82
  83   if (!sock)
  84     return;
  85
  86   /* If disconnecting, ignore the data */
  87   if (SILC_IS_DISCONNECTING(sock))
  88     return;
  89
  90   /* Get data used in the packet sending, keys and stuff */
  91   switch(sock->type) {
  92   case SILC_SOCKET_TYPE_CLIENT:
  93     if (sock->user_data) {
  94       dst_id = ((SilcClientEntry)sock->user_data)->id;
  95       dst_id_type = SILC_ID_CLIENT;
  96     }
  97     break;
  98   case SILC_SOCKET_TYPE_SERVER:
  99   case SILC_SOCKET_TYPE_ROUTER:
 100     if (sock->user_data) {
 101       dst_id = ((SilcServerEntry)sock->user_data)->id;
 102       dst_id_type = SILC_ID_SERVER;
 103     }
 104     break;
 105   default:
 106     break;
 107   }
 108
 109   silc_server_packet_send_dest(server, sock, type, flags, dst_id,
 110                                dst_id_type, data, data_len, force_send);
 111 }
 112
 113 /* Assembles a new packet to be sent out to network. This doesn't actually
 114    send the packet but creates the packet and fills the outgoing data
 115    buffer and marks the packet ready to be sent to network. However, If
 116    argument force_send is TRUE the packet is sent immediately and not put
 117    to queue. Normal case is that the packet is not sent immediately.
 118    Destination information is sent as argument for this function. */
 119
 120 void silc_server_packet_send_dest(SilcServer server,
 121                                   SilcSocketConnection sock,
 122                                   SilcPacketType type,
 123                                   SilcPacketFlags flags,
 124                                   void *dst_id,
 125                                   SilcIdType dst_id_type,
 126                                   unsigned char *data,
 127                                   uint32 data_len,
 128                                   int force_send)
 129 {
 130   SilcPacketContext packetdata;
 131   SilcIDListData idata;
 132   SilcCipher cipher = NULL;
 133   SilcHmac hmac = NULL;
 134   unsigned char *dst_id_data = NULL;
 135   uint32 dst_id_len = 0;
 136
 137   /* If disconnecting, ignore the data */
 138   if (SILC_IS_DISCONNECTING(sock))
 139     return;
 140
 141   SILC_LOG_DEBUG(("Sending packet, type %d", type));
 142
 143   /* Get data used in the packet sending, keys and stuff */
 144   idata = (SilcIDListData)sock->user_data;
 145
 146   if (dst_id) {
 147     dst_id_data = silc_id_id2str(dst_id, dst_id_type);
 148     dst_id_len = silc_id_get_len(dst_id, dst_id_type);
 149   }
 150
 151   /* Set the packet context pointers */
 152   packetdata.type = type;
 153   packetdata.flags = flags;
 154   packetdata.src_id = silc_id_id2str(server->id, server->id_type);
 155   packetdata.src_id_len = silc_id_get_len(server->id, server->id_type);
 156   packetdata.src_id_type = server->id_type;
 157   packetdata.dst_id = dst_id_data;
 158   packetdata.dst_id_len = dst_id_len;
 159   packetdata.dst_id_type = dst_id_type;
 160   packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
 161     packetdata.src_id_len + dst_id_len;
 162   packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen);
 163
 164   /* Prepare outgoing data buffer for packet sending */
 165   silc_packet_send_prepare(sock,
 166                            SILC_PACKET_HEADER_LEN +
 167                            packetdata.src_id_len +
 168                            packetdata.dst_id_len,
 169                            packetdata.padlen,
 170                            data_len);
 171
 172   SILC_LOG_DEBUG(("Putting data to outgoing buffer, len %d", data_len));
 173
 174   packetdata.buffer = sock->outbuf;
 175
 176   /* Put the data to the buffer */
 177   if (data && data_len)
 178     silc_buffer_put(sock->outbuf, data, data_len);
 179
 180   /* Create the outgoing packet */
 181   silc_packet_assemble(&packetdata);
 182
 183   if (idata) {
 184     cipher = idata->send_key;
 185     hmac = idata->hmac_send;
 186   }
 187
 188   /* Encrypt the packet */
 189   silc_packet_encrypt(cipher, hmac, sock->outbuf, sock->outbuf->len);
 190
 191   SILC_LOG_HEXDUMP(("Outgoing packet, len %d", sock->outbuf->len),
 192                    sock->outbuf->data, sock->outbuf->len);
 193
 194   /* Now actually send the packet */
 195   silc_server_packet_send_real(server, sock, force_send);
 196
 197   if (packetdata.src_id)
 198     silc_free(packetdata.src_id);
 199   if (packetdata.dst_id)
 200     silc_free(packetdata.dst_id);
 201 }
 202
 203 /* Assembles a new packet to be sent out to network. This doesn't actually
 204    send the packet but creates the packet and fills the outgoing data
 205    buffer and marks the packet ready to be sent to network. However, If
 206    argument force_send is TRUE the packet is sent immediately and not put
 207    to queue. Normal case is that the packet is not sent immediately.
 208    The source and destination information is sent as argument for this
 209    function. */
 210
 211 void silc_server_packet_send_srcdest(SilcServer server,
 212                                      SilcSocketConnection sock,
 213                                      SilcPacketType type,
 214                                      SilcPacketFlags flags,
 215                                      void *src_id,
 216                                      SilcIdType src_id_type,
 217                                      void *dst_id,
 218                                      SilcIdType dst_id_type,
 219                                      unsigned char *data,
 220                                      uint32 data_len,
 221                                      int force_send)
 222 {
 223   SilcPacketContext packetdata;
 224   SilcIDListData idata;
 225   SilcCipher cipher = NULL;
 226   SilcHmac hmac = NULL;
 227   unsigned char *dst_id_data = NULL;
 228   uint32 dst_id_len = 0;
 229   unsigned char *src_id_data = NULL;
 230   uint32 src_id_len = 0;
 231
 232   SILC_LOG_DEBUG(("Sending packet, type %d", type));
 233
 234   /* Get data used in the packet sending, keys and stuff */
 235   idata = (SilcIDListData)sock->user_data;
 236
 237   if (dst_id) {
 238     dst_id_data = silc_id_id2str(dst_id, dst_id_type);
 239     dst_id_len = silc_id_get_len(dst_id, dst_id_type);
 240   }
 241
 242   if (src_id) {
 243     src_id_data = silc_id_id2str(src_id, src_id_type);
 244     src_id_len = silc_id_get_len(src_id, src_id_type);
 245   }
 246
 247   /* Set the packet context pointers */
 248   packetdata.type = type;
 249   packetdata.flags = flags;
 250   packetdata.src_id = src_id_data;
 251   packetdata.src_id_len = src_id_len;
 252   packetdata.src_id_type = src_id_type;
 253   packetdata.dst_id = dst_id_data;
 254   packetdata.dst_id_len = dst_id_len;
 255   packetdata.dst_id_type = dst_id_type;
 256   packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
 257     packetdata.src_id_len + dst_id_len;
 258   packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen);
 259
 260   /* Prepare outgoing data buffer for packet sending */
 261   silc_packet_send_prepare(sock,
 262                            SILC_PACKET_HEADER_LEN +
 263                            packetdata.src_id_len +
 264                            packetdata.dst_id_len,
 265                            packetdata.padlen,
 266                            data_len);
 267
 268   SILC_LOG_DEBUG(("Putting data to outgoing buffer, len %d", data_len));
 269
 270   packetdata.buffer = sock->outbuf;
 271
 272   /* Put the data to the buffer */
 273   if (data && data_len)
 274     silc_buffer_put(sock->outbuf, data, data_len);
 275
 276   /* Create the outgoing packet */
 277   silc_packet_assemble(&packetdata);
 278
 279   if (idata) {
 280     cipher = idata->send_key;
 281     hmac = idata->hmac_send;
 282   }
 283
 284   /* Encrypt the packet */
 285   silc_packet_encrypt(cipher, hmac, sock->outbuf, sock->outbuf->len);
 286
 287   SILC_LOG_HEXDUMP(("Outgoing packet, len %d", sock->outbuf->len),
 288                    sock->outbuf->data, sock->outbuf->len);
 289
 290   /* Now actually send the packet */
 291   silc_server_packet_send_real(server, sock, force_send);
 292
 293   if (packetdata.src_id)
 294     silc_free(packetdata.src_id);
 295   if (packetdata.dst_id)
 296     silc_free(packetdata.dst_id);
 297 }
 298
 299 /* Broadcast received packet to our primary route. This function is used
 300    by router to further route received broadcast packet. It is expected
 301    that the broadcast flag from the packet is checked before calling this
 302    function. This does not test or set the broadcast flag. */
 303
 304 void silc_server_packet_broadcast(SilcServer server,
 305                                   SilcSocketConnection sock,
 306                                   SilcPacketContext *packet)
 307 {
 308   SilcBuffer buffer = packet->buffer;
 309   SilcIDListData idata;
 310   void *id;
 311
 312   SILC_LOG_DEBUG(("Broadcasting received broadcast packet"));
 313
 314   /* If the packet is originated from our primary route we are
 315      not allowed to send the packet. */
 316   id = silc_id_str2id(packet->src_id, packet->src_id_len, packet->src_id_type);
 317   if (id && !SILC_ID_SERVER_COMPARE(id, server->router->id)) {
 318     idata = (SilcIDListData)sock->user_data;
 319
 320     silc_buffer_push(buffer, buffer->data - buffer->head);
 321     silc_packet_send_prepare(sock, 0, 0, buffer->len);
 322     silc_buffer_put(sock->outbuf, buffer->data, buffer->len);
 323     silc_packet_encrypt(idata->send_key, idata->hmac_send,
 324                         sock->outbuf, sock->outbuf->len);
 325
 326     SILC_LOG_HEXDUMP(("Broadcasted packet, len %d", sock->outbuf->len),
 327                      sock->outbuf->data, sock->outbuf->len);
 328
 329     /* Now actually send the packet */
 330     silc_server_packet_send_real(server, sock, TRUE);
 331     silc_free(id);
 332     return;
 333   }
 334
 335   SILC_LOG_DEBUG(("Will not broadcast to primary route since it is the "
 336                   "original sender of this packet"));
 337   silc_free(id);
 338 }
 339
 340 /* Routes received packet to `sock'. This is used to route the packets that
 341    router receives but are not destined to it. */
 342
 343 void silc_server_packet_route(SilcServer server,
 344                               SilcSocketConnection sock,
 345                               SilcPacketContext *packet)
 346 {
 347   SilcBuffer buffer = packet->buffer;
 348   SilcIDListData idata;
 349
 350   SILC_LOG_DEBUG(("Routing received packet"));
 351
 352   idata = (SilcIDListData)sock->user_data;
 353
 354   silc_buffer_push(buffer, buffer->data - buffer->head);
 355   silc_packet_send_prepare(sock, 0, 0, buffer->len);
 356   silc_buffer_put(sock->outbuf, buffer->data, buffer->len);
 357   silc_packet_encrypt(idata->send_key, idata->hmac_send,
 358                       sock->outbuf, sock->outbuf->len);
 359
 360   SILC_LOG_HEXDUMP(("Routed packet, len %d", sock->outbuf->len),
 361                    sock->outbuf->data, sock->outbuf->len);
 362
 363   /* Now actually send the packet */
 364   silc_server_packet_send_real(server, sock, TRUE);
 365 }
 366
 367 /* Internal routine to actually create the channel packet and send it
 368    to network. This is common function in channel message sending. If
 369    `channel_message' is TRUE this encrypts the message as it is strictly
 370    a channel message. If FALSE normal encryption process is used. */
 371
 372 static void
 373 silc_server_packet_send_to_channel_real(SilcServer server,
 374                                         SilcSocketConnection sock,
 375                                         SilcPacketContext *packet,
 376                                         SilcCipher cipher,
 377                                         SilcHmac hmac,
 378                                         unsigned char *data,
 379                                         uint32 data_len,
 380                                         int channel_message,
 381                                         int force_send)
 382 {
 383   packet->truelen = data_len + SILC_PACKET_HEADER_LEN +
 384     packet->src_id_len + packet->dst_id_len;
 385
 386   /* Prepare outgoing data buffer for packet sending */
 387   silc_packet_send_prepare(sock,
 388                            SILC_PACKET_HEADER_LEN +
 389                            packet->src_id_len +
 390                            packet->dst_id_len,
 391                            packet->padlen,
 392                            data_len);
 393
 394   packet->buffer = sock->outbuf;
 395
 396   /* Put the data to buffer, assemble and encrypt the packet. The packet
 397      is encrypted with normal session key shared with the client. */
 398   silc_buffer_put(sock->outbuf, data, data_len);
 399   silc_packet_assemble(packet);
 400   if (channel_message)
 401     silc_packet_encrypt(cipher, hmac, sock->outbuf, SILC_PACKET_HEADER_LEN +
 402                         packet->src_id_len + packet->dst_id_len +
 403                         packet->padlen);
 404   else
 405     silc_packet_encrypt(cipher, hmac, sock->outbuf, sock->outbuf->len);
 406
 407   SILC_LOG_HEXDUMP(("Channel packet, len %d", sock->outbuf->len),
 408                    sock->outbuf->data, sock->outbuf->len);
 409
 410   /* Now actually send the packet */
 411   silc_server_packet_send_real(server, sock, force_send);
 412 }
 413
 414 /* This routine is used by the server to send packets to channel. The
 415    packet sent with this function is distributed to all clients on
 416    the channel. Usually this is used to send notify messages to the
 417    channel, things like notify about new user joining to the channel.
 418    If `route' is FALSE then the packet is sent only locally and will not
 419    be routed anywhere (for router locally means cell wide). If `sender'
 420    is provided then the packet is not sent to that connection since it
 421    originally came from it. */
 422
 423 void silc_server_packet_send_to_channel(SilcServer server,
 424                                         SilcSocketConnection sender,
 425                                         SilcChannelEntry channel,
 426                                         SilcPacketType type,
 427                                         unsigned char route,
 428                                         unsigned char *data,
 429                                         uint32 data_len,
 430                                         int force_send)
 431 {
 432   SilcSocketConnection sock = NULL;
 433   SilcPacketContext packetdata;
 434   SilcClientEntry client = NULL;
 435   SilcServerEntry *routed = NULL;
 436   SilcChannelClientEntry chl;
 437   SilcHashTableList htl;
 438   SilcIDListData idata;
 439   uint32 routed_count = 0;
 440
 441   /* This doesn't send channel message packets */
 442   if (type == SILC_PACKET_CHANNEL_MESSAGE)
 443     return;
 444
 445   SILC_LOG_DEBUG(("Sending packet to channel"));
 446
 447   /* Set the packet context pointers. */
 448   packetdata.flags = 0;
 449   packetdata.type = type;
 450   packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
 451   packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
 452   packetdata.src_id_type = SILC_ID_SERVER;
 453   packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
 454   packetdata.dst_id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
 455   packetdata.dst_id_type = SILC_ID_CHANNEL;
 456   packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
 457     packetdata.src_id_len + packetdata.dst_id_len;
 458   packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen);
 459
 460   /* If there are global users in the channel we will send the message
 461      first to our router for further routing. */
 462   if (route && server->server_type == SILC_SERVER && !server->standalone &&
 463       channel->global_users) {
 464     SilcServerEntry router;
 465
 466     /* Get data used in packet header encryption, keys and stuff. */
 467     router = server->router;
 468     sock = (SilcSocketConnection)router->connection;
 469     idata = (SilcIDListData)router;
 470
 471     if (sock != sender) {
 472       SILC_LOG_DEBUG(("Sending channel message to router for routing"));
 473
 474       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 475                                               idata->send_key,
 476                                               idata->hmac_send,
 477                                               data, data_len, FALSE,
 478                                               force_send);
 479     }
 480   }
 481
 482   /* Send the message to clients on the channel's client list. */
 483   silc_hash_table_list(channel->user_list, &htl);
 484   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
 485     client = chl->client;
 486
 487     /* If client has router set it is not locally connected client and
 488        we will route the message to the router set in the client. Though,
 489        send locally connected server in all cases. */
 490     if (server->server_type == SILC_ROUTER && client && client->router &&
 491         ((!route && client->router->router == server->id_entry) || route)) {
 492       int k;
 493
 494       /* Check if we have sent the packet to this route already */
 495       for (k = 0; k < routed_count; k++)
 496         if (routed[k] == client->router)
 497           break;
 498       if (k < routed_count)
 499         continue;
 500
 501       /* Get data used in packet header encryption, keys and stuff. */
 502       sock = (SilcSocketConnection)client->router->connection;
 503       idata = (SilcIDListData)client->router;
 504
 505       if (sender && sock == sender)
 506         continue;
 507
 508       /* Send the packet */
 509       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 510                                               idata->send_key,
 511                                               idata->hmac_send,
 512                                               data, data_len, FALSE,
 513                                               force_send);
 514
 515       /* We want to make sure that the packet is routed to same router
 516          only once. Mark this route as sent route. */
 517       k = routed_count;
 518       routed = silc_realloc(routed, sizeof(*routed) * (k + 1));
 519       routed[k] = client->router;
 520       routed_count++;
 521
 522       continue;
 523     }
 524
 525     if (client && client->router)
 526       continue;
 527
 528     /* Send to locally connected client */
 529     if (client) {
 530
 531       /* Get data used in packet header encryption, keys and stuff. */
 532       sock = (SilcSocketConnection)client->connection;
 533       idata = (SilcIDListData)client;
 534
 535       if (sender && sock == sender)
 536         continue;
 537
 538       /* Send the packet */
 539       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 540                                               idata->send_key,
 541                                               idata->hmac_send,
 542                                               data, data_len, FALSE,
 543                                               force_send);
 544     }
 545   }
 546
 547   if (routed_count)
 548     silc_free(routed);
 549   silc_free(packetdata.src_id);
 550   silc_free(packetdata.dst_id);
 551 }
 552
 553 /* This checks whether the relayed packet came from router. If it did
 554    then we'll need to encrypt it with the channel key. This is called
 555    from the silc_server_packet_relay_to_channel. */
 556
 557 static void
 558 silc_server_packet_relay_to_channel_encrypt(SilcServer server,
 559                                             SilcSocketConnection sock,
 560                                             SilcChannelEntry channel,
 561                                             unsigned char *data,
 562                                             unsigned int data_len)
 563 {
 564   /* If we are router and the packet came from router and private key
 565      has not been set for the channel then we must encrypt the packet
 566      as it was decrypted with the session key shared between us and the
 567      router which sent it. This is so, because cells does not share the
 568      same channel key. */
 569   if (server->server_type == SILC_ROUTER &&
 570       sock->type == SILC_SOCKET_TYPE_ROUTER &&
 571       !(channel->mode & SILC_CHANNEL_MODE_PRIVKEY) &&
 572       channel->channel_key) {
 573     SilcBuffer chp;
 574     uint32 iv_len, i;
 575     uint16 data_len, flags;
 576
 577     iv_len = silc_cipher_get_block_len(channel->channel_key);
 578     if (channel->iv[0] == '\0')
 579       for (i = 0; i < iv_len; i++) channel->iv[i] =
 580                                      silc_rng_get_byte(server->rng);
 581     else
 582       silc_hash_make(server->md5hash, channel->iv, iv_len, channel->iv);
 583
 584     /* Encode new payload. This encrypts it also. */
 585     SILC_GET16_MSB(flags, data);
 586     SILC_GET16_MSB(data_len, data + 2);
 587     chp = silc_channel_message_payload_encode(flags, data_len,
 588                                               data + 4,
 589                                               iv_len, channel->iv,
 590                                               channel->channel_key,
 591                                               channel->hmac);
 592     memcpy(data, chp->data, chp->len);
 593     silc_buffer_free(chp);
 594   }
 595 }
 596
 597 /* This routine is explicitly used to relay messages to some channel.
 598    Packets sent with this function we have received earlier and are
 599    totally encrypted. This just sends the packet to all clients on
 600    the channel. If the sender of the packet is someone on the channel
 601    the message will not be sent to that client. The SILC Packet header
 602    is encrypted with the session key shared between us and the client.
 603    MAC is also computed before encrypting the header. Rest of the
 604    packet will be untouched. */
 605
 606 void silc_server_packet_relay_to_channel(SilcServer server,
 607                                          SilcSocketConnection sender_sock,
 608                                          SilcChannelEntry channel,
 609                                          void *sender,
 610                                          SilcIdType sender_type,
 611                                          void *sender_entry,
 612                                          unsigned char *data,
 613                                          uint32 data_len,
 614                                          int force_send)
 615 {
 616   bool found = FALSE;
 617   SilcSocketConnection sock = NULL;
 618   SilcPacketContext packetdata;
 619   SilcClientEntry client = NULL;
 620   SilcServerEntry *routed = NULL;
 621   SilcChannelClientEntry chl;
 622   uint32 routed_count = 0;
 623   SilcIDListData idata;
 624   SilcHashTableList htl;
 625
 626   SILC_LOG_DEBUG(("Relaying packet to channel"));
 627
 628   /* Set the packet context pointers. */
 629   packetdata.flags = 0;
 630   packetdata.type = SILC_PACKET_CHANNEL_MESSAGE;
 631   packetdata.src_id = silc_id_id2str(sender, sender_type);
 632   packetdata.src_id_len = silc_id_get_len(sender, sender_type);
 633   packetdata.src_id_type = sender_type;
 634   packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
 635   packetdata.dst_id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
 636   packetdata.dst_id_type = SILC_ID_CHANNEL;
 637   packetdata.padlen = SILC_PACKET_PADLEN((SILC_PACKET_HEADER_LEN +
 638                                           packetdata.src_id_len +
 639                                           packetdata.dst_id_len));
 640
 641   /* This encrypts the packet, if needed. It will be encrypted if
 642      it came from the router thus it needs to be encrypted with the
 643      channel key. If the channel key does not exist, then we know we
 644      don't have a single local user on the channel. */
 645   silc_server_packet_relay_to_channel_encrypt(server, sender_sock,
 646                                               channel, data,
 647                                               data_len);
 648
 649   /* If there are global users in the channel we will send the message
 650      first to our router for further routing. */
 651   if (server->server_type == SILC_SERVER && !server->standalone &&
 652       channel->global_users) {
 653     SilcServerEntry router;
 654
 655     router = server->router;
 656
 657     /* Check that the sender is not our router. */
 658     if (sender_sock != (SilcSocketConnection)router->connection) {
 659
 660       /* Get data used in packet header encryption, keys and stuff. */
 661       sock = (SilcSocketConnection)router->connection;
 662       idata = (SilcIDListData)router;
 663
 664       SILC_LOG_DEBUG(("Sending channel message to router for routing"));
 665
 666       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 667                                               idata->send_key,
 668                                               idata->hmac_send,
 669                                               data, data_len, TRUE,
 670                                               force_send);
 671     }
 672   }
 673
 674   /* Send the message to clients on the channel's client list. */
 675   silc_hash_table_list(channel->user_list, &htl);
 676   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
 677     client = chl->client;
 678
 679     if (client) {
 680
 681       /* If sender is one on the channel do not send it the packet. */
 682       if (!found && sender_type == SILC_ID_CLIENT &&
 683           SILC_ID_CLIENT_COMPARE(client->id, sender)) {
 684         found = TRUE;
 685         continue;
 686       }
 687
 688       /* If the client has set router it means that it is not locally
 689          connected client and we will route the packet further. */
 690       if (server->server_type == SILC_ROUTER && client->router) {
 691         int k;
 692
 693         /* Sender maybe server as well so we want to make sure that
 694            we won't send the message to the server it came from. */
 695         if (!found && SILC_ID_SERVER_COMPARE(client->router->id, sender)) {
 696           found = TRUE;
 697           continue;
 698         }
 699
 700         /* Check if we have sent the packet to this route already */
 701         for (k = 0; k < routed_count; k++)
 702           if (routed[k] == client->router)
 703             break;
 704         if (k < routed_count)
 705           continue;
 706
 707         /* Get data used in packet header encryption, keys and stuff. */
 708         sock = (SilcSocketConnection)client->router->connection;
 709         idata = (SilcIDListData)client->router;
 710
 711         /* Do not send to the sender. Check first whether the true
 712            sender's router is same as this client's router. Also check
 713            if the sender socket is the same as this client's router
 714            socket. */
 715         if (sender_entry &&
 716             ((SilcClientEntry)sender_entry)->router == client->router)
 717           continue;
 718         if (sender_sock && sock == sender_sock)
 719           continue;
 720
 721         SILC_LOG_DEBUG(("Relaying packet to client ID(%s) %s (%s)",
 722                         silc_id_render(client->id, SILC_ID_CLIENT),
 723                         sock->hostname, sock->ip));
 724
 725         /* We want to make sure that the packet is routed to same router
 726            only once. Mark this route as sent route. */
 727         k = routed_count;
 728         routed = silc_realloc(routed, sizeof(*routed) * (k + 1));
 729         routed[k] = client->router;
 730         routed_count++;
 731
 732         /* If the remote connection is router then we'll decrypt the
 733            channel message and re-encrypt it with the session key shared
 734            between us and the remote router. This is done because the
 735            channel keys are cell specific and we have different channel
 736            key than the remote router has. */
 737         if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
 738
 739           /* If private key mode is not set then decrypt the packet
 740              and re-encrypt it */
 741           if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
 742             unsigned char *tmp = silc_calloc(data_len, sizeof(*data));
 743             memcpy(tmp, data, data_len);
 744
 745             /* Decrypt the channel message (we don't check the MAC) */
 746             /* XXX this could be optimized and removed all together by
 747                taking a copy of the original data before encrypting it
 748                and thus would not required decrypting. */
 749             if (channel->channel_key &&
 750                 !silc_channel_message_payload_decrypt(tmp, data_len,
 751                                                       channel->channel_key,
 752                                                       NULL)) {
 753               memset(tmp, 0, data_len);
 754               silc_free(tmp);
 755               continue;
 756             }
 757
 758             /* Now re-encrypt and send it to the router */
 759             silc_server_packet_send_srcdest(server, sock,
 760                                             SILC_PACKET_CHANNEL_MESSAGE, 0,
 761                                             sender, sender_type,
 762                                             channel->id, SILC_ID_CHANNEL,
 763                                             tmp, data_len, force_send);
 764
 765             /* Free the copy of the channel message */
 766             memset(tmp, 0, data_len);
 767             silc_free(tmp);
 768           } else {
 769             /* Private key mode is set, we don't have the channel key, so
 770                just re-encrypt the entire packet and send it to the router. */
 771             silc_server_packet_send_srcdest(server, sock,
 772                                             SILC_PACKET_CHANNEL_MESSAGE, 0,
 773                                             sender, sender_type,
 774                                             channel->id, SILC_ID_CHANNEL,
 775                                             data, data_len, force_send);
 776           }
 777           continue;
 778         }
 779
 780         /* Send the packet (to normal server) */
 781         silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 782                                                 idata->send_key,
 783                                                 idata->hmac_send,
 784                                                 data, data_len, TRUE,
 785                                                 force_send);
 786
 787         continue;
 788       }
 789
 790       if (client && client->router)
 791         continue;
 792
 793       /* Get data used in packet header encryption, keys and stuff. */
 794       sock = (SilcSocketConnection)client->connection;
 795       idata = (SilcIDListData)client;
 796
 797       if (sender_sock && sock == sender_sock)
 798         continue;
 799
 800       SILC_LOG_DEBUG(("Sending packet to client ID(%s) %s (%s)",
 801                       silc_id_render(client->id, SILC_ID_CLIENT),
 802                       sock->hostname, sock->ip));
 803
 804       /* Send the packet */
 805       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 806                                               idata->send_key,
 807                                               idata->hmac_send,
 808                                               data, data_len, TRUE,
 809                                               force_send);
 810     }
 811   }
 812
 813   silc_free(packetdata.src_id);
 814   silc_free(packetdata.dst_id);
 815 }
 816
 817 /* This function is used to send packets strictly to all local clients
 818    on a particular channel.  This is used for example to distribute new
 819    channel key to all our locally connected clients on the channel.
 820    The packets are always encrypted with the session key shared between
 821    the client, this means these are not _to the channel_ but _to the client_
 822    on the channel. */
 823
 824 void silc_server_packet_send_local_channel(SilcServer server,
 825                                            SilcChannelEntry channel,
 826                                            SilcPacketType type,
 827                                            SilcPacketFlags flags,
 828                                            unsigned char *data,
 829                                            uint32 data_len,
 830                                            int force_send)
 831 {
 832   SilcChannelClientEntry chl;
 833   SilcHashTableList htl;
 834   SilcSocketConnection sock = NULL;
 835
 836   SILC_LOG_DEBUG(("Start"));
 837
 838   /* Send the message to clients on the channel's client list. */
 839   silc_hash_table_list(channel->user_list, &htl);
 840   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
 841     if (chl->client && !chl->client->router) {
 842       sock = (SilcSocketConnection)chl->client->connection;
 843
 844       /* Send the packet to the client */
 845       silc_server_packet_send_dest(server, sock, type, flags, chl->client->id,
 846                                    SILC_ID_CLIENT, data, data_len,
 847                                    force_send);
 848     }
 849   }
 850 }
 851
 852 /* Routine used to send (relay, route) private messages to some destination.
 853    If the private message key does not exist then the message is re-encrypted,
 854    otherwise we just pass it along. This really is not used to send new
 855    private messages (as server does not send them) but to relay received
 856    private messages. */
 857
 858 void silc_server_send_private_message(SilcServer server,
 859                                       SilcSocketConnection dst_sock,
 860                                       SilcCipher cipher,
 861                                       SilcHmac hmac,
 862                                       SilcPacketContext *packet)
 863 {
 864   SilcBuffer buffer = packet->buffer;
 865
 866   /* Re-encrypt and send if private messge key does not exist */
 867   if ((packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY) == FALSE) {
 868
 869     silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
 870                      + packet->dst_id_len + packet->padlen);
 871     silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
 872     silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
 873
 874     /* Re-encrypt packet */
 875     silc_packet_encrypt(cipher, hmac, dst_sock->outbuf, buffer->len);
 876
 877     /* Send the packet */
 878     silc_server_packet_send_real(server, dst_sock, FALSE);
 879
 880   } else {
 881     /* Key exist so encrypt just header and send it */
 882     silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
 883                      + packet->dst_id_len + packet->padlen);
 884     silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
 885     silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
 886
 887     /* Encrypt header */
 888     silc_packet_encrypt(cipher, hmac, dst_sock->outbuf,
 889                         SILC_PACKET_HEADER_LEN + packet->src_id_len +
 890                         packet->dst_id_len + packet->padlen);
 891
 892     silc_server_packet_send_real(server, dst_sock, FALSE);
 893   }
 894 }
 895
 896 /* Sends current motd to client */
 897
 898 void silc_server_send_motd(SilcServer server,
 899                            SilcSocketConnection sock)
 900 {
 901   char *motd;
 902   uint32 motd_len;
 903
 904   if (server->config && server->config->motd &&
 905       server->config->motd->motd_file) {
 906
 907     motd = silc_file_read(server->config->motd->motd_file, &motd_len);
 908     if (!motd)
 909       return;
 910
 911     silc_server_send_notify(server, sock, FALSE, SILC_NOTIFY_TYPE_MOTD, 1,
 912                             motd, motd_len);
 913     silc_free(motd);
 914   }
 915 }
 916
 917 /* Sends error message. Error messages may or may not have any
 918    implications. */
 919
 920 void silc_server_send_error(SilcServer server,
 921                             SilcSocketConnection sock,
 922                             const char *fmt, ...)
 923 {
 924   va_list ap;
 925   unsigned char buf[4096];
 926
 927   memset(buf, 0, sizeof(buf));
 928   va_start(ap, fmt);
 929   vsprintf(buf, fmt, ap);
 930   va_end(ap);
 931
 932   silc_server_packet_send(server, sock, SILC_PACKET_ERROR, 0,
 933                           buf, strlen(buf), FALSE);
 934 }
 935
 936 /* Sends notify message. If format is TRUE the variable arguments are
 937    formatted and the formatted string is sent as argument payload. If it is
 938    FALSE then each argument is sent as separate argument and their format
 939    in the argument list must be { argument data, argument length }. */
 940
 941 void silc_server_send_notify(SilcServer server,
 942                              SilcSocketConnection sock,
 943                              int broadcast,
 944                              SilcNotifyType type,
 945                              uint32 argc, ...)
 946 {
 947   va_list ap;
 948   SilcBuffer packet;
 949
 950   va_start(ap, argc);
 951
 952   packet = silc_notify_payload_encode(type, argc, ap);
 953   silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
 954                           broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
 955                           packet->data, packet->len, FALSE);
 956   silc_buffer_free(packet);
 957 }
 958
 959 /* Sends notify message and gets the arguments from the `args' Argument
 960    Payloads. */
 961
 962 void silc_server_send_notify_args(SilcServer server,
 963                                   SilcSocketConnection sock,
 964                                   int broadcast,
 965                                   SilcNotifyType type,
 966                                   uint32 argc,
 967                                   SilcBuffer args)
 968 {
 969   SilcBuffer packet;
 970
 971   packet = silc_notify_payload_encode_args(type, argc, args);
 972   silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
 973                           broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
 974                           packet->data, packet->len, FALSE);
 975   silc_buffer_free(packet);
 976 }
 977
 978 /* Send CHANNEL_CHANGE notify type. This tells the receiver to replace the
 979    `old_id' with the `new_id'. */
 980
 981 void silc_server_send_notify_channel_change(SilcServer server,
 982                                             SilcSocketConnection sock,
 983                                             int broadcast,
 984                                             SilcChannelID *old_id,
 985                                             SilcChannelID *new_id)
 986 {
 987   SilcBuffer idp1, idp2;
 988
 989   idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CHANNEL);
 990   idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CHANNEL);
 991
 992   silc_server_send_notify(server, sock, broadcast,
 993                           SILC_NOTIFY_TYPE_CHANNEL_CHANGE,
 994                           2, idp1->data, idp1->len, idp2->data, idp2->len);
 995   silc_buffer_free(idp1);
 996   silc_buffer_free(idp2);
 997 }
 998
 999 /* Send NICK_CHANGE notify type. This tells the receiver to replace the
1000    `old_id' with the `new_id'. */
1001
1002 void silc_server_send_notify_nick_change(SilcServer server,
1003                                          SilcSocketConnection sock,
1004                                          int broadcast,
1005                                          SilcClientID *old_id,
1006                                          SilcClientID *new_id)
1007 {
1008   SilcBuffer idp1, idp2;
1009
1010   idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CLIENT);
1011   idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CLIENT);
1012
1013   silc_server_send_notify(server, sock, broadcast,
1014                           SILC_NOTIFY_TYPE_NICK_CHANGE,
1015                           2, idp1->data, idp1->len, idp2->data, idp2->len);
1016   silc_buffer_free(idp1);
1017   silc_buffer_free(idp2);
1018 }
1019
1020 /* Sends JOIN notify type. This tells that new client by `client_id' ID
1021    has joined to the `channel'. */
1022
1023 void silc_server_send_notify_join(SilcServer server,
1024                                   SilcSocketConnection sock,
1025                                   int broadcast,
1026                                   SilcChannelEntry channel,
1027                                   SilcClientID *client_id)
1028 {
1029   SilcBuffer idp1, idp2;
1030
1031   idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1032   idp2 = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1033   silc_server_send_notify(server, sock, broadcast, SILC_NOTIFY_TYPE_JOIN,
1034                           2, idp1->data, idp1->len,
1035                           idp2->data, idp2->len);
1036   silc_buffer_free(idp1);
1037   silc_buffer_free(idp2);
1038 }
1039
1040 /* Sends LEAVE notify type. This tells that `client_id' has left the
1041    `channel'. The Notify packet is always destined to the channel. */
1042
1043 void silc_server_send_notify_leave(SilcServer server,
1044                                    SilcSocketConnection sock,
1045                                    int broadcast,
1046                                    SilcChannelEntry channel,
1047                                    SilcClientID *client_id)
1048 {
1049   SilcBuffer idp;
1050
1051   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1052   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1053                                SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_LEAVE,
1054                                1, idp->data, idp->len);
1055   silc_buffer_free(idp);
1056 }
1057
1058 /* Sends CMODE_CHANGE notify type. This tells that `client_id' changed the
1059    `channel' mode to `mode. The Notify packet is always destined to
1060    the channel. */
1061
1062 void silc_server_send_notify_cmode(SilcServer server,
1063                                    SilcSocketConnection sock,
1064                                    int broadcast,
1065                                    SilcChannelEntry channel,
1066                                    uint32 mode_mask,
1067                                    void *id, SilcIdType id_type,
1068                                    char *cipher, char *hmac)
1069 {
1070   SilcBuffer idp;
1071   unsigned char mode[4];
1072
1073   idp = silc_id_payload_encode((void *)id, id_type);
1074   SILC_PUT32_MSB(mode_mask, mode);
1075
1076   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1077                                SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_CMODE_CHANGE,
1078                                4, idp->data, idp->len,
1079                                mode, 4,
1080                                cipher, cipher ? strlen(cipher) : 0,
1081                                hmac, hmac ? strlen(hmac) : 0);
1082   silc_buffer_free(idp);
1083 }
1084
1085 /* Sends CUMODE_CHANGE notify type. This tells that `client_id' changed the
1086    `target' client's mode on `channel'. The Notify packet is always
1087    destined to the channel. */
1088
1089 void silc_server_send_notify_cumode(SilcServer server,
1090                                     SilcSocketConnection sock,
1091                                     int broadcast,
1092                                     SilcChannelEntry channel,
1093                                     uint32 mode_mask,
1094                                     void *id, SilcIdType id_type,
1095                                     SilcClientID *target)
1096 {
1097   SilcBuffer idp1, idp2;
1098   unsigned char mode[4];
1099
1100   idp1 = silc_id_payload_encode((void *)id, id_type);
1101   idp2 = silc_id_payload_encode((void *)target, SILC_ID_CLIENT);
1102   SILC_PUT32_MSB(mode_mask, mode);
1103
1104   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1105                                SILC_ID_CHANNEL,
1106                                SILC_NOTIFY_TYPE_CUMODE_CHANGE, 3,
1107                                idp1->data, idp1->len,
1108                                mode, 4,
1109                                idp2->data, idp2->len);
1110   silc_buffer_free(idp1);
1111   silc_buffer_free(idp2);
1112 }
1113
1114 /* Sends SIGNOFF notify type. This tells that `client_id' client has
1115    left SILC network. This function is used only between server and router
1116    traffic. This is not used to send the notify to the channel for
1117    client. The `message may be NULL. */
1118
1119 void silc_server_send_notify_signoff(SilcServer server,
1120                                      SilcSocketConnection sock,
1121                                      int broadcast,
1122                                      SilcClientID *client_id,
1123                                      char *message)
1124 {
1125   SilcBuffer idp;
1126
1127   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1128   silc_server_send_notify(server, sock, broadcast,
1129                           SILC_NOTIFY_TYPE_SIGNOFF,
1130                           message ? 2 : 1, idp->data, idp->len,
1131                           message, message ? strlen(message): 0);
1132   silc_buffer_free(idp);
1133 }
1134
1135 /* Sends TOPIC_SET notify type. This tells that `client_id' changed
1136    the `channel's topic to `topic'. The Notify packet is always destined
1137    to the channel. This function is used to send the topic set notifies
1138    between routers. */
1139
1140 void silc_server_send_notify_topic_set(SilcServer server,
1141                                        SilcSocketConnection sock,
1142                                        int broadcast,
1143                                        SilcChannelEntry channel,
1144                                        SilcClientID *client_id,
1145                                        char *topic)
1146 {
1147   SilcBuffer idp;
1148
1149   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1150   silc_server_send_notify(server, sock, broadcast,
1151                           SILC_NOTIFY_TYPE_SERVER_SIGNOFF,
1152                           topic ? 2 : 1,
1153                           idp->data, idp->len,
1154                           topic, topic ? strlen(topic) : 0);
1155   silc_buffer_free(idp);
1156 }
1157
1158 /* Send KICKED notify type. This tells that the `client_id' on `channel'
1159    was kicked off the channel.  The `comment' may indicate the reason
1160    for the kicking. This function is used only between server and router
1161    traffic. */
1162
1163 void silc_server_send_notify_kicked(SilcServer server,
1164                                     SilcSocketConnection sock,
1165                                     int broadcast,
1166                                     SilcChannelEntry channel,
1167                                     SilcClientID *client_id,
1168                                     char *comment)
1169 {
1170   SilcBuffer idp;
1171
1172   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1173   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1174                                SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_KICKED,
1175                                comment ? 2 : 1, idp->data, idp->len,
1176                                comment, comment ? strlen(comment) : 0);
1177   silc_buffer_free(idp);
1178 }
1179
1180 /* Send KILLED notify type. This tells that the `client_id' client was
1181    killed from the network.  The `comment' may indicate the reason
1182    for the killing. */
1183
1184 void silc_server_send_notify_killed(SilcServer server,
1185                                     SilcSocketConnection sock,
1186                                     int broadcast,
1187                                     SilcClientID *client_id,
1188                                     char *comment)
1189 {
1190   SilcBuffer idp;
1191
1192   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1193   silc_server_send_notify_dest(server, sock, broadcast, (void *)client_id,
1194                                SILC_ID_CLIENT, SILC_NOTIFY_TYPE_KILLED,
1195                                comment ? 2 : 1, idp->data, idp->len,
1196                                comment, comment ? strlen(comment) : 0);
1197   silc_buffer_free(idp);
1198 }
1199
1200 /* Sends UMODE_CHANGE notify type. This tells that `client_id' client's
1201    user mode in the SILC Network was changed. This function is used to
1202    send the packet between routers as broadcast packet. */
1203
1204 void silc_server_send_notify_umode(SilcServer server,
1205                                    SilcSocketConnection sock,
1206                                    int broadcast,
1207                                    SilcClientID *client_id,
1208                                    uint32 mode_mask)
1209 {
1210   SilcBuffer idp;
1211   unsigned char mode[4];
1212
1213   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1214   SILC_PUT32_MSB(mode_mask, mode);
1215
1216   silc_server_send_notify(server, sock, broadcast,
1217                           SILC_NOTIFY_TYPE_UMODE_CHANGE, 2,
1218                           idp->data, idp->len,
1219                           mode, 4);
1220   silc_buffer_free(idp);
1221 }
1222
1223 /* Sends BAN notify type. This tells that ban has been either `add'ed
1224    or `del'eted on the `channel. This function is used to send the packet
1225    between routers as broadcast packet. */
1226
1227 void silc_server_send_notify_ban(SilcServer server,
1228                                  SilcSocketConnection sock,
1229                                  int broadcast,
1230                                  SilcChannelEntry channel,
1231                                  char *add, char *del)
1232 {
1233   SilcBuffer idp;
1234
1235   idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1236   silc_server_send_notify(server, sock, broadcast,
1237                           SILC_NOTIFY_TYPE_BAN, 3,
1238                           idp->data, idp->len,
1239                           add, add ? strlen(add) : 0,
1240                           del, del ? strlen(del) : 0);
1241   silc_buffer_free(idp);
1242 }
1243
1244 /* Sends INVITE notify type. This tells that invite has been either `add'ed
1245    or `del'eted on the `channel.  The sender of the invite is the `client_id'.
1246    This function is used to send the packet between routers as broadcast
1247    packet. */
1248
1249 void silc_server_send_notify_invite(SilcServer server,
1250                                     SilcSocketConnection sock,
1251                                     int broadcast,
1252                                     SilcChannelEntry channel,
1253                                     SilcClientID *client_id,
1254                                     char *add, char *del)
1255 {
1256   SilcBuffer idp, idp2;
1257
1258   idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1259   idp2 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1260   silc_server_send_notify(server, sock, broadcast,
1261                           SILC_NOTIFY_TYPE_INVITE, 5,
1262                           idp->data, idp->len,
1263                           channel->channel_name, strlen(channel->channel_name),
1264                           idp2->data, idp2->len,
1265                           add, add ? strlen(add) : 0,
1266                           del, del ? strlen(del) : 0);
1267   silc_buffer_free(idp);
1268   silc_buffer_free(idp2);
1269 }
1270
1271 /* Sends notify message destined to specific entity. */
1272
1273 void silc_server_send_notify_dest(SilcServer server,
1274                                   SilcSocketConnection sock,
1275                                   int broadcast,
1276                                   void *dest_id,
1277                                   SilcIdType dest_id_type,
1278                                   SilcNotifyType type,
1279                                   uint32 argc, ...)
1280 {
1281   va_list ap;
1282   SilcBuffer packet;
1283
1284   va_start(ap, argc);
1285
1286   packet = silc_notify_payload_encode(type, argc, ap);
1287   silc_server_packet_send_dest(server, sock, SILC_PACKET_NOTIFY, 0,
1288                                dest_id, dest_id_type,
1289                                packet->data, packet->len, FALSE);
1290   silc_buffer_free(packet);
1291 }
1292
1293 /* Sends notify message to a channel. The notify message sent is
1294    distributed to all clients on the channel. If `route_notify' is TRUE
1295    then the notify may be routed to primary route or to some other routers.
1296    If FALSE it is assured that the notify is sent only locally. If `sender'
1297    is provided then the packet is not sent to that connection since it
1298    originally came from it. */
1299
1300 void silc_server_send_notify_to_channel(SilcServer server,
1301                                         SilcSocketConnection sender,
1302                                         SilcChannelEntry channel,
1303                                         unsigned char route_notify,
1304                                         SilcNotifyType type,
1305                                         uint32 argc, ...)
1306 {
1307   va_list ap;
1308   SilcBuffer packet;
1309
1310   va_start(ap, argc);
1311
1312   packet = silc_notify_payload_encode(type, argc, ap);
1313   silc_server_packet_send_to_channel(server, sender, channel,
1314                                      SILC_PACKET_NOTIFY, route_notify,
1315                                      packet->data, packet->len, FALSE);
1316   silc_buffer_free(packet);
1317 }
1318
1319 /* Send notify message to all channels the client has joined. It is quaranteed
1320    that the message is sent only once to a client (ie. if a client is joined
1321    on two same channel it will receive only one notify message). Also, this
1322    sends only to local clients (locally connected if we are server, and to
1323    local servers if we are router). If `sender' is provided the packet is
1324    not sent to that client at all. */
1325
1326 void silc_server_send_notify_on_channels(SilcServer server,
1327                                          SilcClientEntry sender,
1328                                          SilcClientEntry client,
1329                                          SilcNotifyType type,
1330                                          uint32 argc, ...)
1331 {
1332   int k;
1333   SilcSocketConnection sock = NULL;
1334   SilcPacketContext packetdata;
1335   SilcClientEntry c;
1336   SilcClientEntry *sent_clients = NULL;
1337   uint32 sent_clients_count = 0;
1338   SilcServerEntry *routed = NULL;
1339   uint32 routed_count = 0;
1340   SilcHashTableList htl, htl2;
1341   SilcChannelEntry channel;
1342   SilcChannelClientEntry chl, chl2;
1343   SilcIDListData idata;
1344   SilcBuffer packet;
1345   unsigned char *data;
1346   uint32 data_len;
1347   int force_send = FALSE;
1348   va_list ap;
1349
1350   SILC_LOG_DEBUG(("Start"));
1351
1352   if (!silc_hash_table_count(client->channels))
1353     return;
1354
1355   va_start(ap, argc);
1356   packet = silc_notify_payload_encode(type, argc, ap);
1357   data = packet->data;
1358   data_len = packet->len;
1359
1360   /* Set the packet context pointers. */
1361   packetdata.flags = 0;
1362   packetdata.type = SILC_PACKET_NOTIFY;
1363   packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
1364   packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
1365   packetdata.src_id_type = SILC_ID_SERVER;
1366
1367   silc_hash_table_list(client->channels, &htl);
1368   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
1369     channel = chl->channel;
1370
1371     /* Send the message to all clients on the channel's client list. */
1372     silc_hash_table_list(channel->user_list, &htl2);
1373     while (silc_hash_table_get(&htl2, NULL, (void *)&chl2)) {
1374       c = chl2->client;
1375
1376       if (sender && c == sender)
1377         continue;
1378
1379       /* Check if we have sent the packet to this client already */
1380       for (k = 0; k < sent_clients_count; k++)
1381         if (sent_clients[k] == c)
1382           break;
1383       if (k < sent_clients_count)
1384         continue;
1385
1386       /* If we are router and if this client has router set it is not
1387          locally connected client and we will route the message to the
1388          router set in the client. */
1389       if (c && c->router && server->server_type == SILC_ROUTER) {
1390         /* Check if we have sent the packet to this route already */
1391         for (k = 0; k < routed_count; k++)
1392           if (routed[k] == c->router)
1393             break;
1394         if (k < routed_count)
1395           continue;
1396
1397         /* Get data used in packet header encryption, keys and stuff. */
1398         sock = (SilcSocketConnection)c->router->connection;
1399         idata = (SilcIDListData)c->router;
1400
1401         packetdata.dst_id = silc_id_id2str(c->router->id, SILC_ID_SERVER);
1402         packetdata.dst_id_len = silc_id_get_len(c->router->id, SILC_ID_SERVER);
1403         packetdata.dst_id_type = SILC_ID_SERVER;
1404         packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
1405           packetdata.src_id_len + packetdata.dst_id_len;
1406         packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen);
1407
1408         /* Send the packet */
1409         silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1410                                                 idata->send_key,
1411                                                 idata->hmac_send,
1412                                                 data, data_len, FALSE,
1413                                                 force_send);
1414
1415         silc_free(packetdata.dst_id);
1416
1417         /* We want to make sure that the packet is routed to same router
1418            only once. Mark this route as sent route. */
1419         k = routed_count;
1420         routed = silc_realloc(routed, sizeof(*routed) * (k + 1));
1421         routed[k] = c->router;
1422         routed_count++;
1423
1424         continue;
1425       }
1426
1427       if (c && c->router)
1428         continue;
1429
1430       /* Send to locally connected client */
1431       if (c) {
1432
1433         /* Get data used in packet header encryption, keys and stuff. */
1434         sock = (SilcSocketConnection)c->connection;
1435         idata = (SilcIDListData)c;
1436
1437         packetdata.dst_id = silc_id_id2str(c->id, SILC_ID_CLIENT);
1438         packetdata.dst_id_len = silc_id_get_len(c->id, SILC_ID_CLIENT);
1439         packetdata.dst_id_type = SILC_ID_CLIENT;
1440         packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
1441           packetdata.src_id_len + packetdata.dst_id_len;
1442         packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen);
1443
1444         /* Send the packet */
1445         silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1446                                                 idata->send_key,
1447                                                 idata->hmac_send,
1448                                                 data, data_len, FALSE,
1449                                                 force_send);
1450
1451         silc_free(packetdata.dst_id);
1452
1453         /* Make sure that we send the notify only once per client. */
1454         sent_clients = silc_realloc(sent_clients, sizeof(*sent_clients) *
1455                                     (sent_clients_count + 1));
1456         sent_clients[sent_clients_count] = c;
1457         sent_clients_count++;
1458       }
1459     }
1460   }
1461
1462   if (routed_count)
1463     silc_free(routed);
1464   if (sent_clients_count)
1465     silc_free(sent_clients);
1466   silc_free(packetdata.src_id);
1467 }
1468
1469 /* Sends New ID Payload to remote end. The packet is used to distribute
1470    information about new registered clients, servers, channel etc. usually
1471    to routers so that they can keep these information up to date.
1472    If the argument `broadcast' is TRUE then the packet is sent as
1473    broadcast packet. */
1474
1475 void silc_server_send_new_id(SilcServer server,
1476                              SilcSocketConnection sock,
1477                              int broadcast,
1478                              void *id, SilcIdType id_type,
1479                              uint32 id_len)
1480 {
1481   SilcBuffer idp;
1482
1483   SILC_LOG_DEBUG(("Start"));
1484
1485   idp = silc_id_payload_encode(id, id_type);
1486   silc_server_packet_send(server, sock, SILC_PACKET_NEW_ID,
1487                           broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1488                           idp->data, idp->len, FALSE);
1489   silc_buffer_free(idp);
1490 }
1491
1492 /* Send New Channel Payload to notify about newly created channel in the
1493    SILC network. Normal server nevers sends this packet. Router uses this
1494    to notify other routers in the network about new channel. This packet
1495    is broadcasted. */
1496
1497 void silc_server_send_new_channel(SilcServer server,
1498                                   SilcSocketConnection sock,
1499                                   int broadcast,
1500                                   char *channel_name,
1501                                   void *channel_id,
1502                                   uint32 channel_id_len,
1503                                   uint32 mode)
1504 {
1505   SilcBuffer packet;
1506   unsigned char *cid;
1507   uint32 name_len = strlen(channel_name);
1508
1509   SILC_LOG_DEBUG(("Start"));
1510
1511   cid = silc_id_id2str(channel_id, SILC_ID_CHANNEL);
1512   if (!cid)
1513     return;
1514
1515   /* Encode the channel payload */
1516   packet = silc_channel_payload_encode(channel_name, name_len,
1517                                        cid, channel_id_len, mode);
1518
1519   silc_server_packet_send(server, sock, SILC_PACKET_NEW_CHANNEL,
1520                           broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1521                           packet->data, packet->len, FALSE);
1522
1523   silc_free(cid);
1524   silc_buffer_free(packet);
1525 }
1526
1527 /* Send Channel Key payload to distribute the new channel key. Normal server
1528    sends this to router when new client joins to existing channel. Router
1529    sends this to the local server who sent the join command in case where
1530    the channel did not exist yet. Both normal and router servers uses this
1531    also to send this to locally connected clients on the channel. This
1532    must not be broadcasted packet. Routers do not send this to each other.
1533    If `sender is provided then the packet is not sent to that connection since
1534    it originally came from it. */
1535
1536 void silc_server_send_channel_key(SilcServer server,
1537                                   SilcSocketConnection sender,
1538                                   SilcChannelEntry channel,
1539                                   unsigned char route)
1540 {
1541   SilcBuffer packet;
1542   unsigned char *chid;
1543   uint32 tmp_len;
1544
1545   SILC_LOG_DEBUG(("Start"));
1546
1547   chid = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
1548   if (!chid)
1549     return;
1550
1551   /* Encode channel key packet */
1552   tmp_len = strlen(channel->channel_key->cipher->name);
1553   packet = silc_channel_key_payload_encode(silc_id_get_len(channel->id,
1554                                                            SILC_ID_CHANNEL),
1555                                            chid, tmp_len,
1556                                            channel->channel_key->cipher->name,
1557                                            channel->key_len / 8, channel->key);
1558
1559   silc_server_packet_send_to_channel(server, sender, channel,
1560                                      SILC_PACKET_CHANNEL_KEY,
1561                                      route, packet->data, packet->len, FALSE);
1562   silc_buffer_free(packet);
1563   silc_free(chid);
1564 }
1565
1566 /* Generic function to send any command. The arguments must be sent already
1567    encoded into correct form in correct order. */
1568
1569 void silc_server_send_command(SilcServer server,
1570                               SilcSocketConnection sock,
1571                               SilcCommand command,
1572                               uint32 argc, ...)
1573 {
1574   SilcBuffer packet;
1575   va_list ap;
1576
1577   va_start(ap, argc);
1578
1579   packet = silc_command_payload_encode_vap(command, 0, argc, ap);
1580   silc_server_packet_send(server, sock, SILC_PACKET_COMMAND, 0,
1581                           packet->data, packet->len, TRUE);
1582   silc_buffer_free(packet);
1583 }
1584
1585 /* Send the heartbeat packet. */
1586
1587 void silc_server_send_heartbeat(SilcServer server,
1588                                 SilcSocketConnection sock)
1589 {
1590   silc_server_packet_send(server, sock, SILC_PACKET_HEARTBEAT, 0,
1591                           NULL, 0, FALSE);
1592 }
1593
1594 /* Generic function to relay packet we've received. This is used to relay
1595    packets to a client but generally can be used to other purposes as well. */
1596
1597 void silc_server_relay_packet(SilcServer server,
1598                               SilcSocketConnection dst_sock,
1599                               SilcCipher cipher,
1600                               SilcHmac hmac,
1601                               SilcPacketContext *packet,
1602                               int force_send)
1603 {
1604   silc_buffer_push(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1605                    + packet->dst_id_len + packet->padlen);
1606
1607   silc_packet_send_prepare(dst_sock, 0, 0, packet->buffer->len);
1608   silc_buffer_put(dst_sock->outbuf, packet->buffer->data, packet->buffer->len);
1609
1610   /* Re-encrypt packet */
1611   silc_packet_encrypt(cipher, hmac, dst_sock->outbuf, packet->buffer->len);
1612
1613   /* Send the packet */
1614   silc_server_packet_send_real(server, dst_sock, force_send);
1615
1616   silc_buffer_pull(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1617                    + packet->dst_id_len + packet->padlen);
1618 }
1619
1620 /* Routine used to send the connection authentication packet. */
1621
1622 void silc_server_send_connection_auth_request(SilcServer server,
1623                                               SilcSocketConnection sock,
1624                                               uint16 conn_type,
1625                                               SilcAuthMethod auth_meth)
1626 {
1627   SilcBuffer packet;
1628
1629   packet = silc_buffer_alloc(4);
1630   silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1631   silc_buffer_format(packet,
1632                      SILC_STR_UI_SHORT(conn_type),
1633                      SILC_STR_UI_SHORT(auth_meth),
1634                      SILC_STR_END);
1635
1636   silc_server_packet_send(server, sock, SILC_PACKET_CONNECTION_AUTH_REQUEST,
1637                           0, packet->data, packet->len, FALSE);
1638   silc_buffer_free(packet);
1639 }