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     silc_server_packet_send_dest(server, sock, type, flags,
 448                                  client->id, SILC_ID_CLIENT,
 449                                  data, data_len, force_send);
 450   }
 451
 452   silc_free(routed);
 453 }
 454
 455 /* Internal routine to actually create the channel packet and send it
 456    to network. This is common function in channel message sending. If
 457    `channel_message' is TRUE this encrypts the message as it is strictly
 458    a channel message. If FALSE normal encryption process is used. */
 459
 460 static void
 461 silc_server_packet_send_to_channel_real(SilcServer server,
 462                                         SilcSocketConnection sock,
 463                                         SilcPacketContext *packet,
 464                                         SilcCipher cipher,
 465                                         SilcHmac hmac,
 466                                         SilcUInt32 sequence,
 467                                         unsigned char *data,
 468                                         SilcUInt32 data_len,
 469                                         bool channel_message,
 470                                         bool force_send)
 471 {
 472   int block_len;
 473   const SilcBufferStruct p;
 474
 475   if (!sock)
 476     return;
 477
 478   data_len = SILC_PACKET_DATALEN(data_len, (SILC_PACKET_HEADER_LEN +
 479                                             packet->src_id_len +
 480                                             packet->dst_id_len));
 481   packet->truelen = data_len + SILC_PACKET_HEADER_LEN +
 482     packet->src_id_len + packet->dst_id_len;
 483
 484   block_len = cipher ? silc_cipher_get_block_len(cipher) : 0;
 485   if (channel_message)
 486     packet->padlen = SILC_PACKET_PADLEN((SILC_PACKET_HEADER_LEN +
 487                                          packet->src_id_len +
 488                                          packet->dst_id_len), block_len);
 489   else
 490     packet->padlen = SILC_PACKET_PADLEN(packet->truelen, block_len);
 491
 492   /* Put the data to buffer, assemble and encrypt the packet. The packet
 493      is encrypted with normal session key shared with the client, unless
 494      the `channel_message' is TRUE. */
 495   if (!silc_packet_assemble(packet, NULL, cipher, hmac, sock, data,
 496                             data_len, (const SilcBuffer)&p)) {
 497     SILC_LOG_ERROR(("Cannot assemble packet"));
 498     return;
 499   }
 500
 501   if (channel_message)
 502     silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p,
 503                         SILC_PACKET_HEADER_LEN + packet->src_id_len +
 504                         packet->dst_id_len + packet->padlen);
 505   else
 506     silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p, p.len);
 507
 508   SILC_LOG_HEXDUMP(("Channel packet (%d), len %d", sequence, p.len),
 509                    p.data, p.len);
 510
 511   /* Now actually send the packet */
 512   silc_server_packet_send_real(server, sock, force_send);
 513 }
 514
 515 /* This routine is used by the server to send packets to channel. The
 516    packet sent with this function is distributed to all clients on
 517    the channel. Usually this is used to send notify messages to the
 518    channel, things like notify about new user joining to the channel.
 519    If `route' is FALSE then the packet is sent only locally and will not
 520    be routed anywhere (for router locally means cell wide). If `sender'
 521    is provided then the packet is not sent to that connection since it
 522    originally came from it. If `send_to_clients' is FALSE then the
 523    packet is not sent clients, only servers. */
 524
 525 void silc_server_packet_send_to_channel(SilcServer server,
 526                                         SilcSocketConnection sender,
 527                                         SilcChannelEntry channel,
 528                                         SilcPacketType type,
 529                                         bool route,
 530                                         unsigned char *data,
 531                                         SilcUInt32 data_len,
 532                                         bool force_send)
 533 {
 534   SilcSocketConnection sock = NULL;
 535   SilcPacketContext packetdata;
 536   SilcClientEntry client = NULL;
 537   SilcServerEntry *routed = NULL;
 538   SilcChannelClientEntry chl;
 539   SilcHashTableList htl;
 540   SilcIDListData idata;
 541   SilcUInt32 routed_count = 0;
 542   bool gone = FALSE;
 543   int k;
 544
 545   /* This doesn't send channel message packets */
 546   assert(type != SILC_PACKET_CHANNEL_MESSAGE);
 547
 548   SILC_LOG_DEBUG(("Sending packet to channel"));
 549
 550   /* Set the packet context pointers. */
 551   packetdata.flags = 0;
 552   packetdata.type = type;
 553   packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
 554   packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
 555   packetdata.src_id_type = SILC_ID_SERVER;
 556   packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
 557   packetdata.dst_id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
 558   packetdata.dst_id_type = SILC_ID_CHANNEL;
 559
 560   /* If there are global users in the channel we will send the message
 561      first to our router for further routing. */
 562   if (route && server->server_type != SILC_ROUTER && !server->standalone &&
 563       channel->global_users) {
 564     SilcServerEntry router;
 565
 566     /* Get data used in packet header encryption, keys and stuff. */
 567     router = server->router;
 568     sock = (SilcSocketConnection)router->connection;
 569     idata = (SilcIDListData)router;
 570
 571     if (sock != sender) {
 572       SILC_LOG_DEBUG(("Sending packet to router for routing"));
 573
 574       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 575                                               idata->send_key,
 576                                               idata->hmac_send,
 577                                               idata->psn_send++,
 578                                               data, data_len, FALSE,
 579                                               force_send);
 580     }
 581   }
 582
 583   routed = silc_calloc(silc_hash_table_count(channel->user_list),
 584                        sizeof(*routed));
 585
 586   /* Send the message to clients on the channel's client list. */
 587   silc_hash_table_list(channel->user_list, &htl);
 588   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
 589     client = chl->client;
 590     if (!client)
 591       continue;
 592
 593     /* If client has router set it is not locally connected client and
 594        we will route the message to the router set in the client. Though,
 595        send locally connected server in all cases. */
 596     if (server->server_type == SILC_ROUTER && client->router &&
 597         ((!route && client->router->router == server->id_entry) || route)) {
 598
 599       /* Check if we have sent the packet to this route already */
 600       for (k = 0; k < routed_count; k++)
 601         if (routed[k] == client->router)
 602           break;
 603       if (k < routed_count)
 604         continue;
 605
 606       /* Get data used in packet header encryption, keys and stuff. */
 607       sock = (SilcSocketConnection)client->router->connection;
 608       idata = (SilcIDListData)client->router;
 609
 610       if (sender && sock == sender)
 611         continue;
 612
 613       /* Route only once to router. Protocol prohibits sending channel
 614          messages to more than one router. */
 615       if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
 616         if (gone)
 617           continue;
 618         gone = TRUE;
 619       }
 620
 621       /* Send the packet */
 622       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 623                                               idata->send_key,
 624                                               idata->hmac_send,
 625                                               idata->psn_send++,
 626                                               data, data_len, FALSE,
 627                                               force_send);
 628
 629       /* Mark this route routed already */
 630       routed[routed_count++] = client->router;
 631       continue;
 632     }
 633
 634     if (client->router)
 635       continue;
 636
 637     /* Send to locally connected client */
 638
 639     /* Get data used in packet header encryption, keys and stuff. */
 640     sock = (SilcSocketConnection)client->connection;
 641     idata = (SilcIDListData)client;
 642
 643     if (!sock || (sender && sock == sender))
 644       continue;
 645
 646     /* Send the packet */
 647     silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 648                                             idata->send_key,
 649                                             idata->hmac_send,
 650                                             idata->psn_send++,
 651                                             data, data_len, FALSE,
 652                                             force_send);
 653   }
 654
 655   silc_hash_table_list_reset(&htl);
 656   silc_free(routed);
 657   silc_free(packetdata.src_id);
 658   silc_free(packetdata.dst_id);
 659 }
 660
 661 /* This checks whether the relayed packet came from router. If it did
 662    then we'll need to encrypt it with the channel key. This is called
 663    from the silc_server_packet_relay_to_channel. */
 664
 665 static bool
 666 silc_server_packet_relay_to_channel_encrypt(SilcServer server,
 667                                             SilcSocketConnection sock,
 668                                             SilcChannelEntry channel,
 669                                             unsigned char *data,
 670                                             unsigned int data_len)
 671 {
 672   /* If we are router and the packet came from router and private key
 673      has not been set for the channel then we must encrypt the packet
 674      as it was decrypted with the session key shared between us and the
 675      router which sent it. This is so, because cells does not share the
 676      same channel key. */
 677   if (server->server_type == SILC_ROUTER &&
 678       sock->type == SILC_SOCKET_TYPE_ROUTER &&
 679       !(channel->mode & SILC_CHANNEL_MODE_PRIVKEY) &&
 680       channel->channel_key) {
 681     SilcUInt32 mac_len = silc_hmac_len(channel->hmac);
 682     SilcUInt32 iv_len = silc_cipher_get_block_len(channel->channel_key);
 683
 684     if (data_len <= mac_len + iv_len) {
 685       SILC_LOG_WARNING(("Corrupted channel message, cannot relay it"));
 686       return FALSE;
 687     }
 688
 689     memcpy(channel->iv, data + (data_len - iv_len), iv_len);
 690     silc_channel_message_payload_encrypt(data, data_len - iv_len - mac_len,
 691                                          data_len, channel->iv, iv_len,
 692                                          channel->channel_key, channel->hmac);
 693   }
 694
 695   return TRUE;
 696 }
 697
 698 /* This routine is explicitly used to relay messages to some channel.
 699    Packets sent with this function we have received earlier and are
 700    totally encrypted. This just sends the packet to all clients on
 701    the channel. If the sender of the packet is someone on the channel
 702    the message will not be sent to that client. The SILC Packet header
 703    is encrypted with the session key shared between us and the client.
 704    MAC is also computed before encrypting the header. Rest of the
 705    packet will be untouched. */
 706
 707 void silc_server_packet_relay_to_channel(SilcServer server,
 708                                          SilcSocketConnection sender_sock,
 709                                          SilcChannelEntry channel,
 710                                          void *sender_id,
 711                                          SilcIdType sender_type,
 712                                          SilcClientEntry sender_entry,
 713                                          unsigned char *data,
 714                                          SilcUInt32 data_len,
 715                                          bool force_send)
 716 {
 717   SilcSocketConnection sock = NULL;
 718   SilcPacketContext packetdata;
 719   SilcClientEntry client = NULL;
 720   SilcServerEntry *routed = NULL;
 721   SilcChannelClientEntry chl;
 722   SilcUInt32 routed_count = 0;
 723   SilcIDListData idata;
 724   SilcHashTableList htl;
 725   bool gone = FALSE;
 726   int k;
 727
 728   SILC_LOG_DEBUG(("Relaying packet to channel"));
 729
 730   /* This encrypts the packet, if needed. It will be encrypted if
 731      it came from the router thus it needs to be encrypted with the
 732      channel key. If the channel key does not exist, then we know we
 733      don't have a single local user on the channel. */
 734   if (!silc_server_packet_relay_to_channel_encrypt(server, sender_sock,
 735                                                    channel, data,
 736                                                    data_len))
 737     return;
 738
 739   /* Set the packet context pointers. */
 740   packetdata.flags = 0;
 741   packetdata.type = SILC_PACKET_CHANNEL_MESSAGE;
 742   packetdata.src_id = silc_id_id2str(sender_id, sender_type);
 743   packetdata.src_id_len = silc_id_get_len(sender_id, sender_type);
 744   packetdata.src_id_type = sender_type;
 745   packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
 746   packetdata.dst_id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
 747   packetdata.dst_id_type = SILC_ID_CHANNEL;
 748
 749   /* If there are global users in the channel we will send the message
 750      first to our router for further routing. */
 751   if (server->server_type != SILC_ROUTER && !server->standalone &&
 752       channel->global_users) {
 753     SilcServerEntry router = server->router;
 754
 755     /* Check that the sender is not our router. */
 756     if (sender_sock != (SilcSocketConnection)router->connection) {
 757
 758       /* Get data used in packet header encryption, keys and stuff. */
 759       sock = (SilcSocketConnection)router->connection;
 760       idata = (SilcIDListData)router;
 761
 762       SILC_LOG_DEBUG(("Sending channel message to router for routing"));
 763
 764       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 765                                               idata->send_key,
 766                                               idata->hmac_send,
 767                                               idata->psn_send++,
 768                                               data, data_len, TRUE,
 769                                               force_send);
 770     }
 771   }
 772
 773   routed = silc_calloc(silc_hash_table_count(channel->user_list),
 774                        sizeof(*routed));
 775
 776   /* Assure we won't route the message back to the sender's way. */
 777   if (sender_entry->router)
 778     routed[routed_count++] = sender_entry->router;
 779
 780   /* Send the message to clients on the channel's client list. */
 781   silc_hash_table_list(channel->user_list, &htl);
 782   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
 783     client = chl->client;
 784     if (!client || client == sender_entry ||
 785         chl->mode & SILC_CHANNEL_UMODE_BLOCK_MESSAGES)
 786       continue;
 787
 788     /* If the client has set router it means that it is not locally
 789        connected client and we will route the packet further. */
 790     if (server->server_type == SILC_ROUTER && client->router) {
 791
 792       /* Check if we have sent the packet to this route already */
 793       for (k = 0; k < routed_count; k++)
 794         if (routed[k] == client->router)
 795           break;
 796       if (k < routed_count)
 797         continue;
 798
 799       /* Get data used in packet header encryption, keys and stuff. */
 800       sock = (SilcSocketConnection)client->router->connection;
 801       idata = (SilcIDListData)client->router;
 802
 803       /* Check if the sender socket is the same as this client's router
 804          socket. */
 805       if (sender_sock && sock == sender_sock)
 806         continue;
 807
 808       SILC_LOG_DEBUG(("Relaying packet to client ID(%s) %s (%s)",
 809                       silc_id_render(client->id, SILC_ID_CLIENT),
 810                       sock->hostname, sock->ip));
 811
 812       /* Mark this route routed already. */
 813       routed[routed_count++] = client->router;
 814
 815       if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
 816         /* The remote connection is router then we'll decrypt the
 817            channel message and re-encrypt it with the session key shared
 818            between us and the remote router. This is done because the
 819            channel keys are cell specific and we have different channel
 820            key than the remote router has. */
 821
 822         /* Route only once to router. Protocol prohibits sending channel
 823            messages to more than one router. */
 824         if (gone)
 825           continue;
 826         gone = TRUE;
 827
 828         SILC_LOG_DEBUG(("Remote is router, encrypt with session key"));
 829
 830         /* If private key mode is not set then decrypt the packet
 831            and re-encrypt it */
 832         if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY) &&
 833             channel->channel_key) {
 834           unsigned char tmp[SILC_PACKET_MAX_LEN];
 835
 836           if (data_len > SILC_PACKET_MAX_LEN)
 837             data_len = SILC_PACKET_MAX_LEN;
 838           memcpy(tmp, data, data_len);
 839
 840           /* Decrypt the channel message (we don't check the MAC) */
 841           silc_channel_message_payload_decrypt(tmp, data_len,
 842                                                channel->channel_key, NULL);
 843
 844           /* Now re-encrypt and send it to the router */
 845           silc_server_packet_send_srcdest(server, sock,
 846                                           SILC_PACKET_CHANNEL_MESSAGE, 0,
 847                                           sender_id, sender_type,
 848                                           channel->id, SILC_ID_CHANNEL,
 849                                           tmp, data_len, force_send);
 850         } else {
 851           /* Private key mode is set, we don't have the channel key, so
 852              just re-encrypt the entire packet and send it to the router. */
 853           silc_server_packet_send_srcdest(server, sock,
 854                                           SILC_PACKET_CHANNEL_MESSAGE, 0,
 855                                           sender_id, sender_type,
 856                                           channel->id, SILC_ID_CHANNEL,
 857                                           data, data_len, force_send);
 858         }
 859       } else {
 860         /* Send the packet to normal server */
 861         silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 862                                                 idata->send_key,
 863                                                 idata->hmac_send,
 864                                                 idata->psn_send++,
 865                                                 data, data_len, TRUE,
 866                                                 force_send);
 867       }
 868
 869       continue;
 870     }
 871
 872     if (client->router)
 873       continue;
 874
 875     /* Get data used in packet header encryption, keys and stuff. */
 876     sock = (SilcSocketConnection)client->connection;
 877     idata = (SilcIDListData)client;
 878
 879     if (!sock || (sender_sock && sock == sender_sock))
 880       continue;
 881
 882     SILC_LOG_DEBUG(("Sending packet to client ID(%s) %s (%s)",
 883                     silc_id_render(client->id, SILC_ID_CLIENT),
 884                     sock->hostname, sock->ip));
 885
 886     /* Send the packet */
 887     silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 888                                             idata->send_key,
 889                                             idata->hmac_send,
 890                                             idata->psn_send++,
 891                                             data, data_len, TRUE,
 892                                             force_send);
 893   }
 894
 895   silc_hash_table_list_reset(&htl);
 896   silc_free(routed);
 897   silc_free(packetdata.src_id);
 898   silc_free(packetdata.dst_id);
 899 }
 900
 901 /* This function is used to send packets strictly to all local clients
 902    on a particular channel.  This is used for example to distribute new
 903    channel key to all our locally connected clients on the channel.
 904    The packets are always encrypted with the session key shared between
 905    the client, this means these are not _to the channel_ but _to the client_
 906    on the channel. */
 907
 908 void silc_server_packet_send_local_channel(SilcServer server,
 909                                            SilcChannelEntry channel,
 910                                            SilcPacketType type,
 911                                            SilcPacketFlags flags,
 912                                            unsigned char *data,
 913                                            SilcUInt32 data_len,
 914                                            bool force_send)
 915 {
 916   SilcChannelClientEntry chl;
 917   SilcHashTableList htl;
 918   SilcSocketConnection sock = NULL;
 919
 920   SILC_LOG_DEBUG(("Start"));
 921
 922   /* Send the message to clients on the channel's client list. */
 923   silc_hash_table_list(channel->user_list, &htl);
 924   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
 925     if (chl->client && !chl->client->router) {
 926       sock = (SilcSocketConnection)chl->client->connection;
 927
 928       /* Send the packet to the client */
 929       silc_server_packet_send_dest(server, sock, type, flags, chl->client->id,
 930                                    SILC_ID_CLIENT, data, data_len,
 931                                    force_send);
 932     }
 933   }
 934   silc_hash_table_list_reset(&htl);
 935 }
 936
 937 /* Routine used to send (relay, route) private messages to some destination.
 938    If the private message key does not exist then the message is re-encrypted,
 939    otherwise we just pass it along. This really is not used to send new
 940    private messages (as server does not send them) but to relay received
 941    private messages. */
 942
 943 void silc_server_send_private_message(SilcServer server,
 944                                       SilcSocketConnection dst_sock,
 945                                       SilcCipher cipher,
 946                                       SilcHmac hmac,
 947                                       SilcUInt32 sequence,
 948                                       SilcPacketContext *packet)
 949 {
 950   SilcBuffer buffer = packet->buffer;
 951   const SilcBufferStruct p;
 952
 953   silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
 954                    + packet->dst_id_len + packet->padlen);
 955   if (!silc_packet_send_prepare(dst_sock, 0, 0, buffer->len, hmac,
 956                                 (const SilcBuffer)&p)) {
 957     SILC_LOG_ERROR(("Cannot send packet"));
 958     return;
 959   }
 960   silc_buffer_put((SilcBuffer)&p, buffer->data, buffer->len);
 961
 962   /* Re-encrypt and send if private messge key does not exist */
 963   if (!(packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY)) {
 964     /* Re-encrypt packet */
 965     silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p, buffer->len);
 966   } else {
 967     /* Key exist so encrypt just header and send it */
 968     silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p,
 969                         SILC_PACKET_HEADER_LEN + packet->src_id_len +
 970                         packet->dst_id_len + packet->padlen);
 971   }
 972
 973   /* Send the packet */
 974   silc_server_packet_send_real(server, dst_sock, FALSE);
 975 }
 976
 977 /* Sends current motd to client */
 978
 979 void silc_server_send_motd(SilcServer server,
 980                            SilcSocketConnection sock)
 981 {
 982   char *motd, *motd_file = NULL;
 983   SilcUInt32 motd_len;
 984
 985   if (server->config)
 986     motd_file = server->config->server_info->motd_file;
 987
 988   if (motd_file) {
 989     motd = silc_file_readfile(motd_file, &motd_len);
 990     if (!motd)
 991       return;
 992
 993     silc_server_send_notify(server, sock, FALSE, SILC_NOTIFY_TYPE_MOTD, 1,
 994                             motd, motd_len);
 995     silc_free(motd);
 996   }
 997 }
 998
 999 /* Sends error message. Error messages may or may not have any
1000    implications. */
1001
1002 void silc_server_send_error(SilcServer server,
1003                             SilcSocketConnection sock,
1004                             const char *fmt, ...)
1005 {
1006   va_list ap;
1007   unsigned char buf[4096];
1008
1009   memset(buf, 0, sizeof(buf));
1010   va_start(ap, fmt);
1011   vsprintf(buf, fmt, ap);
1012   va_end(ap);
1013
1014   silc_server_packet_send(server, sock, SILC_PACKET_ERROR, 0,
1015                           buf, strlen(buf), FALSE);
1016 }
1017
1018 /* Sends notify message. If format is TRUE the variable arguments are
1019    formatted and the formatted string is sent as argument payload. If it is
1020    FALSE then each argument is sent as separate argument and their format
1021    in the argument list must be { argument data, argument length }. */
1022
1023 void silc_server_send_notify(SilcServer server,
1024                              SilcSocketConnection sock,
1025                              bool broadcast,
1026                              SilcNotifyType type,
1027                              SilcUInt32 argc, ...)
1028 {
1029   va_list ap;
1030   SilcBuffer packet;
1031
1032   va_start(ap, argc);
1033
1034   packet = silc_notify_payload_encode(type, argc, ap);
1035   silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
1036                           broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1037                           packet->data, packet->len, FALSE);
1038
1039   /* Send to backup routers if this is being broadcasted to primary
1040      router. */
1041   if (server->router && server->router->connection &&
1042       sock == server->router->connection && broadcast)
1043     silc_server_backup_send(server, NULL, SILC_PACKET_NOTIFY, 0,
1044                             packet->data, packet->len, FALSE, TRUE);
1045
1046   silc_buffer_free(packet);
1047   va_end(ap);
1048 }
1049
1050 /* Sends notify message and gets the arguments from the `args' Argument
1051    Payloads. */
1052
1053 void silc_server_send_notify_args(SilcServer server,
1054                                   SilcSocketConnection sock,
1055                                   bool broadcast,
1056                                   SilcNotifyType type,
1057                                   SilcUInt32 argc,
1058                                   SilcBuffer args)
1059 {
1060   SilcBuffer packet;
1061
1062   packet = silc_notify_payload_encode_args(type, argc, args);
1063   silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
1064                           broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1065                           packet->data, packet->len, FALSE);
1066   silc_buffer_free(packet);
1067 }
1068
1069 /* Send CHANNEL_CHANGE notify type. This tells the receiver to replace the
1070    `old_id' with the `new_id'. */
1071
1072 void silc_server_send_notify_channel_change(SilcServer server,
1073                                             SilcSocketConnection sock,
1074                                             bool broadcast,
1075                                             SilcChannelID *old_id,
1076                                             SilcChannelID *new_id)
1077 {
1078   SilcBuffer idp1, idp2;
1079
1080   idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CHANNEL);
1081   idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CHANNEL);
1082
1083   silc_server_send_notify(server, sock, broadcast,
1084                           SILC_NOTIFY_TYPE_CHANNEL_CHANGE,
1085                           2, idp1->data, idp1->len, idp2->data, idp2->len);
1086   silc_buffer_free(idp1);
1087   silc_buffer_free(idp2);
1088 }
1089
1090 /* Send NICK_CHANGE notify type. This tells the receiver to replace the
1091    `old_id' with the `new_id'. */
1092
1093 void silc_server_send_notify_nick_change(SilcServer server,
1094                                          SilcSocketConnection sock,
1095                                          bool broadcast,
1096                                          SilcClientID *old_id,
1097                                          SilcClientID *new_id,
1098                                          const char *nickname)
1099 {
1100   SilcBuffer idp1, idp2;
1101
1102   idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CLIENT);
1103   idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CLIENT);
1104
1105   silc_server_send_notify(server, sock, broadcast,
1106                           SILC_NOTIFY_TYPE_NICK_CHANGE,
1107                           3, idp1->data, idp1->len, idp2->data, idp2->len,
1108                           nickname, nickname ? strlen(nickname) : 0);
1109   silc_buffer_free(idp1);
1110   silc_buffer_free(idp2);
1111 }
1112
1113 /* Sends JOIN notify type. This tells that new client by `client_id' ID
1114    has joined to the `channel'. */
1115
1116 void silc_server_send_notify_join(SilcServer server,
1117                                   SilcSocketConnection sock,
1118                                   bool broadcast,
1119                                   SilcChannelEntry channel,
1120                                   SilcClientID *client_id)
1121 {
1122   SilcBuffer idp1, idp2;
1123
1124   idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1125   idp2 = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1126   silc_server_send_notify(server, sock, broadcast, SILC_NOTIFY_TYPE_JOIN,
1127                           2, idp1->data, idp1->len,
1128                           idp2->data, idp2->len);
1129   silc_buffer_free(idp1);
1130   silc_buffer_free(idp2);
1131 }
1132
1133 /* Sends LEAVE notify type. This tells that `client_id' has left the
1134    `channel'. The Notify packet is always destined to the channel. */
1135
1136 void silc_server_send_notify_leave(SilcServer server,
1137                                    SilcSocketConnection sock,
1138                                    bool broadcast,
1139                                    SilcChannelEntry channel,
1140                                    SilcClientID *client_id)
1141 {
1142   SilcBuffer idp;
1143
1144   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1145   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1146                                SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_LEAVE,
1147                                1, idp->data, idp->len);
1148   silc_buffer_free(idp);
1149 }
1150
1151 /* Sends CMODE_CHANGE notify type. This tells that `client_id' changed the
1152    `channel' mode to `mode. The Notify packet is always destined to
1153    the channel. */
1154
1155 void silc_server_send_notify_cmode(SilcServer server,
1156                                    SilcSocketConnection sock,
1157                                    bool broadcast,
1158                                    SilcChannelEntry channel,
1159                                    SilcUInt32 mode_mask,
1160                                    void *id, SilcIdType id_type,
1161                                    char *cipher, char *hmac,
1162                                    char *passphrase)
1163 {
1164   SilcBuffer idp;
1165   unsigned char mode[4];
1166
1167   idp = silc_id_payload_encode((void *)id, id_type);
1168   SILC_PUT32_MSB(mode_mask, mode);
1169
1170   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1171                                SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_CMODE_CHANGE,
1172                                5, idp->data, idp->len,
1173                                mode, 4,
1174                                cipher, cipher ? strlen(cipher) : 0,
1175                                hmac, hmac ? strlen(hmac) : 0,
1176                                passphrase, passphrase ?
1177                                strlen(passphrase) : 0);
1178   silc_buffer_free(idp);
1179 }
1180
1181 /* Sends CUMODE_CHANGE notify type. This tells that `client_id' changed the
1182    `target' client's mode on `channel'. The notify packet is always
1183    destined to the channel. */
1184
1185 void silc_server_send_notify_cumode(SilcServer server,
1186                                     SilcSocketConnection sock,
1187                                     bool broadcast,
1188                                     SilcChannelEntry channel,
1189                                     SilcUInt32 mode_mask,
1190                                     void *id, SilcIdType id_type,
1191                                     SilcClientID *target)
1192 {
1193   SilcBuffer idp1, idp2;
1194   unsigned char mode[4];
1195
1196   idp1 = silc_id_payload_encode((void *)id, id_type);
1197   idp2 = silc_id_payload_encode((void *)target, SILC_ID_CLIENT);
1198   SILC_PUT32_MSB(mode_mask, mode);
1199
1200   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1201                                SILC_ID_CHANNEL,
1202                                SILC_NOTIFY_TYPE_CUMODE_CHANGE, 3,
1203                                idp1->data, idp1->len,
1204                                mode, 4,
1205                                idp2->data, idp2->len);
1206   silc_buffer_free(idp1);
1207   silc_buffer_free(idp2);
1208 }
1209
1210 /* Sends SIGNOFF notify type. This tells that `client_id' client has
1211    left SILC network. This function is used only between server and router
1212    traffic. This is not used to send the notify to the channel for
1213    client. The `message may be NULL. */
1214
1215 void silc_server_send_notify_signoff(SilcServer server,
1216                                      SilcSocketConnection sock,
1217                                      bool broadcast,
1218                                      SilcClientID *client_id,
1219                                      const char *message)
1220 {
1221   SilcBuffer idp;
1222
1223   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1224   silc_server_send_notify(server, sock, broadcast,
1225                           SILC_NOTIFY_TYPE_SIGNOFF,
1226                           message ? 2 : 1, idp->data, idp->len,
1227                           message, message ? strlen(message): 0);
1228   silc_buffer_free(idp);
1229 }
1230
1231 /* Sends TOPIC_SET notify type. This tells that `id' changed
1232    the `channel's topic to `topic'. The Notify packet is always destined
1233    to the channel. This function is used to send the topic set notifies
1234    between routers. */
1235
1236 void silc_server_send_notify_topic_set(SilcServer server,
1237                                        SilcSocketConnection sock,
1238                                        bool broadcast,
1239                                        SilcChannelEntry channel,
1240                                        void *id, SilcIdType id_type,
1241                                        char *topic)
1242 {
1243   SilcBuffer idp;
1244
1245   idp = silc_id_payload_encode(id, id_type);
1246   silc_server_send_notify_dest(server, sock, broadcast,
1247                                (void *)channel->id, SILC_ID_CHANNEL,
1248                                SILC_NOTIFY_TYPE_TOPIC_SET,
1249                                topic ? 2 : 1,
1250                                idp->data, idp->len,
1251                                topic, topic ? strlen(topic) : 0);
1252   silc_buffer_free(idp);
1253 }
1254
1255 /* Send KICKED notify type. This tells that the `client_id' on `channel'
1256    was kicked off the channel.  The `comment' may indicate the reason
1257    for the kicking. This function is used only between server and router
1258    traffic. */
1259
1260 void silc_server_send_notify_kicked(SilcServer server,
1261                                     SilcSocketConnection sock,
1262                                     bool broadcast,
1263                                     SilcChannelEntry channel,
1264                                     SilcClientID *client_id,
1265                                     SilcClientID *kicker,
1266                                     char *comment)
1267 {
1268   SilcBuffer idp1;
1269   SilcBuffer idp2;
1270
1271   idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1272   idp2 = silc_id_payload_encode((void *)kicker, SILC_ID_CLIENT);
1273   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1274                                SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_KICKED, 3,
1275                                idp1->data, idp1->len,
1276                                comment, comment ? strlen(comment) : 0,
1277                                idp2->data, idp2->len);
1278   silc_buffer_free(idp1);
1279   silc_buffer_free(idp2);
1280 }
1281
1282 /* Send KILLED notify type. This tells that the `client_id' client was
1283    killed from the network.  The `comment' may indicate the reason
1284    for the killing. */
1285
1286 void silc_server_send_notify_killed(SilcServer server,
1287                                     SilcSocketConnection sock,
1288                                     bool broadcast,
1289                                     SilcClientID *client_id,
1290                                     char *comment,
1291                                     SilcClientID *killer)
1292 {
1293   SilcBuffer idp1;
1294   SilcBuffer idp2;
1295
1296   idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1297   idp2 = silc_id_payload_encode((void *)killer, SILC_ID_CLIENT);
1298   silc_server_send_notify_dest(server, sock, broadcast, (void *)client_id,
1299                                SILC_ID_CLIENT, SILC_NOTIFY_TYPE_KILLED,
1300                                3, idp1->data, idp1->len,
1301                                comment, comment ? strlen(comment) : 0,
1302                                idp2->data, idp2->len);
1303   silc_buffer_free(idp1);
1304   silc_buffer_free(idp2);
1305 }
1306
1307 /* Sends UMODE_CHANGE notify type. This tells that `client_id' client's
1308    user mode in the SILC Network was changed. This function is used to
1309    send the packet between routers as broadcast packet. */
1310
1311 void silc_server_send_notify_umode(SilcServer server,
1312                                    SilcSocketConnection sock,
1313                                    bool broadcast,
1314                                    SilcClientID *client_id,
1315                                    SilcUInt32 mode_mask)
1316 {
1317   SilcBuffer idp;
1318   unsigned char mode[4];
1319
1320   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1321   SILC_PUT32_MSB(mode_mask, mode);
1322
1323   silc_server_send_notify(server, sock, broadcast,
1324                           SILC_NOTIFY_TYPE_UMODE_CHANGE, 2,
1325                           idp->data, idp->len,
1326                           mode, 4);
1327   silc_buffer_free(idp);
1328 }
1329
1330 /* Sends BAN notify type. This tells that ban has been either `add'ed
1331    or `del'eted on the `channel. This function is used to send the packet
1332    between routers as broadcast packet. */
1333
1334 void silc_server_send_notify_ban(SilcServer server,
1335                                  SilcSocketConnection sock,
1336                                  bool broadcast,
1337                                  SilcChannelEntry channel,
1338                                  char *add, char *del)
1339 {
1340   SilcBuffer idp;
1341
1342   idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1343   silc_server_send_notify(server, sock, broadcast,
1344                           SILC_NOTIFY_TYPE_BAN, 3,
1345                           idp->data, idp->len,
1346                           add, add ? strlen(add) : 0,
1347                           del, del ? strlen(del) : 0);
1348   silc_buffer_free(idp);
1349 }
1350
1351 /* Sends INVITE notify type. This tells that invite has been either `add'ed
1352    or `del'eted on the `channel.  The sender of the invite is the `client_id'.
1353    This function is used to send the packet between routers as broadcast
1354    packet. */
1355
1356 void silc_server_send_notify_invite(SilcServer server,
1357                                     SilcSocketConnection sock,
1358                                     bool broadcast,
1359                                     SilcChannelEntry channel,
1360                                     SilcClientID *client_id,
1361                                     char *add, char *del)
1362 {
1363   SilcBuffer idp, idp2;
1364
1365   idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1366   idp2 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1367   silc_server_send_notify(server, sock, broadcast,
1368                           SILC_NOTIFY_TYPE_INVITE, 5,
1369                           idp->data, idp->len,
1370                           channel->channel_name, strlen(channel->channel_name),
1371                           idp2->data, idp2->len,
1372                           add, add ? strlen(add) : 0,
1373                           del, del ? strlen(del) : 0);
1374   silc_buffer_free(idp);
1375   silc_buffer_free(idp2);
1376 }
1377
1378 /* Sends notify message destined to specific entity. */
1379
1380 void silc_server_send_notify_dest(SilcServer server,
1381                                   SilcSocketConnection sock,
1382                                   bool broadcast,
1383                                   void *dest_id,
1384                                   SilcIdType dest_id_type,
1385                                   SilcNotifyType type,
1386                                   SilcUInt32 argc, ...)
1387 {
1388   va_list ap;
1389   SilcBuffer packet;
1390
1391   va_start(ap, argc);
1392
1393   packet = silc_notify_payload_encode(type, argc, ap);
1394   silc_server_packet_send_dest(server, sock, SILC_PACKET_NOTIFY,
1395                                broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1396                                dest_id, dest_id_type,
1397                                packet->data, packet->len, FALSE);
1398   silc_buffer_free(packet);
1399   va_end(ap);
1400 }
1401
1402 /* Sends notify message to a channel. The notify message sent is
1403    distributed to all clients on the channel. If `route_notify' is TRUE
1404    then the notify may be routed to primary route or to some other routers.
1405    If FALSE it is assured that the notify is sent only locally. If `sender'
1406    is provided then the packet is not sent to that connection since it
1407    originally came from it. */
1408
1409 void silc_server_send_notify_to_channel(SilcServer server,
1410                                         SilcSocketConnection sender,
1411                                         SilcChannelEntry channel,
1412                                         bool route_notify,
1413                                         SilcNotifyType type,
1414                                         SilcUInt32 argc, ...)
1415 {
1416   va_list ap;
1417   SilcBuffer packet;
1418
1419   va_start(ap, argc);
1420
1421   packet = silc_notify_payload_encode(type, argc, ap);
1422   silc_server_packet_send_to_channel(server, sender, channel,
1423                                      SILC_PACKET_NOTIFY, route_notify,
1424                                      packet->data, packet->len, FALSE);
1425   silc_buffer_free(packet);
1426   va_end(ap);
1427 }
1428
1429 /* Send notify message to all channels the client has joined. It is quaranteed
1430    that the message is sent only once to a client (ie. if a client is joined
1431    on two same channel it will receive only one notify message). Also, this
1432    sends only to local clients (locally connected if we are server, and to
1433    local servers if we are router). If `sender' is provided the packet is
1434    not sent to that client at all. */
1435
1436 void silc_server_send_notify_on_channels(SilcServer server,
1437                                          SilcClientEntry sender,
1438                                          SilcClientEntry client,
1439                                          SilcNotifyType type,
1440                                          SilcUInt32 argc, ...)
1441 {
1442   int k;
1443   SilcSocketConnection sock = NULL;
1444   SilcPacketContext packetdata;
1445   SilcClientEntry c;
1446   SilcClientEntry *sent_clients = NULL;
1447   SilcUInt32 sent_clients_count = 0;
1448   SilcServerEntry *routed = NULL;
1449   SilcUInt32 routed_count = 0;
1450   SilcHashTableList htl, htl2;
1451   SilcChannelEntry channel;
1452   SilcChannelClientEntry chl, chl2;
1453   SilcIDListData idata;
1454   SilcBuffer packet;
1455   unsigned char *data;
1456   SilcUInt32 data_len;
1457   bool force_send = FALSE;
1458   va_list ap;
1459
1460   SILC_LOG_DEBUG(("Start"));
1461
1462   if (!silc_hash_table_count(client->channels))
1463     return;
1464
1465   va_start(ap, argc);
1466   packet = silc_notify_payload_encode(type, argc, ap);
1467   data = packet->data;
1468   data_len = packet->len;
1469
1470   /* Set the packet context pointers. */
1471   packetdata.flags = 0;
1472   packetdata.type = SILC_PACKET_NOTIFY;
1473   packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
1474   packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
1475   packetdata.src_id_type = SILC_ID_SERVER;
1476
1477   silc_hash_table_list(client->channels, &htl);
1478   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
1479     channel = chl->channel;
1480
1481     /* Send the message to all clients on the channel's client list. */
1482     silc_hash_table_list(channel->user_list, &htl2);
1483     while (silc_hash_table_get(&htl2, NULL, (void *)&chl2)) {
1484       c = chl2->client;
1485
1486       if (sender && c == sender)
1487         continue;
1488
1489       /* Check if we have sent the packet to this client already */
1490       for (k = 0; k < sent_clients_count; k++)
1491         if (sent_clients[k] == c)
1492           break;
1493       if (k < sent_clients_count)
1494         continue;
1495
1496       /* If we are router and if this client has router set it is not
1497          locally connected client and we will route the message to the
1498          router set in the client. */
1499       if (c && c->router && server->server_type == SILC_ROUTER) {
1500         /* Check if we have sent the packet to this route already */
1501         for (k = 0; k < routed_count; k++)
1502           if (routed[k] == c->router)
1503             break;
1504         if (k < routed_count)
1505           continue;
1506
1507         /* Get data used in packet header encryption, keys and stuff. */
1508         sock = (SilcSocketConnection)c->router->connection;
1509         idata = (SilcIDListData)c->router;
1510
1511         {
1512           SILC_LOG_DEBUG(("*****************"));
1513           SILC_LOG_DEBUG(("client->router->id %s",
1514                           silc_id_render(c->router->id, SILC_ID_SERVER)));
1515           SILC_LOG_DEBUG(("client->router->connection->user_data->id %s",
1516                           silc_id_render(((SilcServerEntry)sock->user_data)->id, SILC_ID_SERVER)));
1517         }
1518
1519         packetdata.dst_id = silc_id_id2str(c->router->id, SILC_ID_SERVER);
1520         packetdata.dst_id_len = silc_id_get_len(c->router->id, SILC_ID_SERVER);
1521         packetdata.dst_id_type = SILC_ID_SERVER;
1522
1523         /* Send the packet */
1524         silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1525                                                 idata->send_key,
1526                                                 idata->hmac_send,
1527                                                 idata->psn_send++,
1528                                                 data, data_len, FALSE,
1529                                                 force_send);
1530
1531         silc_free(packetdata.dst_id);
1532
1533         /* We want to make sure that the packet is routed to same router
1534            only once. Mark this route as sent route. */
1535         routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
1536         routed[routed_count++] = c->router;
1537         continue;
1538       }
1539
1540       if (c && c->router)
1541         continue;
1542
1543       /* Send to locally connected client */
1544       if (c) {
1545
1546         /* Get data used in packet header encryption, keys and stuff. */
1547         sock = (SilcSocketConnection)c->connection;
1548         idata = (SilcIDListData)c;
1549
1550         if (!sock)
1551           continue;
1552
1553         packetdata.dst_id = silc_id_id2str(c->id, SILC_ID_CLIENT);
1554         packetdata.dst_id_len = silc_id_get_len(c->id, SILC_ID_CLIENT);
1555         packetdata.dst_id_type = SILC_ID_CLIENT;
1556
1557         /* Send the packet */
1558         silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1559                                                 idata->send_key,
1560                                                 idata->hmac_send,
1561                                                 idata->psn_send++,
1562                                                 data, data_len, FALSE,
1563                                                 force_send);
1564
1565         silc_free(packetdata.dst_id);
1566
1567         /* Make sure that we send the notify only once per client. */
1568         sent_clients = silc_realloc(sent_clients, sizeof(*sent_clients) *
1569                                     (sent_clients_count + 1));
1570         sent_clients[sent_clients_count++] = c;
1571       }
1572     }
1573     silc_hash_table_list_reset(&htl2);
1574   }
1575
1576   silc_hash_table_list_reset(&htl);
1577   silc_free(routed);
1578   silc_free(sent_clients);
1579   silc_free(packetdata.src_id);
1580   silc_buffer_free(packet);
1581   va_end(ap);
1582 }
1583
1584 /* Sends New ID Payload to remote end. The packet is used to distribute
1585    information about new registered clients, servers, channel etc. usually
1586    to routers so that they can keep these information up to date.
1587    If the argument `broadcast' is TRUE then the packet is sent as
1588    broadcast packet. */
1589
1590 void silc_server_send_new_id(SilcServer server,
1591                              SilcSocketConnection sock,
1592                              bool broadcast,
1593                              void *id, SilcIdType id_type,
1594                              SilcUInt32 id_len)
1595 {
1596   SilcBuffer idp;
1597
1598   SILC_LOG_DEBUG(("Start"));
1599
1600   idp = silc_id_payload_encode(id, id_type);
1601   silc_server_packet_send(server, sock, SILC_PACKET_NEW_ID,
1602                           broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1603                           idp->data, idp->len, FALSE);
1604
1605   /* Send to backup routers if this is being broadcasted to primary
1606      router. */
1607   if (server->router && server->router->connection &&
1608       sock == server->router->connection && broadcast)
1609     silc_server_backup_send(server, NULL, SILC_PACKET_NEW_ID, 0,
1610                             idp->data, idp->len, FALSE, TRUE);
1611
1612   silc_buffer_free(idp);
1613 }
1614
1615 /* Send New Channel Payload to notify about newly created channel in the
1616    SILC network. Router uses this to notify other routers in the network
1617    about new channel. This packet is broadcasted by router. */
1618
1619 void silc_server_send_new_channel(SilcServer server,
1620                                   SilcSocketConnection sock,
1621                                   bool broadcast,
1622                                   char *channel_name,
1623                                   void *channel_id,
1624                                   SilcUInt32 channel_id_len,
1625                                   SilcUInt32 mode)
1626 {
1627   SilcBuffer packet;
1628   unsigned char *cid;
1629   SilcUInt32 name_len = strlen(channel_name);
1630
1631   SILC_LOG_DEBUG(("Start"));
1632
1633   cid = silc_id_id2str(channel_id, SILC_ID_CHANNEL);
1634   if (!cid)
1635     return;
1636
1637   /* Encode the channel payload */
1638   packet = silc_channel_payload_encode(channel_name, name_len,
1639                                        cid, channel_id_len, mode);
1640
1641   silc_server_packet_send(server, sock, SILC_PACKET_NEW_CHANNEL,
1642                           broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1643                           packet->data, packet->len, FALSE);
1644
1645   /* Send to backup routers if this is being broadcasted to primary
1646      router. */
1647   if (server->server_type == SILC_ROUTER &&
1648       server->router && server->router->connection &&
1649       sock == server->router->connection && broadcast)
1650     silc_server_backup_send(server, NULL, SILC_PACKET_NEW_CHANNEL, 0,
1651                             packet->data, packet->len, FALSE, TRUE);
1652
1653   silc_free(cid);
1654   silc_buffer_free(packet);
1655 }
1656
1657 /* Send Channel Key payload to distribute the new channel key. Normal server
1658    sends this to router when new client joins to existing channel. Router
1659    sends this to the local server who sent the join command in case where
1660    the channel did not exist yet. Both normal and router servers uses this
1661    also to send this to locally connected clients on the channel. This
1662    must not be broadcasted packet. Routers do not send this to each other.
1663    If `sender is provided then the packet is not sent to that connection since
1664    it originally came from it. */
1665
1666 void silc_server_send_channel_key(SilcServer server,
1667                                   SilcSocketConnection sender,
1668                                   SilcChannelEntry channel,
1669                                   unsigned char route)
1670 {
1671   SilcBuffer packet;
1672   unsigned char *chid;
1673   SilcUInt32 tmp_len;
1674
1675   SILC_LOG_DEBUG(("Sending key to channel %s", channel->channel_name));
1676
1677   chid = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
1678   if (!chid)
1679     return;
1680
1681   /* Encode channel key packet */
1682   tmp_len = strlen(channel->channel_key->cipher->name);
1683   packet = silc_channel_key_payload_encode(silc_id_get_len(channel->id,
1684                                                            SILC_ID_CHANNEL),
1685                                            chid, tmp_len,
1686                                            channel->channel_key->cipher->name,
1687                                            channel->key_len / 8, channel->key);
1688   silc_server_packet_send_to_channel(server, sender, channel,
1689                                      SILC_PACKET_CHANNEL_KEY,
1690                                      route, packet->data, packet->len,
1691                                      FALSE);
1692   silc_buffer_free(packet);
1693   silc_free(chid);
1694 }
1695
1696 /* Generic function to send any command. The arguments must be sent already
1697    encoded into correct form in correct order. */
1698
1699 void silc_server_send_command(SilcServer server,
1700                               SilcSocketConnection sock,
1701                               SilcCommand command,
1702                               SilcUInt16 ident,
1703                               SilcUInt32 argc, ...)
1704 {
1705   SilcBuffer packet;
1706   va_list ap;
1707
1708   va_start(ap, argc);
1709
1710   packet = silc_command_payload_encode_vap(command, ident, argc, ap);
1711   silc_server_packet_send(server, sock, SILC_PACKET_COMMAND, 0,
1712                           packet->data, packet->len, TRUE);
1713   silc_buffer_free(packet);
1714   va_end(ap);
1715 }
1716
1717 /* Generic function to send any command reply. The arguments must be sent
1718    already encoded into correct form in correct order. */
1719
1720 void silc_server_send_command_reply(SilcServer server,
1721                                     SilcSocketConnection sock,
1722                                     SilcCommand command,
1723                                     SilcCommandStatus status,
1724                                     SilcCommandStatus error,
1725                                     SilcUInt16 ident,
1726                                     SilcUInt32 argc, ...)
1727 {
1728   SilcBuffer packet;
1729   va_list ap;
1730
1731   va_start(ap, argc);
1732
1733   packet = silc_command_reply_payload_encode_vap(command, status, error,
1734                                                  ident, argc, ap);
1735   silc_server_packet_send(server, sock, SILC_PACKET_COMMAND_REPLY, 0,
1736                           packet->data, packet->len, TRUE);
1737   silc_buffer_free(packet);
1738   va_end(ap);
1739 }
1740
1741 /* Generic function to send any command reply. The arguments must be sent
1742    already encoded into correct form in correct order. */
1743
1744 void silc_server_send_dest_command_reply(SilcServer server,
1745                                          SilcSocketConnection sock,
1746                                          void *dst_id,
1747                                          SilcIdType dst_id_type,
1748                                          SilcCommand command,
1749                                          SilcCommandStatus status,
1750                                          SilcCommandStatus error,
1751                                          SilcUInt16 ident,
1752                                          SilcUInt32 argc, ...)
1753 {
1754   SilcBuffer packet;
1755   va_list ap;
1756
1757   va_start(ap, argc);
1758
1759   packet = silc_command_reply_payload_encode_vap(command, status, error,
1760                                                  ident, argc, ap);
1761   silc_server_packet_send_dest(server, sock, SILC_PACKET_COMMAND_REPLY, 0,
1762                                dst_id, dst_id_type, packet->data,
1763                                packet->len, TRUE);
1764   silc_buffer_free(packet);
1765   va_end(ap);
1766 }
1767
1768 /* Send the heartbeat packet. */
1769
1770 void silc_server_send_heartbeat(SilcServer server,
1771                                 SilcSocketConnection sock)
1772 {
1773   silc_server_packet_send(server, sock, SILC_PACKET_HEARTBEAT, 0,
1774                           NULL, 0, FALSE);
1775 }
1776
1777 /* Generic function to relay packet we've received. This is used to relay
1778    packets to a client but generally can be used to other purposes as well. */
1779
1780 void silc_server_relay_packet(SilcServer server,
1781                               SilcSocketConnection dst_sock,
1782                               SilcCipher cipher,
1783                               SilcHmac hmac,
1784                               SilcUInt32 sequence,
1785                               SilcPacketContext *packet,
1786                               bool force_send)
1787 {
1788   const SilcBufferStruct p;
1789
1790   silc_buffer_push(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1791                    + packet->dst_id_len + packet->padlen);
1792   if (!silc_packet_send_prepare(dst_sock, 0, 0, packet->buffer->len, hmac,
1793                                 (const SilcBuffer)&p)) {
1794     SILC_LOG_ERROR(("Cannot send packet"));
1795     return;
1796   }
1797   silc_buffer_put((SilcBuffer)&p, packet->buffer->data, packet->buffer->len);
1798
1799   /* Re-encrypt packet */
1800   silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p, p.len);
1801
1802   /* Send the packet */
1803   silc_server_packet_send_real(server, dst_sock, force_send);
1804
1805   silc_buffer_pull(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1806                    + packet->dst_id_len + packet->padlen);
1807 }
1808
1809 /* Routine used to send the connection authentication packet. */
1810
1811 void silc_server_send_connection_auth_request(SilcServer server,
1812                                               SilcSocketConnection sock,
1813                                               SilcUInt16 conn_type,
1814                                               SilcAuthMethod auth_meth)
1815 {
1816   SilcBuffer packet;
1817
1818   packet = silc_buffer_alloc(4);
1819   silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1820   silc_buffer_format(packet,
1821                      SILC_STR_UI_SHORT(conn_type),
1822                      SILC_STR_UI_SHORT(auth_meth),
1823                      SILC_STR_END);
1824
1825   silc_server_packet_send(server, sock, SILC_PACKET_CONNECTION_AUTH_REQUEST,
1826                           0, packet->data, packet->len, FALSE);
1827   silc_buffer_free(packet);
1828 }
1829
1830 /* Purge the outgoing packet queue to the network if there is data. This
1831    function can be used to empty the packet queue. It is guaranteed that
1832    after this function returns the outgoing data queue is empty. */
1833
1834 void silc_server_packet_queue_purge(SilcServer server,
1835                                     SilcSocketConnection sock)
1836 {
1837   if (sock && SILC_IS_OUTBUF_PENDING(sock) &&
1838       (SILC_IS_DISCONNECTED(sock) == FALSE)) {
1839     server->stat.packets_sent++;
1840     silc_packet_send(sock, TRUE);
1841     SILC_SET_CONNECTION_FOR_INPUT(server->schedule, sock->sock);
1842     SILC_UNSET_OUTBUF_PENDING(sock);
1843     silc_buffer_clear(sock->outbuf);
1844   }
1845 }