apps/silcd/packet_send.c

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