apps/silcd/packet_send.c

   1 /*
   2
   3   packet_send.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  * Server packet routines to send packets.
  21  */
  22 /* $Id$ */
  23
  24 #include "serverincludes.h"
  25 #include "server_internal.h"
  26
  27 /* Routine that sends packet or marks packet to be sent. This is used
  28    directly only in special cases. Normal cases should use
  29    silc_server_packet_send. Returns < 0 error. */
  30
  31 int silc_server_packet_send_real(SilcServer server,
  32                                  SilcSocketConnection sock,
  33                                  bool force_send)
  34 {
  35   int ret;
  36
  37   /* If disconnecting, ignore the data */
  38   if (SILC_IS_DISCONNECTING(sock))
  39     return -1;
  40
  41   /* Send the packet */
  42   ret = silc_packet_send(sock, FALSE);
  43   if (ret != -2) {
  44     if (ret == -1) {
  45       SILC_LOG_ERROR(("Error sending packet to connection "
  46                       "%s:%d [%s]", sock->hostname, sock->port,
  47                       (sock->type == SILC_SOCKET_TYPE_UNKNOWN ? "Unknown" :
  48                        sock->type == SILC_SOCKET_TYPE_CLIENT ? "Client" :
  49                        sock->type == SILC_SOCKET_TYPE_SERVER ? "Server" :
  50                        "Router")));
  51
  52       if (sock->user_data)
  53         silc_server_free_sock_user_data(server, sock, NULL);
  54       SILC_SET_DISCONNECTING(sock);
  55       silc_server_close_connection(server, sock);
  56       return ret;
  57     }
  58
  59     server->stat.packets_sent++;
  60     return ret;
  61   }
  62
  63   /* Mark that there is some outgoing data available for this connection.
  64      This call sets the connection both for input and output (the input
  65      is set always and this call keeps the input setting, actually).
  66      Actual data sending is performed by silc_server_packet_process. */
  67   SILC_SET_CONNECTION_FOR_OUTPUT(server->schedule, sock->sock);
  68
  69   /* Mark to socket that data is pending in outgoing buffer. This flag
  70      is needed if new data is added to the buffer before the earlier
  71      put data is sent to the network. */
  72   SILC_SET_OUTBUF_PENDING(sock);
  73
  74   return 0;
  75 }
  76
  77 /* Assembles a new packet to be sent out to network. This doesn't actually
  78    send the packet but creates the packet and fills the outgoing data
  79    buffer and marks the packet ready to be sent to network. However, If
  80    argument force_send is TRUE the packet is sent immediately and not put
  81    to queue. Normal case is that the packet is not sent immediately. */
  82
  83 void silc_server_packet_send(SilcServer server,
  84                              SilcSocketConnection sock,
  85                              SilcPacketType type,
  86                              SilcPacketFlags flags,
  87                              unsigned char *data,
  88                              SilcUInt32 data_len,
  89                              bool force_send)
  90 {
  91   void *dst_id = NULL;
  92   SilcIdType dst_id_type = SILC_ID_NONE;
  93   SilcIDListData idata;
  94
  95   if (!sock)
  96     return;
  97
  98   idata = (SilcIDListData)sock->user_data;
  99
 100   /* If disconnecting, ignore the data */
 101   if (SILC_IS_DISCONNECTING(sock))
 102     return;
 103
 104   /* If entry is disabled do not sent anything.  Allow hearbeat and
 105      rekeys, though */
 106   if ((idata && idata->status & SILC_IDLIST_STATUS_DISABLED &&
 107        type != SILC_PACKET_HEARTBEAT && type != SILC_PACKET_REKEY &&
 108        type != SILC_PACKET_REKEY_DONE) ||
 109       (sock->user_data == server->id_entry)) {
 110     SILC_LOG_DEBUG(("Connection is disabled"));
 111     return;
 112   }
 113
 114   /* Get data used in the packet sending, keys and stuff */
 115   switch(sock->type) {
 116   case SILC_SOCKET_TYPE_CLIENT:
 117     if (sock->user_data) {
 118       dst_id = ((SilcClientEntry)sock->user_data)->id;
 119       dst_id_type = SILC_ID_CLIENT;
 120     }
 121     break;
 122   case SILC_SOCKET_TYPE_SERVER:
 123   case SILC_SOCKET_TYPE_ROUTER:
 124     if (sock->user_data) {
 125       dst_id = ((SilcServerEntry)sock->user_data)->id;
 126       dst_id_type = SILC_ID_SERVER;
 127     }
 128     break;
 129   default:
 130     break;
 131   }
 132
 133   silc_server_packet_send_dest(server, sock, type, flags, dst_id,
 134                                dst_id_type, data, data_len, force_send);
 135 }
 136
 137 /* Assembles a new packet to be sent out to network. This doesn't actually
 138    send the packet but creates the packet and fills the outgoing data
 139    buffer and marks the packet ready to be sent to network. However, If
 140    argument force_send is TRUE the packet is sent immediately and not put
 141    to queue. Normal case is that the packet is not sent immediately.
 142    Destination information is sent as argument for this function. */
 143
 144 void silc_server_packet_send_dest(SilcServer server,
 145                                   SilcSocketConnection sock,
 146                                   SilcPacketType type,
 147                                   SilcPacketFlags flags,
 148                                   void *dst_id,
 149                                   SilcIdType dst_id_type,
 150                                   unsigned char *data,
 151                                   SilcUInt32 data_len,
 152                                   bool force_send)
 153 {
 154   SilcPacketContext packetdata;
 155   const SilcBufferStruct packet;
 156   SilcIDListData idata;
 157   SilcCipher cipher = NULL;
 158   SilcHmac hmac = NULL;
 159   SilcUInt32 sequence = 0;
 160   unsigned char *dst_id_data = NULL;
 161   SilcUInt32 dst_id_len = 0;
 162   int block_len = 0;
 163
 164   /* If disconnecting, ignore the data */
 165   if (!sock || SILC_IS_DISCONNECTING(sock))
 166     return;
 167
 168   idata = (SilcIDListData)sock->user_data;
 169
 170   /* If entry is disabled do not sent anything. */
 171   if ((idata && idata->status & SILC_IDLIST_STATUS_DISABLED) ||
 172       sock->user_data == server->id_entry) {
 173     SILC_LOG_DEBUG(("Connection is disabled"));
 174     return;
 175   }
 176
 177   SILC_LOG_DEBUG(("Sending %s packet (forced=%s)",
 178                   silc_get_packet_name(type), force_send ? "yes" : "no"));
 179
 180   if (dst_id) {
 181     dst_id_data = silc_id_id2str(dst_id, dst_id_type);
 182     dst_id_len = silc_id_get_len(dst_id, dst_id_type);
 183   }
 184
 185   if (idata) {
 186     cipher = idata->send_key;
 187     hmac = idata->hmac_send;
 188     sequence = idata->psn_send++;
 189     if (cipher)
 190       block_len = silc_cipher_get_block_len(cipher);
 191
 192     /* Check for mandatory rekey */
 193     if (sequence == SILC_SERVER_REKEY_THRESHOLD)
 194       silc_schedule_task_add(server->schedule, sock->sock,
 195                              silc_server_rekey_callback, sock, 0, 1,
 196                              SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
 197   }
 198
 199   /* Set the packet context pointers */
 200   packetdata.type = type;
 201   packetdata.flags = flags;
 202   packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
 203   packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
 204   packetdata.src_id_type = SILC_ID_SERVER;
 205   packetdata.dst_id = dst_id_data;
 206   packetdata.dst_id_len = dst_id_len;
 207   packetdata.dst_id_type = dst_id_type;
 208   data_len = SILC_PACKET_DATALEN(data_len, (SILC_PACKET_HEADER_LEN +
 209                                             packetdata.src_id_len +
 210                                             packetdata.dst_id_len));
 211   packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
 212     packetdata.src_id_len + dst_id_len;
 213   if (type == SILC_PACKET_CONNECTION_AUTH)
 214     SILC_PACKET_PADLEN_MAX(packetdata.truelen, block_len, packetdata.padlen);
 215   else
 216     SILC_PACKET_PADLEN(packetdata.truelen, block_len, packetdata.padlen);
 217
 218   /* Create the outgoing packet */
 219   if (!silc_packet_assemble(&packetdata, NULL, cipher, hmac, sock,
 220                             data, data_len, (const SilcBuffer)&packet)) {
 221     SILC_LOG_ERROR(("Cannot assemble packet"));
 222     goto out;
 223   }
 224
 225   /* Encrypt the packet */
 226   silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&packet, packet.len);
 227
 228   SILC_LOG_HEXDUMP(("Outgoing packet (%d), len %d", sequence, packet.len),
 229                    packet.data, packet.len);
 230
 231   /* Now actually send the packet */
 232   silc_server_packet_send_real(server, sock, force_send);
 233
 234  out:
 235   silc_free(packetdata.src_id);
 236   silc_free(packetdata.dst_id);
 237 }
 238
 239 /* Assembles a new packet to be sent out to network. This doesn't actually
 240    send the packet but creates the packet and fills the outgoing data
 241    buffer and marks the packet ready to be sent to network. However, If
 242    argument force_send is TRUE the packet is sent immediately and not put
 243    to queue. Normal case is that the packet is not sent immediately.
 244    The source and destination information is sent as argument for this
 245    function. */
 246
 247 void silc_server_packet_send_srcdest(SilcServer server,
 248                                      SilcSocketConnection sock,
 249                                      SilcPacketType type,
 250                                      SilcPacketFlags flags,
 251                                      void *src_id,
 252                                      SilcIdType src_id_type,
 253                                      void *dst_id,
 254                                      SilcIdType dst_id_type,
 255                                      unsigned char *data,
 256                                      SilcUInt32 data_len,
 257                                      bool force_send)
 258 {
 259   SilcPacketContext packetdata;
 260   const SilcBufferStruct packet;
 261   SilcIDListData idata;
 262   SilcCipher cipher = NULL;
 263   SilcHmac hmac = NULL;
 264   SilcUInt32 sequence = 0;
 265   unsigned char *dst_id_data = NULL;
 266   SilcUInt32 dst_id_len = 0;
 267   unsigned char *src_id_data = NULL;
 268   SilcUInt32 src_id_len = 0;
 269   int block_len = 0;
 270
 271   SILC_LOG_DEBUG(("Sending %s packet", silc_get_packet_name(type)));
 272
 273   if (!sock)
 274     return;
 275
 276   /* Get data used in the packet sending, keys and stuff */
 277   idata = (SilcIDListData)sock->user_data;
 278
 279   /* If entry is disabled do not sent anything. */
 280   if ((idata && idata->status & SILC_IDLIST_STATUS_DISABLED) ||
 281       sock->user_data == server->id_entry) {
 282     SILC_LOG_DEBUG(("Connection is disabled"));
 283     return;
 284   }
 285
 286   if (idata) {
 287     cipher = idata->send_key;
 288     hmac = idata->hmac_send;
 289     sequence = idata->psn_send++;
 290     block_len = silc_cipher_get_block_len(cipher);
 291
 292     /* Check for mandatory rekey */
 293     if (sequence == SILC_SERVER_REKEY_THRESHOLD)
 294       silc_schedule_task_add(server->schedule, sock->sock,
 295                              silc_server_rekey_callback, sock, 0, 1,
 296                              SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
 297   }
 298
 299   if (dst_id) {
 300     dst_id_data = silc_id_id2str(dst_id, dst_id_type);
 301     dst_id_len = silc_id_get_len(dst_id, dst_id_type);
 302   }
 303
 304   if (src_id) {
 305     src_id_data = silc_id_id2str(src_id, src_id_type);
 306     src_id_len = silc_id_get_len(src_id, src_id_type);
 307   }
 308
 309   /* Set the packet context pointers */
 310   packetdata.type = type;
 311   packetdata.flags = flags;
 312   packetdata.src_id = src_id_data;
 313   packetdata.src_id_len = src_id_len;
 314   packetdata.src_id_type = src_id_type;
 315   packetdata.dst_id = dst_id_data;
 316   packetdata.dst_id_len = dst_id_len;
 317   packetdata.dst_id_type = dst_id_type;
 318   data_len = SILC_PACKET_DATALEN(data_len, (SILC_PACKET_HEADER_LEN +
 319                                             packetdata.src_id_len +
 320                                             dst_id_len));
 321   packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
 322     packetdata.src_id_len + dst_id_len;
 323   SILC_PACKET_PADLEN(packetdata.truelen, block_len, packetdata.padlen);
 324
 325   /* Create the outgoing packet */
 326   if (!silc_packet_assemble(&packetdata, NULL, cipher, hmac, sock, data,
 327                             data_len, (const SilcBuffer)&packet)) {
 328     SILC_LOG_ERROR(("Cannot assemble packe"));
 329     goto out;
 330   }
 331
 332   /* Encrypt the packet */
 333   silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&packet, packet.len);
 334
 335   SILC_LOG_HEXDUMP(("Outgoing packet (%d), len %d", sequence, packet.len),
 336                    packet.data, packet.len);
 337
 338   /* Now actually send the packet */
 339   silc_server_packet_send_real(server, sock, force_send);
 340
 341  out:
 342   silc_free(packetdata.src_id);
 343   silc_free(packetdata.dst_id);
 344 }
 345
 346 /* Broadcast received packet to our primary route. This function is used
 347    by router to further route received broadcast packet. It is expected
 348    that the broadcast flag from the packet is checked before calling this
 349    function. This does not test or set the broadcast flag. */
 350
 351 void silc_server_packet_broadcast(SilcServer server,
 352                                   SilcSocketConnection sock,
 353                                   SilcPacketContext *packet)
 354 {
 355   SilcBuffer buffer = packet->buffer;
 356   SilcIDListData idata;
 357   void *id;
 358
 359   if (!sock)
 360     return;
 361
 362   SILC_LOG_DEBUG(("Broadcasting received broadcast packet"));
 363
 364   /* If the packet is originated from our primary route we are
 365      not allowed to send the packet. */
 366   id = silc_id_str2id(packet->src_id, packet->src_id_len, packet->src_id_type);
 367   if (id && !SILC_ID_SERVER_COMPARE(id, server->router->id)) {
 368     const SilcBufferStruct p;
 369
 370     idata = (SilcIDListData)sock->user_data;
 371
 372     silc_buffer_push(buffer, buffer->data - buffer->head);
 373     if (!silc_packet_send_prepare(sock, 0, 0, buffer->len, idata->hmac_send,
 374                                   (const SilcBuffer)&p)) {
 375       SILC_LOG_ERROR(("Cannot send packet"));
 376       silc_free(id);
 377       return;
 378     }
 379     silc_buffer_put((SilcBuffer)&p, buffer->data, buffer->len);
 380     silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
 381                         (SilcBuffer)&p, p.len);
 382
 383     SILC_LOG_HEXDUMP(("Broadcasted packet (%d), len %d", idata->psn_send - 1,
 384                       p.len), p.data, p.len);
 385
 386     /* Now actually send the packet */
 387     silc_server_packet_send_real(server, sock, TRUE);
 388     silc_free(id);
 389
 390     /* Check for mandatory rekey */
 391     if (idata->psn_send == SILC_SERVER_REKEY_THRESHOLD)
 392       silc_schedule_task_add(server->schedule, sock->sock,
 393                              silc_server_rekey_callback, sock, 0, 1,
 394                              SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
 395     return;
 396   }
 397
 398   SILC_LOG_DEBUG(("Will not broadcast to primary route since it is the "
 399                   "original sender of this packet"));
 400   silc_free(id);
 401 }
 402
 403 /* Routes received packet to `sock'. This is used to route the packets that
 404    router receives but are not destined to it. */
 405
 406 void silc_server_packet_route(SilcServer server,
 407                               SilcSocketConnection sock,
 408                               SilcPacketContext *packet)
 409 {
 410   SilcBuffer buffer = packet->buffer;
 411   const SilcBufferStruct p;
 412   SilcIDListData idata;
 413
 414   SILC_LOG_DEBUG(("Routing received packet"));
 415
 416   idata = (SilcIDListData)sock->user_data;
 417
 418   silc_buffer_push(buffer, buffer->data - buffer->head);
 419   if (!silc_packet_send_prepare(sock, 0, 0, buffer->len, idata->hmac_send,
 420                                 (const SilcBuffer)&p)) {
 421     SILC_LOG_ERROR(("Cannot send packet"));
 422     return;
 423   }
 424   silc_buffer_put((SilcBuffer)&p, buffer->data, buffer->len);
 425   silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
 426                       (SilcBuffer)&p, p.len);
 427
 428   SILC_LOG_HEXDUMP(("Routed packet (%d), len %d", idata->psn_send - 1,
 429                    p.len), p.data, p.len);
 430
 431   /* Now actually send the packet */
 432   silc_server_packet_send_real(server, sock, TRUE);
 433
 434   /* Check for mandatory rekey */
 435   if (idata->psn_send == SILC_SERVER_REKEY_THRESHOLD)
 436     silc_schedule_task_add(server->schedule, sock->sock,
 437                            silc_server_rekey_callback, sock, 0, 1,
 438                            SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
 439 }
 440
 441 /* This routine can be used to send a packet to table of clients provided
 442    in `clients'. If `route' is FALSE the packet is routed only to local
 443    clients (for server locally connected, and for router local cell). */
 444
 445 void silc_server_packet_send_clients(SilcServer server,
 446                                      SilcHashTable clients,
 447                                      SilcPacketType type,
 448                                      SilcPacketFlags flags,
 449                                      bool route,
 450                                      unsigned char *data,
 451                                      SilcUInt32 data_len,
 452                                      bool force_send)
 453 {
 454   SilcSocketConnection sock = NULL;
 455   SilcHashTableList htl;
 456   SilcClientEntry client = NULL;
 457   SilcServerEntry *routed = NULL;
 458   SilcUInt32 routed_count = 0;
 459   bool gone = FALSE;
 460   int k;
 461
 462   if (!silc_hash_table_count(clients))
 463     return;
 464
 465   SILC_LOG_DEBUG(("Sending packet to %d clients",
 466                   silc_hash_table_count(clients)));
 467
 468   /* Send to all clients in table */
 469   silc_hash_table_list(clients, &htl);
 470   while (silc_hash_table_get(&htl, NULL, (void **)&client)) {
 471     /* If client has router set it is not locally connected client and
 472        we will route the message to the router set in the client. Though,
 473        send locally connected server in all cases. */
 474     if (server->server_type == SILC_ROUTER && client->router &&
 475         ((!route && client->router->router == server->id_entry) || route)) {
 476
 477       /* Check if we have sent the packet to this route already */
 478       for (k = 0; k < routed_count; k++)
 479         if (routed[k] == client->router)
 480           break;
 481       if (k < routed_count)
 482         continue;
 483
 484       /* Route only once to router */
 485       sock = (SilcSocketConnection)client->router->connection;
 486       if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
 487         if (gone)
 488           continue;
 489         gone = TRUE;
 490       }
 491
 492       /* Send the packet */
 493       silc_server_packet_send_dest(server, sock, type, flags,
 494                                    client->router->id, SILC_ID_SERVER,
 495                                    data, data_len, force_send);
 496
 497       /* Mark this route routed already */
 498       routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
 499       routed[routed_count++] = client->router;
 500       continue;
 501     }
 502
 503     if (client->router)
 504       continue;
 505
 506     /* Send to locally connected client */
 507     sock = (SilcSocketConnection)client->connection;
 508     if (!sock)
 509       continue;
 510
 511     silc_server_packet_send_dest(server, sock, type, flags,
 512                                  client->id, SILC_ID_CLIENT,
 513                                  data, data_len, force_send);
 514   }
 515   silc_hash_table_list_reset(&htl);
 516   silc_free(routed);
 517 }
 518
 519 /* Internal routine to actually create the channel packet and send it
 520    to network. This is common function in channel message sending. If
 521    `channel_message' is TRUE this encrypts the message as it is strictly
 522    a channel message. If FALSE normal encryption process is used. */
 523
 524 static void
 525 silc_server_packet_send_to_channel_real(SilcServer server,
 526                                         SilcSocketConnection sock,
 527                                         SilcPacketContext *packet,
 528                                         SilcCipher cipher,
 529                                         SilcHmac hmac,
 530                                         SilcUInt32 sequence,
 531                                         unsigned char *data,
 532                                         SilcUInt32 data_len,
 533                                         bool channel_message,
 534                                         bool force_send)
 535 {
 536   int block_len;
 537   const SilcBufferStruct p;
 538
 539   if (!sock)
 540     return;
 541
 542   data_len = SILC_PACKET_DATALEN(data_len, (SILC_PACKET_HEADER_LEN +
 543                                             packet->src_id_len +
 544                                             packet->dst_id_len));
 545   packet->truelen = data_len + SILC_PACKET_HEADER_LEN +
 546     packet->src_id_len + packet->dst_id_len;
 547
 548   block_len = cipher ? silc_cipher_get_block_len(cipher) : 0;
 549   if (channel_message)
 550     SILC_PACKET_PADLEN((SILC_PACKET_HEADER_LEN +
 551                         packet->src_id_len +
 552                         packet->dst_id_len), block_len, packet->padlen);
 553   else
 554     SILC_PACKET_PADLEN(packet->truelen, block_len, packet->padlen);
 555
 556   /* Put the data to buffer, assemble and encrypt the packet. The packet
 557      is encrypted with normal session key shared with the client, unless
 558      the `channel_message' is TRUE. */
 559   if (!silc_packet_assemble(packet, NULL, cipher, hmac, sock, data,
 560                             data_len, (const SilcBuffer)&p)) {
 561     SILC_LOG_ERROR(("Cannot assemble packet"));
 562     return;
 563   }
 564
 565   if (channel_message)
 566     silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p,
 567                         SILC_PACKET_HEADER_LEN + packet->src_id_len +
 568                         packet->dst_id_len + packet->padlen);
 569   else
 570     silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p, p.len);
 571
 572   SILC_LOG_HEXDUMP(("Channel packet (%d), len %d", sequence, p.len),
 573                    p.data, p.len);
 574
 575   /* Now actually send the packet */
 576   silc_server_packet_send_real(server, sock, force_send);
 577 }
 578
 579 /* This routine is used by the server to send packets to channel. The
 580    packet sent with this function is distributed to all clients on
 581    the channel. Usually this is used to send notify messages to the
 582    channel, things like notify about new user joining to the channel.
 583    If `route' is FALSE then the packet is sent only locally and will not
 584    be routed anywhere (for router locally means cell wide). If `sender'
 585    is provided then the packet is not sent to that connection since it
 586    originally came from it. If `send_to_clients' is FALSE then the
 587    packet is not sent clients, only servers. */
 588
 589 void silc_server_packet_send_to_channel(SilcServer server,
 590                                         SilcSocketConnection sender,
 591                                         SilcChannelEntry channel,
 592                                         SilcPacketType type,
 593                                         bool route,
 594                                         unsigned char *data,
 595                                         SilcUInt32 data_len,
 596                                         bool force_send)
 597 {
 598   SilcSocketConnection sock = NULL;
 599   SilcPacketContext packetdata;
 600   SilcClientEntry client = NULL;
 601   SilcServerEntry *routed = NULL;
 602   SilcChannelClientEntry chl;
 603   SilcHashTableList htl;
 604   SilcIDListData idata;
 605   SilcUInt32 routed_count = 0;
 606   bool gone = FALSE;
 607   int k;
 608
 609   /* This doesn't send channel message packets */
 610   assert(type != SILC_PACKET_CHANNEL_MESSAGE);
 611
 612   /* Set the packet context pointers. */
 613   packetdata.flags = 0;
 614   packetdata.type = type;
 615   packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
 616   packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
 617   packetdata.src_id_type = SILC_ID_SERVER;
 618   packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
 619   packetdata.dst_id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
 620   packetdata.dst_id_type = SILC_ID_CHANNEL;
 621
 622   /* If there are global users in the channel we will send the message
 623      first to our router for further routing. */
 624   if (route && server->server_type != SILC_ROUTER && !server->standalone &&
 625       channel->global_users) {
 626     SilcServerEntry router;
 627
 628     /* Get data used in packet header encryption, keys and stuff. */
 629     router = server->router;
 630     sock = (SilcSocketConnection)router->connection;
 631     idata = (SilcIDListData)router;
 632
 633     if (sock != sender) {
 634       SILC_LOG_DEBUG(("Sending packet to router for routing"));
 635       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 636                                               idata->send_key,
 637                                               idata->hmac_send,
 638                                               idata->psn_send++,
 639                                               data, data_len, FALSE,
 640                                               force_send);
 641     }
 642   }
 643
 644   if (!silc_hash_table_count(channel->user_list)) {
 645     SILC_LOG_DEBUG(("Channel %s is empty", channel->channel_name));
 646     goto out;
 647   }
 648
 649   SILC_LOG_DEBUG(("Sending %s to channel %s",
 650                   silc_get_packet_name(type), channel->channel_name));
 651
 652   routed = silc_calloc(silc_hash_table_count(channel->user_list),
 653                        sizeof(*routed));
 654
 655   /* Send the message to clients on the channel's client list. */
 656   silc_hash_table_list(channel->user_list, &htl);
 657   while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
 658     client = chl->client;
 659     if (!client)
 660       continue;
 661
 662     /* If client has router set it is not locally connected client and
 663        we will route the message to the router set in the client. Though,
 664        send locally connected server in all cases. */
 665     if (server->server_type == SILC_ROUTER && client->router &&
 666         ((!route && client->router->router == server->id_entry) || route)) {
 667
 668       /* Check if we have sent the packet to this route already */
 669       for (k = 0; k < routed_count; k++)
 670         if (routed[k] == client->router)
 671           break;
 672       if (k < routed_count)
 673         continue;
 674
 675       /* Get data used in packet header encryption, keys and stuff. */
 676       sock = (SilcSocketConnection)client->router->connection;
 677       idata = (SilcIDListData)client->router;
 678
 679       if (sender && sock == sender)
 680         continue;
 681
 682       /* Route only once to router. Protocol prohibits sending channel
 683          messages to more than one router. */
 684       if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
 685         if (gone)
 686           continue;
 687         gone = TRUE;
 688       }
 689
 690       SILC_LOG_DEBUG(("Sending packet to client %s",
 691                       client->nickname ? client->nickname :
 692                       (unsigned char *)""));
 693
 694       /* Send the packet */
 695       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 696                                               idata->send_key,
 697                                               idata->hmac_send,
 698                                               idata->psn_send++,
 699                                               data, data_len, FALSE,
 700                                               force_send);
 701
 702       /* Mark this route routed already */
 703       routed[routed_count++] = client->router;
 704       continue;
 705     }
 706
 707     if (client->router)
 708       continue;
 709
 710     /* Send to locally connected client */
 711
 712     /* Get data used in packet header encryption, keys and stuff. */
 713     sock = (SilcSocketConnection)client->connection;
 714     idata = (SilcIDListData)client;
 715
 716     if (!sock || (sender && sock == sender))
 717       continue;
 718
 719     SILC_LOG_DEBUG(("Sending packet to client %s",
 720                     client->nickname ? client->nickname :
 721                     (unsigned char *)""));
 722
 723     /* Send the packet */
 724     silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 725                                             idata->send_key,
 726                                             idata->hmac_send,
 727                                             idata->psn_send++,
 728                                             data, data_len, FALSE,
 729                                             force_send);
 730   }
 731   silc_hash_table_list_reset(&htl);
 732
 733  out:
 734   silc_free(routed);
 735   silc_free(packetdata.src_id);
 736   silc_free(packetdata.dst_id);
 737 }
 738
 739 /* This checks whether the relayed packet came from router. If it did
 740    then we'll need to encrypt it with the channel key. This is called
 741    from the silc_server_packet_relay_to_channel. */
 742
 743 static bool
 744 silc_server_packet_relay_to_channel_encrypt(SilcServer server,
 745                                             SilcSocketConnection sock,
 746                                             SilcChannelEntry channel,
 747                                             unsigned char *data,
 748                                             unsigned int data_len)
 749 {
 750   SilcUInt32 mac_len, iv_len;
 751   unsigned char iv[SILC_CIPHER_MAX_IV_SIZE];
 752
 753   /* If we are router and the packet came from router and private key
 754      has not been set for the channel then we must encrypt the packet
 755      as it was decrypted with the session key shared between us and the
 756      router which sent it. This is so, because cells does not share the
 757      same channel key. */
 758   if (server->server_type == SILC_ROUTER &&
 759       sock->type == SILC_SOCKET_TYPE_ROUTER &&
 760       !(channel->mode & SILC_CHANNEL_MODE_PRIVKEY) && channel->key) {
 761
 762     /* If we are backup router and remote is our primary router and
 763        we are currently doing backup resuming protocol we must not
 764        re-encrypt message with session key. */
 765     if (server->backup_router && SILC_SERVER_IS_BACKUP(sock) &&
 766         SILC_PRIMARY_ROUTE(server) == sock)
 767       return TRUE;
 768
 769     mac_len = silc_hmac_len(channel->hmac);
 770     iv_len = silc_cipher_get_block_len(channel->channel_key);
 771
 772     if (data_len <= mac_len + iv_len) {
 773       SILC_LOG_WARNING(("Corrupted channel message, cannot relay it"));
 774       return FALSE;
 775     }
 776
 777     memcpy(iv, data + (data_len - iv_len - mac_len), iv_len);
 778     silc_message_payload_encrypt(data, data_len - iv_len, data_len,
 779                                  iv, iv_len, channel->channel_key,
 780                                  channel->hmac);
 781   }
 782
 783   return TRUE;
 784 }
 785
 786 /* This routine is explicitly used to relay messages to some channel.
 787    Packets sent with this function we have received earlier and are
 788    totally encrypted. This just sends the packet to all clients on
 789    the channel. If the sender of the packet is someone on the channel
 790    the message will not be sent to that client. The SILC Packet header
 791    is encrypted with the session key shared between us and the client.
 792    MAC is also computed before encrypting the header. Rest of the
 793    packet will be untouched. */
 794
 795 void silc_server_packet_relay_to_channel(SilcServer server,
 796                                          SilcSocketConnection sender_sock,
 797                                          SilcChannelEntry channel,
 798                                          void *sender_id,
 799                                          SilcIdType sender_type,
 800                                          SilcClientEntry sender_entry,
 801                                          unsigned char *data,
 802                                          SilcUInt32 data_len,
 803                                          bool force_send)
 804 {
 805   SilcSocketConnection sock = NULL;
 806   SilcPacketContext packetdata;
 807   SilcClientEntry client = NULL;
 808   SilcServerEntry *routed = NULL;
 809   SilcChannelClientEntry chl, chl_sender;
 810   SilcUInt32 routed_count = 0;
 811   SilcIDListData idata;
 812   SilcHashTableList htl;
 813   bool gone = FALSE;
 814   int k;
 815
 816   if (!silc_server_client_on_channel(sender_entry, channel, &chl_sender))
 817     return;
 818
 819   SILC_LOG_DEBUG(("Relaying packet to channel %s", channel->channel_name));
 820
 821   /* This encrypts the packet, if needed. It will be encrypted if
 822      it came from the router thus it needs to be encrypted with the
 823      channel key. If the channel key does not exist, then we know we
 824      don't have a single local user on the channel. */
 825   if (!silc_server_packet_relay_to_channel_encrypt(server, sender_sock,
 826                                                    channel, data,
 827                                                    data_len))
 828     return;
 829
 830   /* Set the packet context pointers. */
 831   packetdata.flags = 0;
 832   packetdata.type = SILC_PACKET_CHANNEL_MESSAGE;
 833   packetdata.src_id = silc_id_id2str(sender_id, sender_type);
 834   packetdata.src_id_len = silc_id_get_len(sender_id, sender_type);
 835   packetdata.src_id_type = sender_type;
 836   packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
 837   packetdata.dst_id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
 838   packetdata.dst_id_type = SILC_ID_CHANNEL;
 839
 840   /* If there are global users in the channel we will send the message
 841      first to our router for further routing. */
 842   if (server->server_type != SILC_ROUTER && !server->standalone &&
 843       channel->global_users) {
 844     SilcServerEntry router = server->router;
 845
 846     /* Check that the sender is not our router. */
 847     if (sender_sock != (SilcSocketConnection)router->connection) {
 848
 849       /* Get data used in packet header encryption, keys and stuff. */
 850       sock = (SilcSocketConnection)router->connection;
 851       idata = (SilcIDListData)router;
 852
 853       SILC_LOG_DEBUG(("Sending message to router for routing"));
 854
 855       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 856                                               idata->send_key,
 857                                               idata->hmac_send,
 858                                               idata->psn_send++,
 859                                               data, data_len, TRUE,
 860                                               force_send);
 861     }
 862   }
 863
 864   routed = silc_calloc(silc_hash_table_count(channel->user_list),
 865                        sizeof(*routed));
 866
 867   /* Assure we won't route the message back to the sender's way. */
 868   if (sender_entry->router)
 869     routed[routed_count++] = sender_entry->router;
 870
 871   /* Send the message to clients on the channel's client list. */
 872   silc_hash_table_list(channel->user_list, &htl);
 873   while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
 874     client = chl->client;
 875     if (!client || client == sender_entry)
 876       continue;
 877
 878     /* Check whether message sending is blocked */
 879     if (chl->mode & SILC_CHANNEL_UMODE_BLOCK_MESSAGES)
 880       continue;
 881     if (chl->mode & SILC_CHANNEL_UMODE_BLOCK_MESSAGES_USERS &&
 882         !(chl_sender->mode & SILC_CHANNEL_UMODE_CHANOP) &&
 883         !(chl_sender->mode & SILC_CHANNEL_UMODE_CHANFO))
 884       continue;
 885     if (chl->mode & SILC_CHANNEL_UMODE_BLOCK_MESSAGES_ROBOTS &&
 886         sender_entry->mode & SILC_UMODE_ROBOT)
 887       continue;
 888
 889     /* If the client has set router it means that it is not locally
 890        connected client and we will route the packet further. */
 891     if (server->server_type == SILC_ROUTER && client->router) {
 892
 893       /* Check if we have sent the packet to this route already */
 894       for (k = 0; k < routed_count; k++)
 895         if (routed[k] == client->router)
 896           break;
 897       if (k < routed_count)
 898         continue;
 899
 900       /* Get data used in packet header encryption, keys and stuff. */
 901       sock = (SilcSocketConnection)client->router->connection;
 902       idata = (SilcIDListData)client->router;
 903
 904       /* Check if the sender socket is the same as this client's router
 905          socket. */
 906       if (sender_sock && sock == sender_sock)
 907         continue;
 908
 909       SILC_LOG_DEBUG(("Relaying packet to client ID(%s) %s (%s)",
 910                       silc_id_render(client->id, SILC_ID_CLIENT),
 911                       sock->hostname, sock->ip));
 912
 913       /* Mark this route routed already. */
 914       routed[routed_count++] = client->router;
 915
 916       if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
 917         /* The remote connection is router then we'll decrypt the
 918            channel message and re-encrypt it with the session key shared
 919            between us and the remote router. This is done because the
 920            channel keys are cell specific and we have different channel
 921            key than the remote router has. */
 922
 923         /* Route only once to router. Protocol prohibits sending channel
 924            messages to more than one router. */
 925         if (gone)
 926           continue;
 927         gone = TRUE;
 928
 929         /* If we are backup router and remote is our primary router and
 930            we are currently doing backup resuming protocol we must not
 931            re-encrypt message with session key. */
 932         if (server->backup_router && SILC_SERVER_IS_BACKUP(sock) &&
 933             SILC_PRIMARY_ROUTE(server) == sock) {
 934           silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 935                                                   idata->send_key,
 936                                                   idata->hmac_send,
 937                                                   idata->psn_send++,
 938                                                   data, data_len, TRUE,
 939                                                   force_send);
 940           continue;
 941         }
 942
 943         SILC_LOG_DEBUG(("Remote is router, encrypt with session key"));
 944
 945         /* If private key mode is not set then decrypt the packet
 946            and re-encrypt it */
 947         if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY) &&
 948             channel->channel_key) {
 949           unsigned char tmp[SILC_PACKET_MAX_LEN];
 950
 951           if (data_len > SILC_PACKET_MAX_LEN)
 952             data_len = SILC_PACKET_MAX_LEN;
 953           memcpy(tmp, data, data_len);
 954
 955           /* Decrypt the channel message (we don't check the MAC) */
 956           silc_message_payload_decrypt(tmp, data_len, FALSE, FALSE,
 957                                        channel->channel_key,
 958                                        channel->hmac, FALSE);
 959
 960           /* Now re-encrypt and send it to the router */
 961           silc_server_packet_send_srcdest(server, sock,
 962                                           SILC_PACKET_CHANNEL_MESSAGE, 0,
 963                                           sender_id, sender_type,
 964                                           channel->id, SILC_ID_CHANNEL,
 965                                           tmp, data_len, force_send);
 966         } else {
 967           /* Private key mode is set, we don't have the channel key, so
 968              just re-encrypt the entire packet and send it to the router. */
 969           silc_server_packet_send_srcdest(server, sock,
 970                                           SILC_PACKET_CHANNEL_MESSAGE, 0,
 971                                           sender_id, sender_type,
 972                                           channel->id, SILC_ID_CHANNEL,
 973                                           data, data_len, force_send);
 974         }
 975       } else {
 976         /* Send the packet to normal server */
 977         silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 978                                                 idata->send_key,
 979                                                 idata->hmac_send,
 980                                                 idata->psn_send++,
 981                                                 data, data_len, TRUE,
 982                                                 force_send);
 983       }
 984
 985       continue;
 986     }
 987
 988     if (client->router)
 989       continue;
 990
 991     /* Get data used in packet header encryption, keys and stuff. */
 992     sock = (SilcSocketConnection)client->connection;
 993     idata = (SilcIDListData)client;
 994
 995     if (!sock || (sender_sock && sock == sender_sock))
 996       continue;
 997
 998     SILC_LOG_DEBUG(("Sending packet to client ID(%s) %s (%s)",
 999                     silc_id_render(client->id, SILC_ID_CLIENT),
1000                     sock->hostname, sock->ip));
1001
1002     /* Send the packet */
1003     silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1004                                             idata->send_key,
1005                                             idata->hmac_send,
1006                                             idata->psn_send++,
1007                                             data, data_len, TRUE,
1008                                             force_send);
1009   }
1010
1011   silc_hash_table_list_reset(&htl);
1012   silc_free(routed);
1013   silc_free(packetdata.src_id);
1014   silc_free(packetdata.dst_id);
1015 }
1016
1017 /* This function is used to send packets strictly to all local clients
1018    on a particular channel.  This is used for example to distribute new
1019    channel key to all our locally connected clients on the channel.
1020    The packets are always encrypted with the session key shared between
1021    the client, this means these are not _to the channel_ but _to the client_
1022    on the channel. */
1023
1024 void silc_server_packet_send_local_channel(SilcServer server,
1025                                            SilcChannelEntry channel,
1026                                            SilcPacketType type,
1027                                            SilcPacketFlags flags,
1028                                            unsigned char *data,
1029                                            SilcUInt32 data_len,
1030                                            bool force_send)
1031 {
1032   SilcChannelClientEntry chl;
1033   SilcHashTableList htl;
1034   SilcSocketConnection sock = NULL;
1035
1036   SILC_LOG_DEBUG(("Send packet to local clients on channel %s",
1037                   channel->channel_name));
1038
1039   /* Send the message to clients on the channel's client list. */
1040   silc_hash_table_list(channel->user_list, &htl);
1041   while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
1042     if (chl->client && SILC_IS_LOCAL(chl->client)) {
1043       sock = chl->client->connection;
1044
1045       /* Send the packet to the client */
1046       silc_server_packet_send_dest(server, sock, type, flags, chl->client->id,
1047                                    SILC_ID_CLIENT, data, data_len,
1048                                    force_send);
1049     }
1050   }
1051   silc_hash_table_list_reset(&htl);
1052 }
1053
1054 /* Routine used to send (relay, route) private messages to some destination.
1055    If the private message key does not exist then the message is re-encrypted,
1056    otherwise we just pass it along. This really is not used to send new
1057    private messages (as server does not send them) but to relay received
1058    private messages. */
1059
1060 void silc_server_send_private_message(SilcServer server,
1061                                       SilcSocketConnection dst_sock,
1062                                       SilcCipher cipher,
1063                                       SilcHmac hmac,
1064                                       SilcUInt32 sequence,
1065                                       SilcPacketContext *packet)
1066 {
1067   SilcBuffer buffer = packet->buffer;
1068   const SilcBufferStruct p;
1069
1070   silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1071                    + packet->dst_id_len + packet->padlen);
1072   if (!silc_packet_send_prepare(dst_sock, 0, 0, buffer->len, hmac,
1073                                 (const SilcBuffer)&p)) {
1074     SILC_LOG_ERROR(("Cannot send packet"));
1075     return;
1076   }
1077   silc_buffer_put((SilcBuffer)&p, buffer->data, buffer->len);
1078
1079   /* Re-encrypt and send if private messge key does not exist */
1080   if (!(packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY)) {
1081     /* Re-encrypt packet */
1082     silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p, buffer->len);
1083   } else {
1084     /* Key exist so encrypt just header and send it */
1085     silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p,
1086                         SILC_PACKET_HEADER_LEN + packet->src_id_len +
1087                         packet->dst_id_len + packet->padlen);
1088   }
1089
1090   /* Send the packet */
1091   silc_server_packet_send_real(server, dst_sock, FALSE);
1092
1093   /* Check for mandatory rekey */
1094   if (sequence == SILC_SERVER_REKEY_THRESHOLD)
1095     silc_schedule_task_add(server->schedule, dst_sock->sock,
1096                            silc_server_rekey_callback, dst_sock, 0, 1,
1097                            SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
1098 }
1099
1100 /* Sends current motd to client */
1101
1102 void silc_server_send_motd(SilcServer server,
1103                            SilcSocketConnection sock)
1104 {
1105   char *motd, *motd_file = NULL;
1106   SilcUInt32 motd_len;
1107
1108   if (server->config)
1109     motd_file = server->config->server_info->motd_file;
1110
1111   if (motd_file) {
1112     motd = silc_file_readfile(motd_file, &motd_len);
1113     if (!motd)
1114       return;
1115
1116     motd[motd_len] = 0;
1117     silc_server_send_notify(server, sock, FALSE, SILC_NOTIFY_TYPE_MOTD, 1,
1118                             motd, motd_len);
1119     silc_free(motd);
1120   }
1121 }
1122
1123 /* Sends error message. Error messages may or may not have any
1124    implications. */
1125
1126 void silc_server_send_error(SilcServer server,
1127                             SilcSocketConnection sock,
1128                             const char *fmt, ...)
1129 {
1130   va_list ap;
1131   unsigned char buf[4096];
1132
1133   memset(buf, 0, sizeof(buf));
1134   va_start(ap, fmt);
1135   vsnprintf(buf, sizeof(buf) - 1, fmt, ap);
1136   va_end(ap);
1137
1138   silc_server_packet_send(server, sock, SILC_PACKET_ERROR, 0,
1139                           buf, strlen(buf), FALSE);
1140 }
1141
1142 /* Sends notify message. If format is TRUE the variable arguments are
1143    formatted and the formatted string is sent as argument payload. If it is
1144    FALSE then each argument is sent as separate argument and their format
1145    in the argument list must be { argument data, argument length }. */
1146
1147 void silc_server_send_notify(SilcServer server,
1148                              SilcSocketConnection sock,
1149                              bool broadcast,
1150                              SilcNotifyType type,
1151                              SilcUInt32 argc, ...)
1152 {
1153   va_list ap;
1154   SilcBuffer packet;
1155
1156   va_start(ap, argc);
1157
1158   packet = silc_notify_payload_encode(type, argc, ap);
1159   silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
1160                           broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1161                           packet->data, packet->len, FALSE);
1162
1163   /* Send to backup routers if this is being broadcasted to primary
1164      router.  The silc_server_backup_send checks further whether to
1165      actually send it or not. */
1166   if ((broadcast && sock && sock == SILC_PRIMARY_ROUTE(server)) ||
1167       (broadcast && !sock && !SILC_PRIMARY_ROUTE(server)))
1168     silc_server_backup_send(server, NULL, SILC_PACKET_NOTIFY, 0,
1169                             packet->data, packet->len, FALSE, TRUE);
1170
1171   silc_buffer_free(packet);
1172   va_end(ap);
1173 }
1174
1175 /* Sends notify message and gets the arguments from the `args' Argument
1176    Payloads. */
1177
1178 void silc_server_send_notify_args(SilcServer server,
1179                                   SilcSocketConnection sock,
1180                                   bool broadcast,
1181                                   SilcNotifyType type,
1182                                   SilcUInt32 argc,
1183                                   SilcBuffer args)
1184 {
1185   SilcBuffer packet;
1186
1187   packet = silc_notify_payload_encode_args(type, argc, args);
1188   silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
1189                           broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1190                           packet->data, packet->len, FALSE);
1191   silc_buffer_free(packet);
1192 }
1193
1194 /* Send CHANNEL_CHANGE notify type. This tells the receiver to replace the
1195    `old_id' with the `new_id'. */
1196
1197 void silc_server_send_notify_channel_change(SilcServer server,
1198                                             SilcSocketConnection sock,
1199                                             bool broadcast,
1200                                             SilcChannelID *old_id,
1201                                             SilcChannelID *new_id)
1202 {
1203   SilcBuffer idp1, idp2;
1204
1205   idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CHANNEL);
1206   idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CHANNEL);
1207
1208   silc_server_send_notify(server, sock, broadcast,
1209                           SILC_NOTIFY_TYPE_CHANNEL_CHANGE,
1210                           2, idp1->data, idp1->len, idp2->data, idp2->len);
1211   silc_buffer_free(idp1);
1212   silc_buffer_free(idp2);
1213 }
1214
1215 /* Send NICK_CHANGE notify type. This tells the receiver to replace the
1216    `old_id' with the `new_id'. */
1217
1218 void silc_server_send_notify_nick_change(SilcServer server,
1219                                          SilcSocketConnection sock,
1220                                          bool broadcast,
1221                                          SilcClientID *old_id,
1222                                          SilcClientID *new_id,
1223                                          const char *nickname)
1224 {
1225   SilcBuffer idp1, idp2;
1226
1227   idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CLIENT);
1228   idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CLIENT);
1229
1230   silc_server_send_notify(server, sock, broadcast,
1231                           SILC_NOTIFY_TYPE_NICK_CHANGE,
1232                           3, idp1->data, idp1->len, idp2->data, idp2->len,
1233                           nickname, nickname ? strlen(nickname) : 0);
1234   silc_buffer_free(idp1);
1235   silc_buffer_free(idp2);
1236 }
1237
1238 /* Sends JOIN notify type. This tells that new client by `client_id' ID
1239    has joined to the `channel'. */
1240
1241 void silc_server_send_notify_join(SilcServer server,
1242                                   SilcSocketConnection sock,
1243                                   bool broadcast,
1244                                   SilcChannelEntry channel,
1245                                   SilcClientID *client_id)
1246 {
1247   SilcBuffer idp1, idp2;
1248
1249   idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1250   idp2 = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1251   silc_server_send_notify(server, sock, broadcast, SILC_NOTIFY_TYPE_JOIN,
1252                           2, idp1->data, idp1->len,
1253                           idp2->data, idp2->len);
1254   silc_buffer_free(idp1);
1255   silc_buffer_free(idp2);
1256 }
1257
1258 /* Sends LEAVE notify type. This tells that `client_id' has left the
1259    `channel'. The Notify packet is always destined to the channel. */
1260
1261 void silc_server_send_notify_leave(SilcServer server,
1262                                    SilcSocketConnection sock,
1263                                    bool broadcast,
1264                                    SilcChannelEntry channel,
1265                                    SilcClientID *client_id)
1266 {
1267   SilcBuffer idp;
1268
1269   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1270   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1271                                SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_LEAVE,
1272                                1, idp->data, idp->len);
1273   silc_buffer_free(idp);
1274 }
1275
1276 /* Sends CMODE_CHANGE notify type. This tells that `client_id' changed the
1277    `channel' mode to `mode. The Notify packet is always destined to
1278    the channel. */
1279
1280 void silc_server_send_notify_cmode(SilcServer server,
1281                                    SilcSocketConnection sock,
1282                                    bool broadcast,
1283                                    SilcChannelEntry channel,
1284                                    SilcUInt32 mode_mask,
1285                                    void *id, SilcIdType id_type,
1286                                    const char *cipher, const char *hmac,
1287                                    const char *passphrase,
1288                                    SilcPublicKey founder_key,
1289                                    SilcBuffer channel_pubkeys)
1290 {
1291   SilcBuffer idp, fkey = NULL;
1292   unsigned char mode[4];
1293
1294   idp = silc_id_payload_encode((void *)id, id_type);
1295   SILC_PUT32_MSB(mode_mask, mode);
1296   if (founder_key)
1297     fkey = silc_pkcs_public_key_payload_encode(founder_key);
1298
1299   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1300                                SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_CMODE_CHANGE,
1301                                7, idp->data, idp->len,
1302                                mode, 4,
1303                                cipher, cipher ? strlen(cipher) : 0,
1304                                hmac, hmac ? strlen(hmac) : 0,
1305                                passphrase, passphrase ?
1306                                strlen(passphrase) : 0,
1307                                fkey ? fkey->data : NULL, fkey ? fkey->len : 0,
1308                                channel_pubkeys ? channel_pubkeys->data : NULL,
1309                                channel_pubkeys ? channel_pubkeys->len : 0);
1310   silc_buffer_free(fkey);
1311   silc_buffer_free(idp);
1312 }
1313
1314 /* Sends CUMODE_CHANGE notify type. This tells that `id' changed the
1315    `target' client's mode on `channel'. The notify packet is always
1316    destined to the channel. */
1317
1318 void silc_server_send_notify_cumode(SilcServer server,
1319                                     SilcSocketConnection sock,
1320                                     bool broadcast,
1321                                     SilcChannelEntry channel,
1322                                     SilcUInt32 mode_mask,
1323                                     void *id, SilcIdType id_type,
1324                                     SilcClientID *target,
1325                                     SilcPublicKey founder_key)
1326 {
1327   SilcBuffer idp1, idp2, fkey = NULL;
1328   unsigned char mode[4];
1329
1330   idp1 = silc_id_payload_encode((void *)id, id_type);
1331   idp2 = silc_id_payload_encode((void *)target, SILC_ID_CLIENT);
1332   SILC_PUT32_MSB(mode_mask, mode);
1333   if (founder_key)
1334     fkey = silc_pkcs_public_key_payload_encode(founder_key);
1335
1336   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1337                                SILC_ID_CHANNEL,
1338                                SILC_NOTIFY_TYPE_CUMODE_CHANGE, 4,
1339                                idp1->data, idp1->len,
1340                                mode, 4,
1341                                idp2->data, idp2->len,
1342                                fkey ? fkey->data : NULL, fkey ? fkey->len : 0);
1343   silc_buffer_free(fkey);
1344   silc_buffer_free(idp1);
1345   silc_buffer_free(idp2);
1346 }
1347
1348 /* Sends SIGNOFF notify type. This tells that `client_id' client has
1349    left SILC network. This function is used only between server and router
1350    traffic. This is not used to send the notify to the channel for
1351    client. The `message may be NULL. */
1352
1353 void silc_server_send_notify_signoff(SilcServer server,
1354                                      SilcSocketConnection sock,
1355                                      bool broadcast,
1356                                      SilcClientID *client_id,
1357                                      const char *message)
1358 {
1359   SilcBuffer idp;
1360
1361   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1362   silc_server_send_notify(server, sock, broadcast,
1363                           SILC_NOTIFY_TYPE_SIGNOFF,
1364                           message ? 2 : 1, idp->data, idp->len,
1365                           message, message ? strlen(message): 0);
1366   silc_buffer_free(idp);
1367 }
1368
1369 /* Sends TOPIC_SET notify type. This tells that `id' changed
1370    the `channel's topic to `topic'. The Notify packet is always destined
1371    to the channel. This function is used to send the topic set notifies
1372    between routers. */
1373
1374 void silc_server_send_notify_topic_set(SilcServer server,
1375                                        SilcSocketConnection sock,
1376                                        bool broadcast,
1377                                        SilcChannelEntry channel,
1378                                        void *id, SilcIdType id_type,
1379                                        char *topic)
1380 {
1381   SilcBuffer idp;
1382
1383   idp = silc_id_payload_encode(id, id_type);
1384   silc_server_send_notify_dest(server, sock, broadcast,
1385                                (void *)channel->id, SILC_ID_CHANNEL,
1386                                SILC_NOTIFY_TYPE_TOPIC_SET,
1387                                topic ? 2 : 1,
1388                                idp->data, idp->len,
1389                                topic, topic ? strlen(topic) : 0);
1390   silc_buffer_free(idp);
1391 }
1392
1393 /* Send KICKED notify type. This tells that the `client_id' on `channel'
1394    was kicked off the channel.  The `comment' may indicate the reason
1395    for the kicking. This function is used only between server and router
1396    traffic. */
1397
1398 void silc_server_send_notify_kicked(SilcServer server,
1399                                     SilcSocketConnection sock,
1400                                     bool broadcast,
1401                                     SilcChannelEntry channel,
1402                                     SilcClientID *client_id,
1403                                     SilcClientID *kicker,
1404                                     char *comment)
1405 {
1406   SilcBuffer idp1;
1407   SilcBuffer idp2;
1408
1409   idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1410   idp2 = silc_id_payload_encode((void *)kicker, SILC_ID_CLIENT);
1411   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1412                                SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_KICKED, 3,
1413                                idp1->data, idp1->len,
1414                                comment, comment ? strlen(comment) : 0,
1415                                idp2->data, idp2->len);
1416   silc_buffer_free(idp1);
1417   silc_buffer_free(idp2);
1418 }
1419
1420 /* Send KILLED notify type. This tells that the `client_id' client was
1421    killed from the network.  The `comment' may indicate the reason
1422    for the killing. */
1423
1424 void silc_server_send_notify_killed(SilcServer server,
1425                                     SilcSocketConnection sock,
1426                                     bool broadcast,
1427                                     SilcClientID *client_id,
1428                                     const char *comment,
1429                                     void *killer, SilcIdType killer_type)
1430 {
1431   SilcBuffer idp1;
1432   SilcBuffer idp2;
1433
1434   idp1 = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
1435   idp2 = silc_id_payload_encode(killer, killer_type);
1436   silc_server_send_notify_dest(server, sock, broadcast, (void *)client_id,
1437                                SILC_ID_CLIENT, SILC_NOTIFY_TYPE_KILLED,
1438                                3, idp1->data, idp1->len,
1439                                comment, comment ? strlen(comment) : 0,
1440                                idp2->data, idp2->len);
1441   silc_buffer_free(idp1);
1442   silc_buffer_free(idp2);
1443 }
1444
1445 /* Sends UMODE_CHANGE notify type. This tells that `client_id' client's
1446    user mode in the SILC Network was changed. This function is used to
1447    send the packet between routers as broadcast packet. */
1448
1449 void silc_server_send_notify_umode(SilcServer server,
1450                                    SilcSocketConnection sock,
1451                                    bool broadcast,
1452                                    SilcClientID *client_id,
1453                                    SilcUInt32 mode_mask)
1454 {
1455   SilcBuffer idp;
1456   unsigned char mode[4];
1457
1458   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1459   SILC_PUT32_MSB(mode_mask, mode);
1460
1461   silc_server_send_notify(server, sock, broadcast,
1462                           SILC_NOTIFY_TYPE_UMODE_CHANGE, 2,
1463                           idp->data, idp->len,
1464                           mode, 4);
1465   silc_buffer_free(idp);
1466 }
1467
1468 /* Sends BAN notify type. This tells that ban has been either `add'ed
1469    or `del'eted on the `channel. This function is used to send the packet
1470    between routers as broadcast packet. */
1471
1472 void silc_server_send_notify_ban(SilcServer server,
1473                                  SilcSocketConnection sock,
1474                                  bool broadcast,
1475                                  SilcChannelEntry channel,
1476                                  unsigned char *action,
1477                                  SilcBuffer list)
1478 {
1479   SilcBuffer idp;
1480
1481   idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1482   silc_server_send_notify(server, sock, broadcast,
1483                           SILC_NOTIFY_TYPE_BAN, 3,
1484                           idp->data, idp->len,
1485                           action ? action : NULL, action ? 1 : 0,
1486                           list ? list->data : NULL, list ? list->len : 0);
1487   silc_buffer_free(idp);
1488 }
1489
1490 /* Sends INVITE notify type. This tells that invite has been either `add'ed
1491    or `del'eted on the `channel.  The sender of the invite is the `client_id'.
1492    This function is used to send the packet between routers as broadcast
1493    packet. */
1494
1495 void silc_server_send_notify_invite(SilcServer server,
1496                                     SilcSocketConnection sock,
1497                                     bool broadcast,
1498                                     SilcChannelEntry channel,
1499                                     SilcClientID *client_id,
1500                                     unsigned char *action,
1501                                     SilcBuffer list)
1502 {
1503   SilcBuffer idp, idp2;
1504
1505   idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1506   idp2 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1507   silc_server_send_notify(server, sock, broadcast,
1508                           SILC_NOTIFY_TYPE_INVITE, 5,
1509                           idp->data, idp->len,
1510                           channel->channel_name, strlen(channel->channel_name),
1511                           idp2->data, idp2->len,
1512                           action ? action : NULL, action ? 1 : 0,
1513                           list ? list->data : NULL, list ? list->len : 0);
1514   silc_buffer_free(idp);
1515   silc_buffer_free(idp2);
1516 }
1517
1518 /* Sends WATCH notify type. This tells that the `client' was watched and
1519    its status in the network has changed. */
1520
1521 void silc_server_send_notify_watch(SilcServer server,
1522                                    SilcSocketConnection sock,
1523                                    SilcClientEntry watcher,
1524                                    SilcClientEntry client,
1525                                    const char *nickname,
1526                                    SilcNotifyType type)
1527 {
1528   SilcBuffer idp;
1529   unsigned char mode[4], n[2];
1530
1531   idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
1532   SILC_PUT16_MSB(type, n);
1533   SILC_PUT32_MSB(client->mode, mode);
1534   silc_server_send_notify_dest(server, sock, FALSE, watcher->id,
1535                                SILC_ID_CLIENT, SILC_NOTIFY_TYPE_WATCH,
1536                                4, idp->data, idp->len,
1537                                nickname, nickname ? strlen(nickname) : 0,
1538                                mode, sizeof(mode),
1539                                type != SILC_NOTIFY_TYPE_NONE ?
1540                                n : NULL, sizeof(n));
1541   silc_buffer_free(idp);
1542 }
1543
1544 /* Sends notify message destined to specific entity. */
1545
1546 void silc_server_send_notify_dest(SilcServer server,
1547                                   SilcSocketConnection sock,
1548                                   bool broadcast,
1549                                   void *dest_id,
1550                                   SilcIdType dest_id_type,
1551                                   SilcNotifyType type,
1552                                   SilcUInt32 argc, ...)
1553 {
1554   va_list ap;
1555   SilcBuffer packet;
1556
1557   va_start(ap, argc);
1558
1559   packet = silc_notify_payload_encode(type, argc, ap);
1560   silc_server_packet_send_dest(server, sock, SILC_PACKET_NOTIFY,
1561                                broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1562                                dest_id, dest_id_type,
1563                                packet->data, packet->len, FALSE);
1564
1565   /* Send to backup routers if this is being broadcasted to primary
1566      router.  The silc_server_backup_send checks further whether to
1567      actually send it or not. */
1568   if ((broadcast && sock && sock == SILC_PRIMARY_ROUTE(server)) ||
1569       (broadcast && !sock && !SILC_PRIMARY_ROUTE(server)))
1570     silc_server_backup_send_dest(server, NULL, SILC_PACKET_NOTIFY, 0,
1571                                  dest_id, dest_id_type,
1572                                  packet->data, packet->len, FALSE, TRUE);
1573
1574   silc_buffer_free(packet);
1575   va_end(ap);
1576 }
1577
1578 /* Sends notify message to a channel. The notify message sent is
1579    distributed to all clients on the channel. If `route_notify' is TRUE
1580    then the notify may be routed to primary route or to some other routers.
1581    If FALSE it is assured that the notify is sent only locally. If `sender'
1582    is provided then the packet is not sent to that connection since it
1583    originally came from it. */
1584
1585 void silc_server_send_notify_to_channel(SilcServer server,
1586                                         SilcSocketConnection sender,
1587                                         SilcChannelEntry channel,
1588                                         bool route_notify,
1589                                         SilcNotifyType type,
1590                                         SilcUInt32 argc, ...)
1591 {
1592   va_list ap;
1593   SilcBuffer packet;
1594
1595   va_start(ap, argc);
1596
1597   packet = silc_notify_payload_encode(type, argc, ap);
1598   silc_server_packet_send_to_channel(server, sender, channel,
1599                                      SILC_PACKET_NOTIFY, route_notify,
1600                                      packet->data, packet->len, FALSE);
1601   silc_buffer_free(packet);
1602   va_end(ap);
1603 }
1604
1605 /* Send notify message to all channels the client has joined. It is quaranteed
1606    that the message is sent only once to a client (ie. if a client is joined
1607    on two same channel it will receive only one notify message). Also, this
1608    sends only to local clients (locally connected if we are server, and to
1609    local servers if we are router). If `sender' is provided the packet is
1610    not sent to that client at all. */
1611
1612 void silc_server_send_notify_on_channels(SilcServer server,
1613                                          SilcClientEntry sender,
1614                                          SilcClientEntry client,
1615                                          SilcNotifyType type,
1616                                          SilcUInt32 argc, ...)
1617 {
1618   int k;
1619   SilcSocketConnection sock = NULL;
1620   SilcPacketContext packetdata;
1621   SilcClientEntry c;
1622   SilcClientEntry *sent_clients = NULL;
1623   SilcUInt32 sent_clients_count = 0;
1624   SilcServerEntry *routed = NULL;
1625   SilcUInt32 routed_count = 0;
1626   SilcHashTableList htl, htl2;
1627   SilcChannelEntry channel;
1628   SilcChannelClientEntry chl, chl2;
1629   SilcIDListData idata;
1630   SilcBuffer packet;
1631   unsigned char *data;
1632   SilcUInt32 data_len;
1633   bool force_send = FALSE;
1634   va_list ap;
1635
1636   if (!silc_hash_table_count(client->channels)) {
1637     SILC_LOG_DEBUG(("Client is not joined to any channels"));
1638     return;
1639   }
1640
1641   SILC_LOG_DEBUG(("Sending notify to joined channels"));
1642
1643   va_start(ap, argc);
1644   packet = silc_notify_payload_encode(type, argc, ap);
1645   data = packet->data;
1646   data_len = packet->len;
1647
1648   /* Set the packet context pointers. */
1649   packetdata.flags = 0;
1650   packetdata.type = SILC_PACKET_NOTIFY;
1651   packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
1652   packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
1653   packetdata.src_id_type = SILC_ID_SERVER;
1654
1655   silc_hash_table_list(client->channels, &htl);
1656   while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
1657     channel = chl->channel;
1658
1659     /* Send the message to all clients on the channel's client list. */
1660     silc_hash_table_list(channel->user_list, &htl2);
1661     while (silc_hash_table_get(&htl2, NULL, (void **)&chl2)) {
1662       c = chl2->client;
1663
1664       if (sender && c == sender)
1665         continue;
1666
1667       /* Check if we have sent the packet to this client already */
1668       for (k = 0; k < sent_clients_count; k++)
1669         if (sent_clients[k] == c)
1670           break;
1671       if (k < sent_clients_count)
1672         continue;
1673
1674       /* If we are router and if this client has router set it is not
1675          locally connected client and we will route the message to the
1676          router set in the client. */
1677       if (c && c->router && server->server_type == SILC_ROUTER) {
1678         /* Check if we have sent the packet to this route already */
1679         for (k = 0; k < routed_count; k++)
1680           if (routed[k] == c->router)
1681             break;
1682         if (k < routed_count)
1683           continue;
1684
1685         /* Get data used in packet header encryption, keys and stuff. */
1686         sock = (SilcSocketConnection)c->router->connection;
1687         idata = (SilcIDListData)c->router;
1688
1689         {
1690           SILC_LOG_DEBUG(("*****************"));
1691           SILC_LOG_DEBUG(("client->router->id %s",
1692                           silc_id_render(c->router->id, SILC_ID_SERVER)));
1693           SILC_LOG_DEBUG(("client->router->connection->user_data->id %s",
1694                           silc_id_render(((SilcServerEntry)sock->user_data)->id, SILC_ID_SERVER)));
1695         }
1696
1697         packetdata.dst_id = silc_id_id2str(c->router->id, SILC_ID_SERVER);
1698         packetdata.dst_id_len = silc_id_get_len(c->router->id, SILC_ID_SERVER);
1699         packetdata.dst_id_type = SILC_ID_SERVER;
1700
1701         /* Send the packet */
1702         silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1703                                                 idata->send_key,
1704                                                 idata->hmac_send,
1705                                                 idata->psn_send++,
1706                                                 data, data_len, FALSE,
1707                                                 force_send);
1708
1709         silc_free(packetdata.dst_id);
1710
1711         /* We want to make sure that the packet is routed to same router
1712            only once. Mark this route as sent route. */
1713         routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
1714         routed[routed_count++] = c->router;
1715         continue;
1716       }
1717
1718       if (c && c->router)
1719         continue;
1720
1721       /* Send to locally connected client */
1722       if (c) {
1723
1724         /* Get data used in packet header encryption, keys and stuff. */
1725         sock = (SilcSocketConnection)c->connection;
1726         idata = (SilcIDListData)c;
1727
1728         if (!sock)
1729           continue;
1730
1731         packetdata.dst_id = silc_id_id2str(c->id, SILC_ID_CLIENT);
1732         packetdata.dst_id_len = silc_id_get_len(c->id, SILC_ID_CLIENT);
1733         packetdata.dst_id_type = SILC_ID_CLIENT;
1734
1735         /* Send the packet */
1736         silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1737                                                 idata->send_key,
1738                                                 idata->hmac_send,
1739                                                 idata->psn_send++,
1740                                                 data, data_len, FALSE,
1741                                                 force_send);
1742
1743         silc_free(packetdata.dst_id);
1744
1745         /* Make sure that we send the notify only once per client. */
1746         sent_clients = silc_realloc(sent_clients, sizeof(*sent_clients) *
1747                                     (sent_clients_count + 1));
1748         sent_clients[sent_clients_count++] = c;
1749       }
1750     }
1751     silc_hash_table_list_reset(&htl2);
1752   }
1753
1754   silc_hash_table_list_reset(&htl);
1755   silc_free(routed);
1756   silc_free(sent_clients);
1757   silc_free(packetdata.src_id);
1758   silc_buffer_free(packet);
1759   va_end(ap);
1760 }
1761
1762 /* Sends New ID Payload to remote end. The packet is used to distribute
1763    information about new registered clients, servers, channel etc. usually
1764    to routers so that they can keep these information up to date.
1765    If the argument `broadcast' is TRUE then the packet is sent as
1766    broadcast packet. */
1767
1768 void silc_server_send_new_id(SilcServer server,
1769                              SilcSocketConnection sock,
1770                              bool broadcast,
1771                              void *id, SilcIdType id_type,
1772                              SilcUInt32 id_len)
1773 {
1774   SilcBuffer idp;
1775
1776   SILC_LOG_DEBUG(("Sending new ID"));
1777
1778   idp = silc_id_payload_encode(id, id_type);
1779   silc_server_packet_send(server, sock, SILC_PACKET_NEW_ID,
1780                           broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1781                           idp->data, idp->len, FALSE);
1782   silc_buffer_free(idp);
1783 }
1784
1785 /* Send New Channel Payload to notify about newly created channel in the
1786    SILC network. Router uses this to notify other routers in the network
1787    about new channel. This packet is broadcasted by router. */
1788
1789 void silc_server_send_new_channel(SilcServer server,
1790                                   SilcSocketConnection sock,
1791                                   bool broadcast,
1792                                   char *channel_name,
1793                                   void *channel_id,
1794                                   SilcUInt32 channel_id_len,
1795                                   SilcUInt32 mode)
1796 {
1797   SilcBuffer packet;
1798   unsigned char *cid;
1799   SilcUInt32 name_len = strlen(channel_name);
1800
1801   SILC_LOG_DEBUG(("Sending new channel"));
1802
1803   cid = silc_id_id2str(channel_id, SILC_ID_CHANNEL);
1804   if (!cid)
1805     return;
1806
1807   /* Encode the channel payload */
1808   packet = silc_channel_payload_encode(channel_name, name_len,
1809                                        cid, channel_id_len, mode);
1810
1811   silc_server_packet_send(server, sock, SILC_PACKET_NEW_CHANNEL,
1812                           broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1813                           packet->data, packet->len, FALSE);
1814
1815   silc_free(cid);
1816   silc_buffer_free(packet);
1817 }
1818
1819 /* Send Channel Key payload to distribute the new channel key. Normal server
1820    sends this to router when new client joins to existing channel. Router
1821    sends this to the local server who sent the join command in case where
1822    the channel did not exist yet. Both normal and router servers uses this
1823    also to send this to locally connected clients on the channel. This
1824    must not be broadcasted packet. Routers do not send this to each other.
1825    If `sender is provided then the packet is not sent to that connection since
1826    it originally came from it. */
1827
1828 void silc_server_send_channel_key(SilcServer server,
1829                                   SilcSocketConnection sender,
1830                                   SilcChannelEntry channel,
1831                                   unsigned char route)
1832 {
1833   SilcBuffer packet;
1834   unsigned char *chid;
1835   SilcUInt32 tmp_len;
1836   const char *cipher;
1837
1838   SILC_LOG_DEBUG(("Sending key to channel %s", channel->channel_name));
1839
1840   chid = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
1841   if (!chid)
1842     return;
1843
1844   if (!channel->channel_key)
1845     return;
1846
1847   /* Encode channel key packet */
1848   cipher = silc_cipher_get_name(channel->channel_key);
1849   tmp_len = strlen(cipher);
1850   packet = silc_channel_key_payload_encode(silc_id_get_len(channel->id,
1851                                                            SILC_ID_CHANNEL),
1852                                            chid, tmp_len, cipher,
1853                                            channel->key_len / 8, channel->key);
1854   silc_server_packet_send_to_channel(server, sender, channel,
1855                                      SILC_PACKET_CHANNEL_KEY,
1856                                      route, packet->data, packet->len,
1857                                      FALSE);
1858   silc_buffer_free(packet);
1859   silc_free(chid);
1860 }
1861
1862 /* Generic function to send any command. The arguments must be sent already
1863    encoded into correct form in correct order. */
1864
1865 void silc_server_send_command(SilcServer server,
1866                               SilcSocketConnection sock,
1867                               SilcCommand command,
1868                               SilcUInt16 ident,
1869                               SilcUInt32 argc, ...)
1870 {
1871   SilcBuffer packet;
1872   va_list ap;
1873
1874   va_start(ap, argc);
1875
1876   packet = silc_command_payload_encode_vap(command, ident, argc, ap);
1877   silc_server_packet_send(server, sock, SILC_PACKET_COMMAND, 0,
1878                           packet->data, packet->len, FALSE);
1879   silc_buffer_free(packet);
1880   va_end(ap);
1881 }
1882
1883 /* Generic function to send any command reply. The arguments must be sent
1884    already encoded into correct form in correct order. */
1885
1886 void silc_server_send_command_reply(SilcServer server,
1887                                     SilcSocketConnection sock,
1888                                     SilcCommand command,
1889                                     SilcStatus status,
1890                                     SilcStatus error,
1891                                     SilcUInt16 ident,
1892                                     SilcUInt32 argc, ...)
1893 {
1894   SilcBuffer packet;
1895   va_list ap;
1896
1897   va_start(ap, argc);
1898
1899   packet = silc_command_reply_payload_encode_vap(command, status, error,
1900                                                  ident, argc, ap);
1901   silc_server_packet_send(server, sock, SILC_PACKET_COMMAND_REPLY, 0,
1902                           packet->data, packet->len, TRUE);
1903   silc_buffer_free(packet);
1904   va_end(ap);
1905 }
1906
1907 /* Generic function to send any command reply. The arguments must be sent
1908    already encoded into correct form in correct order. */
1909
1910 void silc_server_send_dest_command_reply(SilcServer server,
1911                                          SilcSocketConnection sock,
1912                                          void *dst_id,
1913                                          SilcIdType dst_id_type,
1914                                          SilcCommand command,
1915                                          SilcStatus status,
1916                                          SilcStatus error,
1917                                          SilcUInt16 ident,
1918                                          SilcUInt32 argc, ...)
1919 {
1920   SilcBuffer packet;
1921   va_list ap;
1922
1923   va_start(ap, argc);
1924
1925   packet = silc_command_reply_payload_encode_vap(command, status, error,
1926                                                  ident, argc, ap);
1927   silc_server_packet_send_dest(server, sock, SILC_PACKET_COMMAND_REPLY, 0,
1928                                dst_id, dst_id_type, packet->data,
1929                                packet->len, FALSE);
1930   silc_buffer_free(packet);
1931   va_end(ap);
1932 }
1933
1934 /* Send the heartbeat packet. */
1935
1936 void silc_server_send_heartbeat(SilcServer server,
1937                                 SilcSocketConnection sock)
1938 {
1939   silc_server_packet_send(server, sock, SILC_PACKET_HEARTBEAT, 0,
1940                           NULL, 0, FALSE);
1941 }
1942
1943 /* Generic function to relay packet we've received. This is used to relay
1944    packets to a client but generally can be used to other purposes as well. */
1945
1946 void silc_server_relay_packet(SilcServer server,
1947                               SilcSocketConnection dst_sock,
1948                               SilcCipher cipher,
1949                               SilcHmac hmac,
1950                               SilcUInt32 sequence,
1951                               SilcPacketContext *packet,
1952                               bool force_send)
1953 {
1954   const SilcBufferStruct p;
1955
1956   silc_buffer_push(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1957                    + packet->dst_id_len + packet->padlen);
1958   if (!silc_packet_send_prepare(dst_sock, 0, 0, packet->buffer->len, hmac,
1959                                 (const SilcBuffer)&p)) {
1960     SILC_LOG_ERROR(("Cannot send packet"));
1961     return;
1962   }
1963   silc_buffer_put((SilcBuffer)&p, packet->buffer->data, packet->buffer->len);
1964
1965   /* Re-encrypt packet */
1966   silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p, p.len);
1967
1968   /* Send the packet */
1969   silc_server_packet_send_real(server, dst_sock, force_send);
1970
1971   silc_buffer_pull(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1972                    + packet->dst_id_len + packet->padlen);
1973
1974   /* Check for mandatory rekey */
1975   if (sequence == SILC_SERVER_REKEY_THRESHOLD)
1976     silc_schedule_task_add(server->schedule, dst_sock->sock,
1977                            silc_server_rekey_callback, dst_sock, 0, 1,
1978                            SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
1979 }
1980
1981 /* Routine used to send the connection authentication packet. */
1982
1983 void silc_server_send_connection_auth_request(SilcServer server,
1984                                               SilcSocketConnection sock,
1985                                               SilcUInt16 conn_type,
1986                                               SilcAuthMethod auth_meth)
1987 {
1988   SilcBuffer packet;
1989
1990   packet = silc_buffer_alloc(4);
1991   silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1992   silc_buffer_format(packet,
1993                      SILC_STR_UI_SHORT(conn_type),
1994                      SILC_STR_UI_SHORT(auth_meth),
1995                      SILC_STR_END);
1996
1997   silc_server_packet_send(server, sock, SILC_PACKET_CONNECTION_AUTH_REQUEST,
1998                           0, packet->data, packet->len, FALSE);
1999   silc_buffer_free(packet);
2000 }
2001
2002 /* Purge the outgoing packet queue to the network if there is data. This
2003    function can be used to empty the packet queue. It is guaranteed that
2004    after this function returns the outgoing data queue is empty. */
2005
2006 void silc_server_packet_queue_purge(SilcServer server,
2007                                     SilcSocketConnection sock)
2008 {
2009   if (sock && SILC_IS_OUTBUF_PENDING(sock) &&
2010       !(SILC_IS_DISCONNECTING(sock)) && !(SILC_IS_DISCONNECTED(sock))) {
2011     SILC_LOG_DEBUG(("Purging outgoing queue"));
2012     server->stat.packets_sent++;
2013     silc_packet_send(sock, TRUE);
2014     SILC_UNSET_OUTBUF_PENDING(sock);
2015     SILC_SET_CONNECTION_FOR_INPUT(server->schedule, sock->sock);
2016     silc_buffer_clear(sock->outbuf);
2017   }
2018 }
2019
2020 /* Send packet to clients that are known to be operators.  If server
2021    is router and `route' is TRUE then the packet would go to all operators
2022    in the SILC network.  If `route' is FALSE then only local operators
2023    (local for server and cell wide for router).  If `local' is TRUE then
2024    only locally connected operators receive the packet.  If `local' is
2025    TRUE then `route' is ignored.  If server is normal server and `route'
2026    is FALSE it is equivalent to `local' being TRUE. */
2027
2028 void silc_server_send_opers(SilcServer server,
2029                             SilcPacketType type,
2030                             SilcPacketFlags flags,
2031                             bool route, bool local,
2032                             unsigned char *data,
2033                             SilcUInt32 data_len,
2034                             bool force_send)
2035 {
2036   SilcIDCacheList list = NULL;
2037   SilcIDCacheEntry id_cache = NULL;
2038   SilcClientEntry client = NULL;
2039   SilcSocketConnection sock;
2040   SilcServerEntry *routed = NULL;
2041   SilcUInt32 routed_count = 0;
2042   bool gone = FALSE;
2043   int k;
2044
2045   SILC_LOG_DEBUG(("Sending %s packet to operators",
2046                   silc_get_packet_name(type)));
2047
2048   /* If local was requested send only locally connected operators. */
2049   if (local || (server->server_type == SILC_SERVER && !route)) {
2050     if (!silc_idcache_get_all(server->local_list->clients, &list) ||
2051         !silc_idcache_list_first(list, &id_cache))
2052       return;
2053     while (id_cache) {
2054       client = (SilcClientEntry)id_cache->context;
2055       if (!client->router && SILC_IS_LOCAL(client) &&
2056           (client->mode & SILC_UMODE_SERVER_OPERATOR ||
2057            client->mode & SILC_UMODE_ROUTER_OPERATOR)) {
2058
2059         /* Send the packet to locally connected operator */
2060         silc_server_packet_send_dest(server, client->connection, type, flags,
2061                                      client->id, SILC_ID_CLIENT,
2062                                      data, data_len, force_send);
2063       }
2064
2065       if (!silc_idcache_list_next(list, &id_cache))
2066         break;
2067     }
2068     silc_idcache_list_free(list);
2069     return;
2070   }
2071
2072   if (!silc_idcache_get_all(server->local_list->clients, &list) ||
2073       !silc_idcache_list_first(list, &id_cache))
2074     return;
2075   while (id_cache) {
2076     client = (SilcClientEntry)id_cache->context;
2077     if (!(client->mode & SILC_UMODE_SERVER_OPERATOR) &&
2078         !(client->mode & SILC_UMODE_ROUTER_OPERATOR))
2079       goto next;
2080
2081     if (server->server_type != SILC_SERVER && client->router &&
2082         ((!route && client->router->router == server->id_entry) || route)) {
2083
2084       /* Check if we have sent the packet to this route already */
2085       for (k = 0; k < routed_count; k++)
2086         if (routed[k] == client->router)
2087           break;
2088       if (k < routed_count)
2089         goto next;
2090
2091       /* Route only once to router */
2092       sock = (SilcSocketConnection)client->router->connection;
2093       if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
2094         if (gone)
2095           goto next;
2096         gone = TRUE;
2097       }
2098
2099       /* Send the packet */
2100       silc_server_packet_send_dest(server, sock, type, flags,
2101                                    client->id, SILC_ID_CLIENT,
2102                                    data, data_len, force_send);
2103
2104       /* Mark this route routed already */
2105       routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
2106       routed[routed_count++] = client->router;
2107       goto next;
2108     }
2109
2110     if (client->router || !client->connection)
2111       goto next;
2112
2113     /* Send to locally connected client */
2114     sock = (SilcSocketConnection)client->connection;
2115     silc_server_packet_send_dest(server, sock, type, flags,
2116                                  client->id, SILC_ID_CLIENT,
2117                                  data, data_len, force_send);
2118
2119   next:
2120     if (!silc_idcache_list_next(list, &id_cache))
2121       break;
2122   }
2123   silc_idcache_list_free(list);
2124
2125   if (!silc_idcache_get_all(server->global_list->clients, &list) ||
2126       !silc_idcache_list_first(list, &id_cache))
2127     return;
2128   while (id_cache) {
2129     client = (SilcClientEntry)id_cache->context;
2130     if (!(client->mode & SILC_UMODE_SERVER_OPERATOR) &&
2131         !(client->mode & SILC_UMODE_ROUTER_OPERATOR))
2132       goto nextg;
2133
2134     if (server->server_type != SILC_SERVER && client->router &&
2135         ((!route && client->router->router == server->id_entry) || route)) {
2136
2137       /* Check if we have sent the packet to this route already */
2138       for (k = 0; k < routed_count; k++)
2139         if (routed[k] == client->router)
2140           break;
2141       if (k < routed_count)
2142         goto nextg;
2143
2144       /* Route only once to router */
2145       sock = (SilcSocketConnection)client->router->connection;
2146       if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
2147         if (gone)
2148           goto nextg;
2149         gone = TRUE;
2150       }
2151
2152       /* Send the packet */
2153       silc_server_packet_send_dest(server, sock, type, flags,
2154                                    client->id, SILC_ID_CLIENT,
2155                                    data, data_len, force_send);
2156
2157       /* Mark this route routed already */
2158       routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
2159       routed[routed_count++] = client->router;
2160       goto nextg;
2161     }
2162
2163     if (client->router || !client->connection)
2164       goto nextg;
2165
2166     /* Send to locally connected client */
2167     sock = (SilcSocketConnection)client->connection;
2168     silc_server_packet_send_dest(server, sock, type, flags,
2169                                  client->id, SILC_ID_CLIENT,
2170                                  data, data_len, force_send);
2171
2172   nextg:
2173     if (!silc_idcache_list_next(list, &id_cache))
2174       break;
2175   }
2176   silc_idcache_list_free(list);
2177   silc_free(routed);
2178 }
2179
2180 /* Send a notify packet to operators */
2181
2182 void silc_server_send_opers_notify(SilcServer server,
2183                                    bool route,
2184                                    bool local,
2185                                    SilcNotifyType type,
2186                                    SilcUInt32 argc, ...)
2187 {
2188   va_list ap;
2189   SilcBuffer packet;
2190
2191   va_start(ap, argc);
2192   packet = silc_notify_payload_encode(type, argc, ap);
2193   silc_server_send_opers(server, SILC_PACKET_NOTIFY, 0,
2194                          route, local, packet->data, packet->len,
2195                          FALSE);
2196   silc_buffer_free(packet);
2197   va_end(ap);
2198 }