apps/silcd/packet_send.c

   1 /*
   2
   3   packet_send.c
   4
   5   Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
   6
   7   Copyright (C) 1997 - 2001 Pekka Riikonen
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; either version 2 of the License, or
  12   (at your option) any later version.
  13
  14   This program is distributed in the hope that it will be useful,
  15   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17   GNU General Public License for more details.
  18
  19 */
  20 /*
  21  * Server packet routines to send packets.
  22  */
  23 /* $Id$ */
  24
  25 #include "serverincludes.h"
  26 #include "server_internal.h"
  27
  28 /* Routine that sends packet or marks packet to be sent. This is used
  29    directly only in special cases. Normal cases should use
  30    silc_server_packet_send. Returns < 0 error. */
  31
  32 int silc_server_packet_send_real(SilcServer server,
  33                                  SilcSocketConnection sock,
  34                                  int force_send)
  35 {
  36   int ret;
  37
  38   /* Send the packet */
  39   ret = silc_packet_send(sock, force_send);
  40   if (ret != -2)
  41     return ret;
  42
  43   /* Mark that there is some outgoing data available for this connection.
  44      This call sets the connection both for input and output (the input
  45      is set always and this call keeps the input setting, actually).
  46      Actual data sending is performed by silc_server_packet_process. */
  47   SILC_SET_CONNECTION_FOR_OUTPUT(sock->sock);
  48
  49   /* Mark to socket that data is pending in outgoing buffer. This flag
  50      is needed if new data is added to the buffer before the earlier
  51      put data is sent to the network. */
  52   SILC_SET_OUTBUF_PENDING(sock);
  53
  54   return 0;
  55 }
  56
  57 /* Assembles a new packet to be sent out to network. This doesn't actually
  58    send the packet but creates the packet and fills the outgoing data
  59    buffer and marks the packet ready to be sent to network. However, If
  60    argument force_send is TRUE the packet is sent immediately and not put
  61    to queue. Normal case is that the packet is not sent immediately. */
  62
  63 void silc_server_packet_send(SilcServer server,
  64                              SilcSocketConnection sock,
  65                              SilcPacketType type,
  66                              SilcPacketFlags flags,
  67                              unsigned char *data,
  68                              unsigned int data_len,
  69                              int force_send)
  70 {
  71   void *dst_id = NULL;
  72   SilcIdType dst_id_type = SILC_ID_NONE;
  73
  74   if (!sock)
  75     return;
  76
  77   /* Get data used in the packet sending, keys and stuff */
  78   switch(sock->type) {
  79   case SILC_SOCKET_TYPE_CLIENT:
  80     dst_id = ((SilcClientEntry)sock->user_data)->id;
  81     dst_id_type = SILC_ID_CLIENT;
  82     break;
  83   case SILC_SOCKET_TYPE_SERVER:
  84   case SILC_SOCKET_TYPE_ROUTER:
  85     dst_id = ((SilcServerEntry)sock->user_data)->id;
  86     dst_id_type = SILC_ID_SERVER;
  87     break;
  88   default:
  89     break;
  90   }
  91
  92   silc_server_packet_send_dest(server, sock, type, flags, dst_id,
  93                                dst_id_type, data, data_len, force_send);
  94 }
  95
  96 /* Assembles a new packet to be sent out to network. This doesn't actually
  97    send the packet but creates the packet and fills the outgoing data
  98    buffer and marks the packet ready to be sent to network. However, If
  99    argument force_send is TRUE the packet is sent immediately and not put
 100    to queue. Normal case is that the packet is not sent immediately.
 101    Destination information is sent as argument for this function. */
 102
 103 void silc_server_packet_send_dest(SilcServer server,
 104                                   SilcSocketConnection sock,
 105                                   SilcPacketType type,
 106                                   SilcPacketFlags flags,
 107                                   void *dst_id,
 108                                   SilcIdType dst_id_type,
 109                                   unsigned char *data,
 110                                   unsigned int data_len,
 111                                   int force_send)
 112 {
 113   SilcPacketContext packetdata;
 114   SilcIDListData idata;
 115   SilcCipher cipher = NULL;
 116   SilcHmac hmac = NULL;
 117   unsigned char *dst_id_data = NULL;
 118   unsigned int dst_id_len = 0;
 119
 120   SILC_LOG_DEBUG(("Sending packet, type %d", type));
 121
 122   /* Get data used in the packet sending, keys and stuff */
 123   idata = (SilcIDListData)sock->user_data;
 124
 125   if (dst_id) {
 126     dst_id_data = silc_id_id2str(dst_id, dst_id_type);
 127     dst_id_len = silc_id_get_len(dst_id_type);
 128   }
 129
 130   /* Set the packet context pointers */
 131   packetdata.type = type;
 132   packetdata.flags = flags;
 133   packetdata.src_id = silc_id_id2str(server->id, server->id_type);
 134   packetdata.src_id_len = SILC_ID_SERVER_LEN;
 135   packetdata.src_id_type = server->id_type;
 136   packetdata.dst_id = dst_id_data;
 137   packetdata.dst_id_len = dst_id_len;
 138   packetdata.dst_id_type = dst_id_type;
 139   packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
 140     packetdata.src_id_len + dst_id_len;
 141   packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen);
 142
 143   /* Prepare outgoing data buffer for packet sending */
 144   silc_packet_send_prepare(sock,
 145                            SILC_PACKET_HEADER_LEN +
 146                            packetdata.src_id_len +
 147                            packetdata.dst_id_len,
 148                            packetdata.padlen,
 149                            data_len);
 150
 151   SILC_LOG_DEBUG(("Putting data to outgoing buffer, len %d", data_len));
 152
 153   packetdata.buffer = sock->outbuf;
 154
 155   /* Put the data to the buffer */
 156   if (data && data_len)
 157     silc_buffer_put(sock->outbuf, data, data_len);
 158
 159   /* Create the outgoing packet */
 160   silc_packet_assemble(&packetdata);
 161
 162   if (idata) {
 163     cipher = idata->send_key;
 164     hmac = idata->hmac;
 165   }
 166
 167   /* Encrypt the packet */
 168   silc_packet_encrypt(cipher, hmac, sock->outbuf, sock->outbuf->len);
 169
 170   SILC_LOG_HEXDUMP(("Outgoing packet, len %d", sock->outbuf->len),
 171                    sock->outbuf->data, sock->outbuf->len);
 172
 173   /* Now actually send the packet */
 174   silc_server_packet_send_real(server, sock, force_send);
 175
 176   if (packetdata.src_id)
 177     silc_free(packetdata.src_id);
 178   if (packetdata.dst_id)
 179     silc_free(packetdata.dst_id);
 180 }
 181
 182 /* Broadcast received packet to our primary route. This function is used
 183    by router to further route received broadcast packet. It is expected
 184    that the broadcast flag from the packet is checked before calling this
 185    function. This does not test or set the broadcast flag. */
 186
 187 void silc_server_packet_broadcast(SilcServer server,
 188                                   SilcSocketConnection sock,
 189                                   SilcPacketContext *packet)
 190 {
 191   SilcBuffer buffer = packet->buffer;
 192   SilcIDListData idata;
 193   void *id;
 194
 195   SILC_LOG_DEBUG(("Broadcasting received broadcast packet"));
 196
 197   /* If the packet is originated from our primary route we are
 198      not allowed to send the packet. */
 199   id = silc_id_str2id(packet->src_id, packet->src_id_len, packet->src_id_type);
 200   if (id && SILC_ID_SERVER_COMPARE(id, server->router->id)) {
 201     idata = (SilcIDListData)sock->user_data;
 202
 203     silc_buffer_push(buffer, buffer->data - buffer->head);
 204     silc_packet_send_prepare(sock, 0, 0, buffer->len);
 205     silc_buffer_put(sock->outbuf, buffer->data, buffer->len);
 206     silc_packet_encrypt(idata->send_key, idata->hmac,
 207                         sock->outbuf, sock->outbuf->len);
 208
 209     SILC_LOG_HEXDUMP(("Broadcasted packet, len %d", sock->outbuf->len),
 210                      sock->outbuf->data, sock->outbuf->len);
 211
 212     /* Now actually send the packet */
 213     silc_server_packet_send_real(server, sock, TRUE);
 214     silc_free(id);
 215     return;
 216   }
 217
 218   SILC_LOG_DEBUG(("Will not broadcast to primary route since it is the "
 219                   "original sender of this packet"));
 220   silc_free(id);
 221 }
 222
 223 /* Routes received packet to `sock'. This is used to route the packets that
 224    router receives but are not destined to it. */
 225
 226 void silc_server_packet_route(SilcServer server,
 227                               SilcSocketConnection sock,
 228                               SilcPacketContext *packet)
 229 {
 230   SilcBuffer buffer = packet->buffer;
 231   SilcIDListData idata;
 232
 233   SILC_LOG_DEBUG(("Routing received packet"));
 234
 235   idata = (SilcIDListData)sock->user_data;
 236
 237   silc_buffer_push(buffer, buffer->data - buffer->head);
 238   silc_packet_send_prepare(sock, 0, 0, buffer->len);
 239   silc_buffer_put(sock->outbuf, buffer->data, buffer->len);
 240   silc_packet_encrypt(idata->send_key, idata->hmac,
 241                       sock->outbuf, sock->outbuf->len);
 242
 243   SILC_LOG_HEXDUMP(("Routed packet, len %d", sock->outbuf->len),
 244                    sock->outbuf->data, sock->outbuf->len);
 245
 246   /* Now actually send the packet */
 247   silc_server_packet_send_real(server, sock, TRUE);
 248 }
 249
 250 /* Internal routine to actually create the channel packet and send it
 251    to network. This is common function in channel message sending. If
 252    `channel_message' is TRUE this encrypts the message as it is strictly
 253    a channel message. If FALSE normal encryption process is used. */
 254
 255 static void
 256 silc_server_packet_send_to_channel_real(SilcServer server,
 257                                         SilcSocketConnection sock,
 258                                         SilcPacketContext *packet,
 259                                         SilcCipher cipher,
 260                                         SilcHmac hmac,
 261                                         unsigned char *data,
 262                                         unsigned int data_len,
 263                                         int channel_message,
 264                                         int force_send)
 265 {
 266   packet->truelen = data_len + SILC_PACKET_HEADER_LEN +
 267     packet->src_id_len + packet->dst_id_len;
 268
 269   /* Prepare outgoing data buffer for packet sending */
 270   silc_packet_send_prepare(sock,
 271                            SILC_PACKET_HEADER_LEN +
 272                            packet->src_id_len +
 273                            packet->dst_id_len,
 274                            packet->padlen,
 275                            data_len);
 276
 277   packet->buffer = sock->outbuf;
 278
 279   /* Put the data to buffer, assemble and encrypt the packet. The packet
 280      is encrypted with normal session key shared with the client. */
 281   silc_buffer_put(sock->outbuf, data, data_len);
 282   silc_packet_assemble(packet);
 283   if (channel_message)
 284     silc_packet_encrypt(cipher, hmac, sock->outbuf, SILC_PACKET_HEADER_LEN +
 285                         packet->src_id_len + packet->dst_id_len +
 286                         packet->padlen);
 287   else
 288     silc_packet_encrypt(cipher, hmac, sock->outbuf, sock->outbuf->len);
 289
 290   SILC_LOG_HEXDUMP(("Channel packet, len %d", sock->outbuf->len),
 291                    sock->outbuf->data, sock->outbuf->len);
 292
 293   /* Now actually send the packet */
 294   silc_server_packet_send_real(server, sock, force_send);
 295 }
 296
 297 /* This routine is used by the server to send packets to channel. The
 298    packet sent with this function is distributed to all clients on
 299    the channel. Usually this is used to send notify messages to the
 300    channel, things like notify about new user joining to the channel.
 301    If `route' is FALSE then the packet is sent only locally and will not
 302    be routed anywhere (for router locally means cell wide). If `sender'
 303    is provided then the packet is not sent to that connection since it
 304    originally came from it. */
 305
 306 void silc_server_packet_send_to_channel(SilcServer server,
 307                                         SilcSocketConnection sender,
 308                                         SilcChannelEntry channel,
 309                                         SilcPacketType type,
 310                                         unsigned char route,
 311                                         unsigned char *data,
 312                                         unsigned int data_len,
 313                                         int force_send)
 314 {
 315   SilcSocketConnection sock = NULL;
 316   SilcPacketContext packetdata;
 317   SilcClientEntry client = NULL;
 318   SilcServerEntry *routed = NULL;
 319   SilcChannelClientEntry chl;
 320   SilcIDListData idata;
 321   unsigned int routed_count = 0;
 322
 323   /* This doesn't send channel message packets */
 324   if (type == SILC_PACKET_CHANNEL_MESSAGE)
 325     return;
 326
 327   SILC_LOG_DEBUG(("Sending packet to channel"));
 328
 329   /* Set the packet context pointers. */
 330   packetdata.flags = 0;
 331   packetdata.type = type;
 332   packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
 333   packetdata.src_id_len = SILC_ID_SERVER_LEN;
 334   packetdata.src_id_type = SILC_ID_SERVER;
 335   packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
 336   packetdata.dst_id_len = SILC_ID_CHANNEL_LEN;
 337   packetdata.dst_id_type = SILC_ID_CHANNEL;
 338   packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
 339     packetdata.src_id_len + packetdata.dst_id_len;
 340   packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen);
 341
 342   /* If there are global users in the channel we will send the message
 343      first to our router for further routing. */
 344   if (route && server->server_type == SILC_SERVER && !server->standalone &&
 345       channel->global_users) {
 346     SilcServerEntry router;
 347
 348     /* Get data used in packet header encryption, keys and stuff. */
 349     router = server->router;
 350     sock = (SilcSocketConnection)router->connection;
 351     idata = (SilcIDListData)router;
 352
 353     if (sock != sender) {
 354       SILC_LOG_DEBUG(("Sending channel message to router for routing"));
 355
 356       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 357                                               idata->send_key, idata->hmac,
 358                                               data, data_len, FALSE,
 359                                               force_send);
 360     }
 361   }
 362
 363   /* Send the message to clients on the channel's client list. */
 364   silc_list_start(channel->user_list);
 365   while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END) {
 366     client = chl->client;
 367
 368     /* If client has router set it is not locally connected client and
 369        we will route the message to the router set in the client. Though,
 370        send locally connected server in all cases. */
 371     if (server->server_type == SILC_ROUTER && client && client->router &&
 372         ((!route && client->router->router == server->id_entry) || route)) {
 373       int k;
 374
 375       /* Check if we have sent the packet to this route already */
 376       for (k = 0; k < routed_count; k++)
 377         if (routed[k] == client->router)
 378           break;
 379       if (k < routed_count)
 380         continue;
 381
 382       /* Get data used in packet header encryption, keys and stuff. */
 383       sock = (SilcSocketConnection)client->router->connection;
 384       idata = (SilcIDListData)client->router;
 385
 386       if (sender && sock == sender)
 387         continue;
 388
 389       /* Send the packet */
 390       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 391                                               idata->send_key, idata->hmac,
 392                                               data, data_len, FALSE,
 393                                               force_send);
 394
 395       /* We want to make sure that the packet is routed to same router
 396          only once. Mark this route as sent route. */
 397       k = routed_count;
 398       routed = silc_realloc(routed, sizeof(*routed) * (k + 1));
 399       routed[k] = client->router;
 400       routed_count++;
 401
 402       continue;
 403     }
 404
 405     if (client && client->router)
 406       continue;
 407
 408     /* Send to locally connected client */
 409     if (client) {
 410
 411       /* Get data used in packet header encryption, keys and stuff. */
 412       sock = (SilcSocketConnection)client->connection;
 413       idata = (SilcIDListData)client;
 414
 415       if (sender && sock == sender)
 416         continue;
 417
 418       /* Send the packet */
 419       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 420                                               idata->send_key, idata->hmac,
 421                                               data, data_len, FALSE,
 422                                               force_send);
 423     }
 424   }
 425
 426   if (routed_count)
 427     silc_free(routed);
 428   silc_free(packetdata.src_id);
 429   silc_free(packetdata.dst_id);
 430 }
 431
 432 /* This routine is explicitly used to relay messages to some channel.
 433    Packets sent with this function we have received earlier and are
 434    totally encrypted. This just sends the packet to all clients on
 435    the channel. If the sender of the packet is someone on the channel
 436    the message will not be sent to that client. The SILC Packet header
 437    is encrypted with the session key shared between us and the client.
 438    MAC is also computed before encrypting the header. Rest of the
 439    packet will be untouched. */
 440
 441 void silc_server_packet_relay_to_channel(SilcServer server,
 442                                          SilcSocketConnection sender_sock,
 443                                          SilcChannelEntry channel,
 444                                          void *sender,
 445                                          SilcIdType sender_type,
 446                                          unsigned char *data,
 447                                          unsigned int data_len,
 448                                          int force_send)
 449 {
 450   int found = FALSE;
 451   SilcSocketConnection sock = NULL;
 452   SilcPacketContext packetdata;
 453   SilcClientEntry client = NULL;
 454   SilcServerEntry *routed = NULL;
 455   SilcChannelClientEntry chl;
 456   unsigned int routed_count = 0;
 457   SilcIDListData idata;
 458
 459   SILC_LOG_DEBUG(("Relaying packet to channel"));
 460
 461   /* Set the packet context pointers. */
 462   packetdata.flags = 0;
 463   packetdata.type = SILC_PACKET_CHANNEL_MESSAGE;
 464   packetdata.src_id = silc_id_id2str(sender, sender_type);
 465   packetdata.src_id_len = silc_id_get_len(sender_type);
 466   packetdata.src_id_type = sender_type;
 467   packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
 468   packetdata.dst_id_len = SILC_ID_CHANNEL_LEN;
 469   packetdata.dst_id_type = SILC_ID_CHANNEL;
 470   packetdata.padlen = SILC_PACKET_PADLEN((SILC_PACKET_HEADER_LEN +
 471                                           packetdata.src_id_len +
 472                                           packetdata.dst_id_len));
 473
 474   /* If there are global users in the channel we will send the message
 475      first to our router for further routing. */
 476   if (server->server_type == SILC_SERVER && !server->standalone &&
 477       channel->global_users) {
 478     SilcServerEntry router;
 479
 480     router = server->router;
 481
 482     /* Check that the sender is not our router. */
 483     if (sender_sock != (SilcSocketConnection)router->connection) {
 484
 485       /* Get data used in packet header encryption, keys and stuff. */
 486       sock = (SilcSocketConnection)router->connection;
 487       idata = (SilcIDListData)router;
 488
 489       SILC_LOG_DEBUG(("Sending channel message to router for routing"));
 490
 491       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 492                                               idata->send_key, idata->hmac,
 493                                               data, data_len, TRUE,
 494                                               force_send);
 495     }
 496   }
 497
 498   /* Send the message to clients on the channel's client list. */
 499   silc_list_start(channel->user_list);
 500   while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END) {
 501     client = chl->client;
 502
 503     if (client) {
 504
 505       /* If sender is one on the channel do not send it the packet. */
 506       if (!found && !SILC_ID_CLIENT_COMPARE(client->id, sender)) {
 507         found = TRUE;
 508         continue;
 509       }
 510
 511       /* If the client has set router it means that it is not locally
 512          connected client and we will route the packet further. */
 513       if (server->server_type == SILC_ROUTER && client->router) {
 514         int k;
 515
 516         /* Sender maybe server as well so we want to make sure that
 517            we won't send the message to the server it came from. */
 518         if (!found && !SILC_ID_SERVER_COMPARE(client->router->id, sender)) {
 519           found = TRUE;
 520           continue;
 521         }
 522
 523         /* Check if we have sent the packet to this route already */
 524         for (k = 0; k < routed_count; k++)
 525           if (routed[k] == client->router)
 526             break;
 527         if (k < routed_count)
 528           continue;
 529
 530         /* Get data used in packet header encryption, keys and stuff. */
 531         sock = (SilcSocketConnection)client->router->connection;
 532         idata = (SilcIDListData)client->router;
 533
 534         if (sender_sock && sock == sender_sock)
 535           continue;
 536
 537         SILC_LOG_DEBUG(("Relaying packet to client ID(%s) %s (%s)",
 538                         silc_id_render(client->id, SILC_ID_CLIENT),
 539                         sock->hostname, sock->ip));
 540
 541         /* Send the packet */
 542         silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 543                                                 idata->send_key, idata->hmac,
 544                                                 data, data_len, TRUE,
 545                                                 force_send);
 546
 547         /* We want to make sure that the packet is routed to same router
 548            only once. Mark this route as sent route. */
 549         k = routed_count;
 550         routed = silc_realloc(routed, sizeof(*routed) * (k + 1));
 551         routed[k] = client->router;
 552         routed_count++;
 553
 554         continue;
 555       }
 556
 557       if (client && client->router)
 558         continue;
 559
 560       /* Get data used in packet header encryption, keys and stuff. */
 561       sock = (SilcSocketConnection)client->connection;
 562       idata = (SilcIDListData)client;
 563
 564       if (sender_sock && sock == sender_sock)
 565         continue;
 566
 567       SILC_LOG_DEBUG(("Sending packet to client ID(%s) %s (%s)",
 568                       silc_id_render(client->id, SILC_ID_CLIENT),
 569                       sock->hostname, sock->ip));
 570
 571       /* Send the packet */
 572       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 573                                               idata->send_key, idata->hmac,
 574                                               data, data_len, TRUE,
 575                                               force_send);
 576     }
 577   }
 578
 579   silc_free(packetdata.src_id);
 580   silc_free(packetdata.dst_id);
 581 }
 582
 583 /* This function is used to send packets strictly to all local clients
 584    on a particular channel.  This is used for example to distribute new
 585    channel key to all our locally connected clients on the channel.
 586    The packets are always encrypted with the session key shared between
 587    the client, this means these are not _to the channel_ but _to the client_
 588    on the channel. */
 589
 590 void silc_server_packet_send_local_channel(SilcServer server,
 591                                            SilcChannelEntry channel,
 592                                            SilcPacketType type,
 593                                            SilcPacketFlags flags,
 594                                            unsigned char *data,
 595                                            unsigned int data_len,
 596                                            int force_send)
 597 {
 598   SilcChannelClientEntry chl;
 599   SilcSocketConnection sock = NULL;
 600
 601   SILC_LOG_DEBUG(("Start"));
 602
 603   /* Send the message to clients on the channel's client list. */
 604   silc_list_start(channel->user_list);
 605   while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END) {
 606     if (chl->client && !chl->client->router) {
 607       sock = (SilcSocketConnection)chl->client->connection;
 608
 609       /* Send the packet to the client */
 610       silc_server_packet_send_dest(server, sock, type, flags, chl->client->id,
 611                                    SILC_ID_CLIENT, data, data_len,
 612                                    force_send);
 613     }
 614   }
 615 }
 616
 617 /* Routine used to send (relay, route) private messages to some destination.
 618    If the private message key does not exist then the message is re-encrypted,
 619    otherwise we just pass it along. This really is not used to send new
 620    private messages (as server does not send them) but to relay received
 621    private messages. */
 622
 623 void silc_server_send_private_message(SilcServer server,
 624                                       SilcSocketConnection dst_sock,
 625                                       SilcCipher cipher,
 626                                       SilcHmac hmac,
 627                                       SilcPacketContext *packet)
 628 {
 629   SilcBuffer buffer = packet->buffer;
 630
 631   /* Send and re-encrypt if private messge key does not exist */
 632   if ((packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY) == FALSE) {
 633
 634     silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
 635                      + packet->dst_id_len + packet->padlen);
 636     silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
 637     silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
 638
 639     /* Re-encrypt packet */
 640     silc_packet_encrypt(cipher, hmac, dst_sock->outbuf, buffer->len);
 641
 642     /* Send the packet */
 643     silc_server_packet_send_real(server, dst_sock, FALSE);
 644
 645   } else {
 646     /* Key exist so just send it */
 647     silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
 648                      + packet->dst_id_len + packet->padlen);
 649     silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
 650     silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
 651     silc_server_packet_send_real(server, dst_sock, FALSE);
 652   }
 653 }
 654
 655 /* Sends current motd to client */
 656
 657 void silc_server_send_motd(SilcServer server,
 658                            SilcSocketConnection sock)
 659 {
 660   char *motd;
 661   int motd_len;
 662
 663   if (server->config && server->config->motd &&
 664       server->config->motd->motd_file) {
 665
 666     motd = silc_file_read(server->config->motd->motd_file, &motd_len);
 667     if (!motd)
 668       return;
 669
 670     silc_server_send_notify(server, sock, FALSE, SILC_NOTIFY_TYPE_MOTD, 1,
 671                             motd, motd_len);
 672     silc_free(motd);
 673   }
 674 }
 675
 676 /* Sends error message. Error messages may or may not have any
 677    implications. */
 678
 679 void silc_server_send_error(SilcServer server,
 680                             SilcSocketConnection sock,
 681                             const char *fmt, ...)
 682 {
 683   va_list ap;
 684   unsigned char buf[4096];
 685
 686   memset(buf, 0, sizeof(buf));
 687   va_start(ap, fmt);
 688   vsprintf(buf, fmt, ap);
 689   va_end(ap);
 690
 691   silc_server_packet_send(server, sock, SILC_PACKET_ERROR, 0,
 692                           buf, strlen(buf), FALSE);
 693 }
 694
 695 /* Sends notify message. If format is TRUE the variable arguments are
 696    formatted and the formatted string is sent as argument payload. If it is
 697    FALSE then each argument is sent as separate argument and their format
 698    in the argument list must be { argument data, argument length }. */
 699
 700 void silc_server_send_notify(SilcServer server,
 701                              SilcSocketConnection sock,
 702                              int broadcast,
 703                              SilcNotifyType type,
 704                              unsigned int argc, ...)
 705 {
 706   va_list ap;
 707   SilcBuffer packet;
 708
 709   va_start(ap, argc);
 710
 711   packet = silc_notify_payload_encode(type, argc, ap);
 712   silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY, 0,
 713                           packet->data, packet->len, FALSE);
 714   silc_buffer_free(packet);
 715 }
 716
 717 /* Send CHANNEL_CHANGE notify type. This tells the receiver to replace the
 718    `old_id' with the `new_id'. */
 719
 720 void silc_server_send_notify_channel_change(SilcServer server,
 721                                             SilcSocketConnection sock,
 722                                             int broadcast,
 723                                             SilcChannelID *old_id,
 724                                             SilcChannelID *new_id,
 725                                             unsigned int id_len)
 726 {
 727   SilcBuffer idp1, idp2;
 728
 729   idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CHANNEL);
 730   idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CHANNEL);
 731
 732   silc_server_send_notify(server, sock, broadcast,
 733                           SILC_NOTIFY_TYPE_CHANNEL_CHANGE,
 734                           2, idp1->data, idp1->len, idp2->data, idp2->len);
 735   silc_buffer_free(idp1);
 736   silc_buffer_free(idp2);
 737 }
 738
 739 /* Send NICK_CHANGE notify type. This tells the receiver to replace the
 740    `old_id' with the `new_id'. */
 741
 742 void silc_server_send_notify_nick_change(SilcServer server,
 743                                          SilcSocketConnection sock,
 744                                          int broadcast,
 745                                          SilcClientID *old_id,
 746                                          SilcClientID *new_id,
 747                                          unsigned int id_len)
 748 {
 749   SilcBuffer idp1, idp2;
 750
 751   idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CLIENT);
 752   idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CLIENT);
 753
 754   silc_server_send_notify(server, sock, broadcast,
 755                           SILC_NOTIFY_TYPE_NICK_CHANGE,
 756                           2, idp1->data, idp1->len, idp2->data, idp2->len);
 757   silc_buffer_free(idp1);
 758   silc_buffer_free(idp2);
 759 }
 760
 761 /* Sends JOIN notify type. This tells that new client by `client_id' ID
 762    has joined to the `channel'. */
 763
 764 void silc_server_send_notify_join(SilcServer server,
 765                                   SilcSocketConnection sock,
 766                                   int broadcast,
 767                                   SilcChannelEntry channel,
 768                                   SilcClientID *client_id,
 769                                   unsigned int client_id_len)
 770 {
 771   SilcBuffer idp1, idp2;
 772
 773   idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
 774   idp2 = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
 775   silc_server_send_notify(server, sock, broadcast, SILC_NOTIFY_TYPE_JOIN,
 776                           2, idp1->data, idp1->len,
 777                           idp2->data, idp2->len);
 778   silc_buffer_free(idp1);
 779   silc_buffer_free(idp2);
 780 }
 781
 782 /* Sends LEAVE notify type. This tells that `client_id' has left the
 783    `channel'. The Notify packet is always destined to the channel. */
 784
 785 void silc_server_send_notify_leave(SilcServer server,
 786                                    SilcSocketConnection sock,
 787                                    int broadcast,
 788                                    SilcChannelEntry channel,
 789                                    SilcClientID *client_id,
 790                                    unsigned int client_id_len)
 791 {
 792   SilcBuffer idp;
 793
 794   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
 795   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
 796                                SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_LEAVE,
 797                                1, idp->data, idp->len);
 798   silc_buffer_free(idp);
 799 }
 800
 801 /* Sends CMODE_CHANGE notify type. This tells that `client_id' changed the
 802    `channel' mode to `mode. The Notify packet is always destined to
 803    the channel. */
 804
 805 void silc_server_send_notify_cmode(SilcServer server,
 806                                    SilcSocketConnection sock,
 807                                    int broadcast,
 808                                    SilcChannelEntry channel,
 809                                    unsigned int mode_mask,
 810                                    SilcClientID *client_id,
 811                                    unsigned int client_id_len)
 812 {
 813   SilcBuffer idp;
 814   unsigned char mode[4];
 815
 816   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
 817   SILC_PUT32_MSB(mode_mask, mode);
 818
 819   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
 820                                SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_CMODE_CHANGE,
 821                                2, idp->data, idp->len,
 822                                mode, 4);
 823   silc_buffer_free(idp);
 824 }
 825
 826 /* Sends CUMODE_CHANGE notify type. This tells that `client_id' changed the
 827    `target' client's mode on `channel'. The Notify packet is always
 828    destined to the channel. */
 829
 830 void silc_server_send_notify_cumode(SilcServer server,
 831                                     SilcSocketConnection sock,
 832                                     int broadcast,
 833                                     SilcChannelEntry channel,
 834                                     unsigned int mode_mask,
 835                                     SilcClientID *client_id,
 836                                     unsigned int client_id_len,
 837                                     SilcClientID *target,
 838                                     unsigned int target_len)
 839 {
 840   SilcBuffer idp1, idp2;
 841   unsigned char mode[4];
 842
 843   idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
 844   idp2 = silc_id_payload_encode((void *)target, SILC_ID_CLIENT);
 845   SILC_PUT32_MSB(mode_mask, mode);
 846
 847   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
 848                                SILC_ID_CHANNEL,
 849                                SILC_NOTIFY_TYPE_CUMODE_CHANGE, 3,
 850                                idp1->data, idp1->len,
 851                                mode, 4,
 852                                idp2->data, idp2->len);
 853   silc_buffer_free(idp1);
 854   silc_buffer_free(idp2);
 855 }
 856
 857 /* Sends SIGNOFF notify type. This tells that `client_id' client has
 858    left SILC network. This function is used only between server and router
 859    traffic. This is not used to send the notify to the channel for
 860    client. The `message may be NULL. */
 861
 862 void silc_server_send_notify_signoff(SilcServer server,
 863                                      SilcSocketConnection sock,
 864                                      int broadcast,
 865                                      SilcClientID *client_id,
 866                                      unsigned int client_id_len,
 867                                      char *message)
 868 {
 869   SilcBuffer idp;
 870
 871   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
 872   silc_server_send_notify(server, sock, broadcast,
 873                           SILC_NOTIFY_TYPE_SIGNOFF,
 874                           message ? 2 : 1, idp->data, idp->len,
 875                           message, message ? strlen(message): 0);
 876   silc_buffer_free(idp);
 877 }
 878
 879 /* Sends SERVER_SIGNOFF notify type. This tells that `server_id' server
 880    has quit SILC network. */
 881
 882 void silc_server_send_notify_server_signoff(SilcServer server,
 883                                             SilcSocketConnection sock,
 884                                             int broadcast,
 885                                             SilcServerID *server_id,
 886                                             unsigned int server_id_len)
 887 {
 888   SilcBuffer idp;
 889
 890   idp = silc_id_payload_encode((void *)server_id, SILC_ID_SERVER);
 891   silc_server_send_notify(server, sock, broadcast,
 892                           SILC_NOTIFY_TYPE_SERVER_SIGNOFF,
 893                           1, idp->data, idp->len);
 894   silc_buffer_free(idp);
 895 }
 896
 897 /* Sends TOPIC_SET notify type. This tells that `client_id' changed
 898    the `channel's topic to `topic'. The Notify packet is always destined
 899    to the channel. This function is used to send the topic set notifies
 900    between routers. */
 901
 902 void silc_server_send_notify_topic_set(SilcServer server,
 903                                        SilcSocketConnection sock,
 904                                        int broadcast,
 905                                        SilcChannelEntry channel,
 906                                        SilcClientID *client_id,
 907                                        unsigned int client_id_len,
 908                                        char *topic)
 909 {
 910   SilcBuffer idp;
 911
 912   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
 913   silc_server_send_notify(server, sock, broadcast,
 914                           SILC_NOTIFY_TYPE_SERVER_SIGNOFF,
 915                           topic ? 2 : 1,
 916                           idp->data, idp->len,
 917                           topic, topic ? strlen(topic) : 0);
 918   silc_buffer_free(idp);
 919 }
 920
 921 /* Send KICKED notify type. This tells that the `client_id' on `channel'
 922    was kicked off the channel.  The `comment' may indicate the reason
 923    for the kicking. This function is used only between server and router
 924    traffic. */
 925
 926 void silc_server_send_notify_kicked(SilcServer server,
 927                                     SilcSocketConnection sock,
 928                                     int broadcast,
 929                                     SilcChannelEntry channel,
 930                                     SilcClientID *client_id,
 931                                     unsigned int client_id_len,
 932                                     char *comment)
 933 {
 934   SilcBuffer idp;
 935
 936   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
 937   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
 938                                SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_KICKED,
 939                                comment ? 2 : 1, idp->data, idp->len,
 940                                comment, comment ? strlen(comment) : 0);
 941   silc_buffer_free(idp);
 942 }
 943
 944 /* Sends notify message destined to specific entity. */
 945
 946 void silc_server_send_notify_dest(SilcServer server,
 947                                   SilcSocketConnection sock,
 948                                   int broadcast,
 949                                   void *dest_id,
 950                                   SilcIdType dest_id_type,
 951                                   SilcNotifyType type,
 952                                   unsigned int argc, ...)
 953 {
 954   va_list ap;
 955   SilcBuffer packet;
 956
 957   va_start(ap, argc);
 958
 959   packet = silc_notify_payload_encode(type, argc, ap);
 960   silc_server_packet_send_dest(server, sock, SILC_PACKET_NOTIFY, 0,
 961                                dest_id, dest_id_type,
 962                                packet->data, packet->len, FALSE);
 963   silc_buffer_free(packet);
 964 }
 965
 966 /* Sends notify message to a channel. The notify message sent is
 967    distributed to all clients on the channel. If `route_notify' is TRUE
 968    then the notify may be routed to primary route or to some other routers.
 969    If FALSE it is assured that the notify is sent only locally. If `sender'
 970    is provided then the packet is not sent to that connection since it
 971    originally came from it. */
 972
 973 void silc_server_send_notify_to_channel(SilcServer server,
 974                                         SilcSocketConnection sender,
 975                                         SilcChannelEntry channel,
 976                                         unsigned char route_notify,
 977                                         SilcNotifyType type,
 978                                         unsigned int argc, ...)
 979 {
 980   va_list ap;
 981   SilcBuffer packet;
 982
 983   va_start(ap, argc);
 984
 985   packet = silc_notify_payload_encode(type, argc, ap);
 986   silc_server_packet_send_to_channel(server, sender, channel,
 987                                      SILC_PACKET_NOTIFY, route_notify,
 988                                      packet->data, packet->len, FALSE);
 989   silc_buffer_free(packet);
 990 }
 991
 992 /* Send notify message to all clients the client has joined. It is quaranteed
 993    that the message is sent only once to a client (ie. if a client is joined
 994    on two same channel it will receive only one notify message). Also, this
 995    sends only to local clients (locally connected if we are server, and to
 996    local servers if we are router). */
 997
 998 void silc_server_send_notify_on_channels(SilcServer server,
 999                                          SilcClientEntry client,
1000                                          SilcNotifyType type,
1001                                          unsigned int argc, ...)
1002 {
1003   int k;
1004   SilcSocketConnection sock = NULL;
1005   SilcPacketContext packetdata;
1006   SilcClientEntry c;
1007   SilcClientEntry *sent_clients = NULL;
1008   unsigned int sent_clients_count = 0;
1009   SilcServerEntry *routed = NULL;
1010   unsigned int routed_count = 0;
1011   SilcChannelEntry channel;
1012   SilcChannelClientEntry chl, chl2;
1013   SilcIDListData idata;
1014   SilcBuffer packet;
1015   unsigned char *data;
1016   unsigned int data_len;
1017   int force_send = FALSE;
1018   va_list ap;
1019
1020   SILC_LOG_DEBUG(("Start"));
1021
1022   if (!silc_list_count(client->channels))
1023     return;
1024
1025   va_start(ap, argc);
1026   packet = silc_notify_payload_encode(type, argc, ap);
1027   data = packet->data;
1028   data_len = packet->len;
1029
1030   /* Set the packet context pointers. */
1031   packetdata.flags = 0;
1032   packetdata.type = SILC_PACKET_NOTIFY;
1033   packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
1034   packetdata.src_id_len = SILC_ID_SERVER_LEN;
1035   packetdata.src_id_type = SILC_ID_SERVER;
1036
1037   silc_list_start(client->channels);
1038   while ((chl = silc_list_get(client->channels)) != SILC_LIST_END) {
1039     channel = chl->channel;
1040
1041     /* Send the message to all clients on the channel's client list. */
1042     silc_list_start(channel->user_list);
1043     while ((chl2 = silc_list_get(channel->user_list)) != SILC_LIST_END) {
1044       c = chl2->client;
1045
1046       /* Check if we have sent the packet to this client already */
1047       for (k = 0; k < sent_clients_count; k++)
1048         if (sent_clients[k] == c)
1049           break;
1050       if (k < sent_clients_count)
1051         continue;
1052
1053       /* If we are router and if this client has router set it is not
1054          locally connected client and we will route the message to the
1055          router set in the client. */
1056       if (c && c->router && server->server_type == SILC_ROUTER) {
1057         /* Check if we have sent the packet to this route already */
1058         for (k = 0; k < routed_count; k++)
1059           if (routed[k] == c->router)
1060             break;
1061         if (k < routed_count)
1062           continue;
1063
1064         /* Get data used in packet header encryption, keys and stuff. */
1065         sock = (SilcSocketConnection)c->router->connection;
1066         idata = (SilcIDListData)c->router;
1067
1068         packetdata.dst_id = silc_id_id2str(c->router->id, SILC_ID_SERVER);
1069         packetdata.dst_id_len = SILC_ID_SERVER_LEN;
1070         packetdata.dst_id_type = SILC_ID_SERVER;
1071         packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
1072           packetdata.src_id_len + packetdata.dst_id_len;
1073         packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen);
1074
1075         /* Send the packet */
1076         silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1077                                                 idata->send_key, idata->hmac,
1078                                                 data, data_len, FALSE,
1079                                                 force_send);
1080
1081         silc_free(packetdata.dst_id);
1082
1083         /* We want to make sure that the packet is routed to same router
1084            only once. Mark this route as sent route. */
1085         k = routed_count;
1086         routed = silc_realloc(routed, sizeof(*routed) * (k + 1));
1087         routed[k] = c->router;
1088         routed_count++;
1089
1090         continue;
1091       }
1092
1093       if (c && c->router)
1094         continue;
1095
1096       /* Send to locally connected client */
1097       if (c) {
1098
1099         /* Get data used in packet header encryption, keys and stuff. */
1100         sock = (SilcSocketConnection)c->connection;
1101         idata = (SilcIDListData)c;
1102
1103         packetdata.dst_id = silc_id_id2str(c->id, SILC_ID_CLIENT);
1104         packetdata.dst_id_len = SILC_ID_CLIENT_LEN;
1105         packetdata.dst_id_type = SILC_ID_CLIENT;
1106         packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
1107           packetdata.src_id_len + packetdata.dst_id_len;
1108         packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen);
1109
1110         /* Send the packet */
1111         silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1112                                                 idata->send_key, idata->hmac,
1113                                                 data, data_len, FALSE,
1114                                                 force_send);
1115
1116         silc_free(packetdata.dst_id);
1117
1118         /* Make sure that we send the notify only once per client. */
1119         sent_clients = silc_realloc(sent_clients, sizeof(*sent_clients) *
1120                                     (sent_clients_count + 1));
1121         sent_clients[sent_clients_count] = c;
1122         sent_clients_count++;
1123       }
1124     }
1125   }
1126
1127   if (routed_count)
1128     silc_free(routed);
1129   if (sent_clients_count)
1130     silc_free(sent_clients);
1131   silc_free(packetdata.src_id);
1132 }
1133
1134 /* Sends New ID Payload to remote end. The packet is used to distribute
1135    information about new registered clients, servers, channel etc. usually
1136    to routers so that they can keep these information up to date.
1137    If the argument `broadcast' is TRUE then the packet is sent as
1138    broadcast packet. */
1139
1140 void silc_server_send_new_id(SilcServer server,
1141                              SilcSocketConnection sock,
1142                              int broadcast,
1143                              void *id, SilcIdType id_type,
1144                              unsigned int id_len)
1145 {
1146   SilcBuffer idp;
1147
1148   SILC_LOG_DEBUG(("Start"));
1149
1150   idp = silc_id_payload_encode(id, id_type);
1151   silc_server_packet_send(server, sock, SILC_PACKET_NEW_ID,
1152                           broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1153                           idp->data, idp->len, FALSE);
1154   silc_buffer_free(idp);
1155 }
1156
1157 /* Send New Channel Payload to notify about newly created channel in the
1158    SILC network. Normal server nevers sends this packet. Router uses this
1159    to notify other routers in the network about new channel. This packet
1160    is broadcasted. */
1161
1162 void silc_server_send_new_channel(SilcServer server,
1163                                   SilcSocketConnection sock,
1164                                   int broadcast,
1165                                   char *channel_name,
1166                                   void *channel_id,
1167                                   unsigned int channel_id_len)
1168 {
1169   SilcBuffer packet;
1170   unsigned char *cid;
1171   unsigned int name_len = strlen(channel_name);
1172
1173   SILC_LOG_DEBUG(("Start"));
1174
1175   cid = silc_id_id2str(channel_id, SILC_ID_CHANNEL);
1176   if (!cid)
1177     return;
1178
1179   packet = silc_buffer_alloc(2 + 2 + name_len + channel_id_len);
1180   silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1181   silc_buffer_format(packet,
1182                      SILC_STR_UI_SHORT(name_len),
1183                      SILC_STR_UI_XNSTRING(channel_name, name_len),
1184                      SILC_STR_UI_SHORT(channel_id_len),
1185                      SILC_STR_UI_XNSTRING(cid, channel_id_len),
1186                      SILC_STR_END);
1187
1188
1189   silc_server_packet_send(server, sock, SILC_PACKET_NEW_CHANNEL,
1190                           broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1191                           packet->data, packet->len, FALSE);
1192
1193   silc_free(cid);
1194   silc_buffer_free(packet);
1195 }
1196
1197 /* Send Channel Key payload to distribute the new channel key. Normal server
1198    sends this to router when new client joins to existing channel. Router
1199    sends this to the local server who sent the join command in case where
1200    the channel did not exist yet. Both normal and router servers uses this
1201    also to send this to locally connected clients on the channel. This
1202    must not be broadcasted packet. Routers do not send this to each other.
1203    If `sender is provided then the packet is not sent to that connection since
1204    it originally came from it. */
1205
1206 void silc_server_send_channel_key(SilcServer server,
1207                                   SilcSocketConnection sender,
1208                                   SilcChannelEntry channel,
1209                                   unsigned char route)
1210 {
1211   SilcBuffer packet;
1212   unsigned char *chid;
1213   unsigned int tmp_len;
1214
1215   SILC_LOG_DEBUG(("Start"));
1216
1217   chid = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
1218   if (!chid)
1219     return;
1220
1221   /* Encode channel key packet */
1222   tmp_len = strlen(channel->channel_key->cipher->name);
1223   packet = silc_channel_key_payload_encode(SILC_ID_CHANNEL_LEN, chid, tmp_len,
1224                                            channel->channel_key->cipher->name,
1225                                            channel->key_len / 8, channel->key);
1226
1227   silc_server_packet_send_to_channel(server, sender, channel,
1228                                      SILC_PACKET_CHANNEL_KEY,
1229                                      route, packet->data, packet->len, FALSE);
1230   silc_buffer_free(packet);
1231   silc_free(chid);
1232 }
1233
1234 /* Generic function to send any command. The arguments must be sent already
1235    encoded into correct form in correct order. */
1236
1237 void silc_server_send_command(SilcServer server,
1238                               SilcSocketConnection sock,
1239                               SilcCommand command,
1240                               unsigned int argc, ...)
1241 {
1242   SilcBuffer packet;
1243   va_list ap;
1244
1245   va_start(ap, argc);
1246
1247   packet = silc_command_payload_encode_vap(command, 0, argc, ap);
1248   silc_server_packet_send(server, sock, SILC_PACKET_COMMAND, 0,
1249                           packet->data, packet->len, TRUE);
1250   silc_buffer_free(packet);
1251 }
1252
1253 /* Send the heartbeat packet. */
1254
1255 void silc_server_send_heartbeat(SilcServer server,
1256                                 SilcSocketConnection sock)
1257 {
1258   silc_server_packet_send(server, sock, SILC_PACKET_HEARTBEAT, 0,
1259                           NULL, 0, FALSE);
1260 }