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 /* Assembles a new packet to be sent out to network. This doesn't actually
 183    send the packet but creates the packet and fills the outgoing data
 184    buffer and marks the packet ready to be sent to network. However, If
 185    argument force_send is TRUE the packet is sent immediately and not put
 186    to queue. Normal case is that the packet is not sent immediately.
 187    The source and destination information is sent as argument for this
 188    function. */
 189
 190 void silc_server_packet_send_srcdest(SilcServer server,
 191                                      SilcSocketConnection sock,
 192                                      SilcPacketType type,
 193                                      SilcPacketFlags flags,
 194                                      void *src_id,
 195                                      SilcIdType src_id_type,
 196                                      void *dst_id,
 197                                      SilcIdType dst_id_type,
 198                                      unsigned char *data,
 199                                      unsigned int data_len,
 200                                      int force_send)
 201 {
 202   SilcPacketContext packetdata;
 203   SilcIDListData idata;
 204   SilcCipher cipher = NULL;
 205   SilcHmac hmac = NULL;
 206   unsigned char *dst_id_data = NULL;
 207   unsigned int dst_id_len = 0;
 208   unsigned char *src_id_data = NULL;
 209   unsigned int src_id_len = 0;
 210
 211   SILC_LOG_DEBUG(("Sending packet, type %d", type));
 212
 213   /* Get data used in the packet sending, keys and stuff */
 214   idata = (SilcIDListData)sock->user_data;
 215
 216   if (dst_id) {
 217     dst_id_data = silc_id_id2str(dst_id, dst_id_type);
 218     dst_id_len = silc_id_get_len(dst_id_type);
 219   }
 220
 221   if (src_id) {
 222     src_id_data = silc_id_id2str(src_id, src_id_type);
 223     src_id_len = silc_id_get_len(src_id_type);
 224   }
 225
 226   /* Set the packet context pointers */
 227   packetdata.type = type;
 228   packetdata.flags = flags;
 229   packetdata.src_id = src_id_data;
 230   packetdata.src_id_len = src_id_len;
 231   packetdata.src_id_type = src_id_type;
 232   packetdata.dst_id = dst_id_data;
 233   packetdata.dst_id_len = dst_id_len;
 234   packetdata.dst_id_type = dst_id_type;
 235   packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
 236     packetdata.src_id_len + dst_id_len;
 237   packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen);
 238
 239   /* Prepare outgoing data buffer for packet sending */
 240   silc_packet_send_prepare(sock,
 241                            SILC_PACKET_HEADER_LEN +
 242                            packetdata.src_id_len +
 243                            packetdata.dst_id_len,
 244                            packetdata.padlen,
 245                            data_len);
 246
 247   SILC_LOG_DEBUG(("Putting data to outgoing buffer, len %d", data_len));
 248
 249   packetdata.buffer = sock->outbuf;
 250
 251   /* Put the data to the buffer */
 252   if (data && data_len)
 253     silc_buffer_put(sock->outbuf, data, data_len);
 254
 255   /* Create the outgoing packet */
 256   silc_packet_assemble(&packetdata);
 257
 258   if (idata) {
 259     cipher = idata->send_key;
 260     hmac = idata->hmac;
 261   }
 262
 263   /* Encrypt the packet */
 264   silc_packet_encrypt(cipher, hmac, sock->outbuf, sock->outbuf->len);
 265
 266   SILC_LOG_HEXDUMP(("Outgoing packet, len %d", sock->outbuf->len),
 267                    sock->outbuf->data, sock->outbuf->len);
 268
 269   /* Now actually send the packet */
 270   silc_server_packet_send_real(server, sock, force_send);
 271
 272   if (packetdata.src_id)
 273     silc_free(packetdata.src_id);
 274   if (packetdata.dst_id)
 275     silc_free(packetdata.dst_id);
 276 }
 277
 278 /* Broadcast received packet to our primary route. This function is used
 279    by router to further route received broadcast packet. It is expected
 280    that the broadcast flag from the packet is checked before calling this
 281    function. This does not test or set the broadcast flag. */
 282
 283 void silc_server_packet_broadcast(SilcServer server,
 284                                   SilcSocketConnection sock,
 285                                   SilcPacketContext *packet)
 286 {
 287   SilcBuffer buffer = packet->buffer;
 288   SilcIDListData idata;
 289   void *id;
 290
 291   SILC_LOG_DEBUG(("Broadcasting received broadcast packet"));
 292
 293   /* If the packet is originated from our primary route we are
 294      not allowed to send the packet. */
 295   id = silc_id_str2id(packet->src_id, packet->src_id_len, packet->src_id_type);
 296   if (id && SILC_ID_SERVER_COMPARE(id, server->router->id)) {
 297     idata = (SilcIDListData)sock->user_data;
 298
 299     silc_buffer_push(buffer, buffer->data - buffer->head);
 300     silc_packet_send_prepare(sock, 0, 0, buffer->len);
 301     silc_buffer_put(sock->outbuf, buffer->data, buffer->len);
 302     silc_packet_encrypt(idata->send_key, idata->hmac,
 303                         sock->outbuf, sock->outbuf->len);
 304
 305     SILC_LOG_HEXDUMP(("Broadcasted packet, len %d", sock->outbuf->len),
 306                      sock->outbuf->data, sock->outbuf->len);
 307
 308     /* Now actually send the packet */
 309     silc_server_packet_send_real(server, sock, TRUE);
 310     silc_free(id);
 311     return;
 312   }
 313
 314   SILC_LOG_DEBUG(("Will not broadcast to primary route since it is the "
 315                   "original sender of this packet"));
 316   silc_free(id);
 317 }
 318
 319 /* Routes received packet to `sock'. This is used to route the packets that
 320    router receives but are not destined to it. */
 321
 322 void silc_server_packet_route(SilcServer server,
 323                               SilcSocketConnection sock,
 324                               SilcPacketContext *packet)
 325 {
 326   SilcBuffer buffer = packet->buffer;
 327   SilcIDListData idata;
 328
 329   SILC_LOG_DEBUG(("Routing received packet"));
 330
 331   idata = (SilcIDListData)sock->user_data;
 332
 333   silc_buffer_push(buffer, buffer->data - buffer->head);
 334   silc_packet_send_prepare(sock, 0, 0, buffer->len);
 335   silc_buffer_put(sock->outbuf, buffer->data, buffer->len);
 336   silc_packet_encrypt(idata->send_key, idata->hmac,
 337                       sock->outbuf, sock->outbuf->len);
 338
 339   SILC_LOG_HEXDUMP(("Routed packet, len %d", sock->outbuf->len),
 340                    sock->outbuf->data, sock->outbuf->len);
 341
 342   /* Now actually send the packet */
 343   silc_server_packet_send_real(server, sock, TRUE);
 344 }
 345
 346 /* Internal routine to actually create the channel packet and send it
 347    to network. This is common function in channel message sending. If
 348    `channel_message' is TRUE this encrypts the message as it is strictly
 349    a channel message. If FALSE normal encryption process is used. */
 350
 351 static void
 352 silc_server_packet_send_to_channel_real(SilcServer server,
 353                                         SilcSocketConnection sock,
 354                                         SilcPacketContext *packet,
 355                                         SilcCipher cipher,
 356                                         SilcHmac hmac,
 357                                         unsigned char *data,
 358                                         unsigned int data_len,
 359                                         int channel_message,
 360                                         int force_send)
 361 {
 362   packet->truelen = data_len + SILC_PACKET_HEADER_LEN +
 363     packet->src_id_len + packet->dst_id_len;
 364
 365   /* Prepare outgoing data buffer for packet sending */
 366   silc_packet_send_prepare(sock,
 367                            SILC_PACKET_HEADER_LEN +
 368                            packet->src_id_len +
 369                            packet->dst_id_len,
 370                            packet->padlen,
 371                            data_len);
 372
 373   packet->buffer = sock->outbuf;
 374
 375   /* Put the data to buffer, assemble and encrypt the packet. The packet
 376      is encrypted with normal session key shared with the client. */
 377   silc_buffer_put(sock->outbuf, data, data_len);
 378   silc_packet_assemble(packet);
 379   if (channel_message)
 380     silc_packet_encrypt(cipher, hmac, sock->outbuf, SILC_PACKET_HEADER_LEN +
 381                         packet->src_id_len + packet->dst_id_len +
 382                         packet->padlen);
 383   else
 384     silc_packet_encrypt(cipher, hmac, sock->outbuf, sock->outbuf->len);
 385
 386   SILC_LOG_HEXDUMP(("Channel packet, len %d", sock->outbuf->len),
 387                    sock->outbuf->data, sock->outbuf->len);
 388
 389   /* Now actually send the packet */
 390   silc_server_packet_send_real(server, sock, force_send);
 391 }
 392
 393 /* This routine is used by the server to send packets to channel. The
 394    packet sent with this function is distributed to all clients on
 395    the channel. Usually this is used to send notify messages to the
 396    channel, things like notify about new user joining to the channel.
 397    If `route' is FALSE then the packet is sent only locally and will not
 398    be routed anywhere (for router locally means cell wide). If `sender'
 399    is provided then the packet is not sent to that connection since it
 400    originally came from it. */
 401
 402 void silc_server_packet_send_to_channel(SilcServer server,
 403                                         SilcSocketConnection sender,
 404                                         SilcChannelEntry channel,
 405                                         SilcPacketType type,
 406                                         unsigned char route,
 407                                         unsigned char *data,
 408                                         unsigned int data_len,
 409                                         int force_send)
 410 {
 411   SilcSocketConnection sock = NULL;
 412   SilcPacketContext packetdata;
 413   SilcClientEntry client = NULL;
 414   SilcServerEntry *routed = NULL;
 415   SilcChannelClientEntry chl;
 416   SilcIDListData idata;
 417   unsigned int routed_count = 0;
 418
 419   /* This doesn't send channel message packets */
 420   if (type == SILC_PACKET_CHANNEL_MESSAGE)
 421     return;
 422
 423   SILC_LOG_DEBUG(("Sending packet to channel"));
 424
 425   /* Set the packet context pointers. */
 426   packetdata.flags = 0;
 427   packetdata.type = type;
 428   packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
 429   packetdata.src_id_len = SILC_ID_SERVER_LEN;
 430   packetdata.src_id_type = SILC_ID_SERVER;
 431   packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
 432   packetdata.dst_id_len = SILC_ID_CHANNEL_LEN;
 433   packetdata.dst_id_type = SILC_ID_CHANNEL;
 434   packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
 435     packetdata.src_id_len + packetdata.dst_id_len;
 436   packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen);
 437
 438   /* If there are global users in the channel we will send the message
 439      first to our router for further routing. */
 440   if (route && server->server_type == SILC_SERVER && !server->standalone &&
 441       channel->global_users) {
 442     SilcServerEntry router;
 443
 444     /* Get data used in packet header encryption, keys and stuff. */
 445     router = server->router;
 446     sock = (SilcSocketConnection)router->connection;
 447     idata = (SilcIDListData)router;
 448
 449     if (sock != sender) {
 450       SILC_LOG_DEBUG(("Sending channel message to router for routing"));
 451
 452       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 453                                               idata->send_key, idata->hmac,
 454                                               data, data_len, FALSE,
 455                                               force_send);
 456     }
 457   }
 458
 459   /* Send the message to clients on the channel's client list. */
 460   silc_list_start(channel->user_list);
 461   while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END) {
 462     client = chl->client;
 463
 464     /* If client has router set it is not locally connected client and
 465        we will route the message to the router set in the client. Though,
 466        send locally connected server in all cases. */
 467     if (server->server_type == SILC_ROUTER && client && client->router &&
 468         ((!route && client->router->router == server->id_entry) || route)) {
 469       int k;
 470
 471       /* Check if we have sent the packet to this route already */
 472       for (k = 0; k < routed_count; k++)
 473         if (routed[k] == client->router)
 474           break;
 475       if (k < routed_count)
 476         continue;
 477
 478       /* Get data used in packet header encryption, keys and stuff. */
 479       sock = (SilcSocketConnection)client->router->connection;
 480       idata = (SilcIDListData)client->router;
 481
 482       if (sender && sock == sender)
 483         continue;
 484
 485       /* Send the packet */
 486       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 487                                               idata->send_key, idata->hmac,
 488                                               data, data_len, FALSE,
 489                                               force_send);
 490
 491       /* We want to make sure that the packet is routed to same router
 492          only once. Mark this route as sent route. */
 493       k = routed_count;
 494       routed = silc_realloc(routed, sizeof(*routed) * (k + 1));
 495       routed[k] = client->router;
 496       routed_count++;
 497
 498       continue;
 499     }
 500
 501     if (client && client->router)
 502       continue;
 503
 504     /* Send to locally connected client */
 505     if (client) {
 506
 507       /* Get data used in packet header encryption, keys and stuff. */
 508       sock = (SilcSocketConnection)client->connection;
 509       idata = (SilcIDListData)client;
 510
 511       if (sender && sock == sender)
 512         continue;
 513
 514       /* Send the packet */
 515       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 516                                               idata->send_key, idata->hmac,
 517                                               data, data_len, FALSE,
 518                                               force_send);
 519     }
 520   }
 521
 522   if (routed_count)
 523     silc_free(routed);
 524   silc_free(packetdata.src_id);
 525   silc_free(packetdata.dst_id);
 526 }
 527
 528 /* This routine is explicitly used to relay messages to some channel.
 529    Packets sent with this function we have received earlier and are
 530    totally encrypted. This just sends the packet to all clients on
 531    the channel. If the sender of the packet is someone on the channel
 532    the message will not be sent to that client. The SILC Packet header
 533    is encrypted with the session key shared between us and the client.
 534    MAC is also computed before encrypting the header. Rest of the
 535    packet will be untouched. */
 536
 537 void silc_server_packet_relay_to_channel(SilcServer server,
 538                                          SilcSocketConnection sender_sock,
 539                                          SilcChannelEntry channel,
 540                                          void *sender,
 541                                          SilcIdType sender_type,
 542                                          unsigned char *data,
 543                                          unsigned int data_len,
 544                                          int force_send)
 545 {
 546   int found = FALSE;
 547   SilcSocketConnection sock = NULL;
 548   SilcPacketContext packetdata;
 549   SilcClientEntry client = NULL;
 550   SilcServerEntry *routed = NULL;
 551   SilcChannelClientEntry chl;
 552   unsigned int routed_count = 0;
 553   SilcIDListData idata;
 554
 555   SILC_LOG_DEBUG(("Relaying packet to channel"));
 556
 557   /* Set the packet context pointers. */
 558   packetdata.flags = 0;
 559   packetdata.type = SILC_PACKET_CHANNEL_MESSAGE;
 560   packetdata.src_id = silc_id_id2str(sender, sender_type);
 561   packetdata.src_id_len = silc_id_get_len(sender_type);
 562   packetdata.src_id_type = sender_type;
 563   packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
 564   packetdata.dst_id_len = SILC_ID_CHANNEL_LEN;
 565   packetdata.dst_id_type = SILC_ID_CHANNEL;
 566   packetdata.padlen = SILC_PACKET_PADLEN((SILC_PACKET_HEADER_LEN +
 567                                           packetdata.src_id_len +
 568                                           packetdata.dst_id_len));
 569
 570   /* If there are global users in the channel we will send the message
 571      first to our router for further routing. */
 572   if (server->server_type == SILC_SERVER && !server->standalone &&
 573       channel->global_users) {
 574     SilcServerEntry router;
 575
 576     router = server->router;
 577
 578     /* Check that the sender is not our router. */
 579     if (sender_sock != (SilcSocketConnection)router->connection) {
 580
 581       /* Get data used in packet header encryption, keys and stuff. */
 582       sock = (SilcSocketConnection)router->connection;
 583       idata = (SilcIDListData)router;
 584
 585       SILC_LOG_DEBUG(("Sending channel message to router for routing"));
 586
 587       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 588                                               idata->send_key, idata->hmac,
 589                                               data, data_len, TRUE,
 590                                               force_send);
 591     }
 592   }
 593
 594   /* Send the message to clients on the channel's client list. */
 595   silc_list_start(channel->user_list);
 596   while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END) {
 597     client = chl->client;
 598
 599     if (client) {
 600
 601       /* If sender is one on the channel do not send it the packet. */
 602       if (!found && !SILC_ID_CLIENT_COMPARE(client->id, sender)) {
 603         found = TRUE;
 604         continue;
 605       }
 606
 607       /* If the client has set router it means that it is not locally
 608          connected client and we will route the packet further. */
 609       if (server->server_type == SILC_ROUTER && client->router) {
 610         int k;
 611
 612         /* Sender maybe server as well so we want to make sure that
 613            we won't send the message to the server it came from. */
 614         if (!found && !SILC_ID_SERVER_COMPARE(client->router->id, sender)) {
 615           found = TRUE;
 616           continue;
 617         }
 618
 619         /* Check if we have sent the packet to this route already */
 620         for (k = 0; k < routed_count; k++)
 621           if (routed[k] == client->router)
 622             break;
 623         if (k < routed_count)
 624           continue;
 625
 626         /* Get data used in packet header encryption, keys and stuff. */
 627         sock = (SilcSocketConnection)client->router->connection;
 628         idata = (SilcIDListData)client->router;
 629
 630         if (sender_sock && sock == sender_sock)
 631           continue;
 632
 633         SILC_LOG_DEBUG(("Relaying packet to client ID(%s) %s (%s)",
 634                         silc_id_render(client->id, SILC_ID_CLIENT),
 635                         sock->hostname, sock->ip));
 636
 637         /* We want to make sure that the packet is routed to same router
 638            only once. Mark this route as sent route. */
 639         k = routed_count;
 640         routed = silc_realloc(routed, sizeof(*routed) * (k + 1));
 641         routed[k] = client->router;
 642         routed_count++;
 643
 644         /* If the remote connection is router then we'll decrypt the
 645            channel message and re-encrypt it with the session key shared
 646            between us and the remote router. This is done because the
 647            channel keys are cell specific and we have different channel
 648            key than the remote router has. */
 649         if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
 650
 651           /* If private key mode is not set then decrypt the packet
 652              and re-encrypt it */
 653           if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
 654             unsigned char *tmp = silc_calloc(data_len, sizeof(*data));
 655             memcpy(tmp, data, data_len);
 656
 657             /* Decrypt the channel message (we don't check the MAC) */
 658             if (!silc_channel_payload_decrypt(tmp, data_len,
 659                                               channel->channel_key,
 660                                               NULL)) {
 661               memset(tmp, 0, data_len);
 662               silc_free(tmp);
 663               continue;
 664             }
 665
 666             /* Now re-encrypt and send it to the router */
 667             silc_server_packet_send_srcdest(server, sock,
 668                                             SILC_PACKET_CHANNEL_MESSAGE, 0,
 669                                             sender, sender_type,
 670                                             channel->id, SILC_ID_CHANNEL,
 671                                             tmp, data_len, force_send);
 672
 673             /* Free the copy of the channel message */
 674             memset(tmp, 0, data_len);
 675             silc_free(tmp);
 676           } else {
 677             /* Private key mode is set, we don't have the channel key, so
 678                just re-encrypt the entire packet and send it to the router. */
 679             silc_server_packet_send_dest(server, sock,
 680                                          SILC_PACKET_CHANNEL_MESSAGE, 0,
 681                                          channel->id, SILC_ID_CHANNEL,
 682                                          data, data_len, force_send);
 683           }
 684           continue;
 685         }
 686
 687         /* Send the packet (to normal server) */
 688         silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 689                                                 idata->send_key, idata->hmac,
 690                                                 data, data_len, TRUE,
 691                                                 force_send);
 692
 693         continue;
 694       }
 695
 696       if (client && client->router)
 697         continue;
 698
 699       /* Get data used in packet header encryption, keys and stuff. */
 700       sock = (SilcSocketConnection)client->connection;
 701       idata = (SilcIDListData)client;
 702
 703       if (sender_sock && sock == sender_sock)
 704         continue;
 705
 706       SILC_LOG_DEBUG(("Sending packet to client ID(%s) %s (%s)",
 707                       silc_id_render(client->id, SILC_ID_CLIENT),
 708                       sock->hostname, sock->ip));
 709
 710       /* Send the packet */
 711       silc_server_packet_send_to_channel_real(server, sock, &packetdata,
 712                                               idata->send_key, idata->hmac,
 713                                               data, data_len, TRUE,
 714                                               force_send);
 715     }
 716   }
 717
 718   silc_free(packetdata.src_id);
 719   silc_free(packetdata.dst_id);
 720 }
 721
 722 /* This function is used to send packets strictly to all local clients
 723    on a particular channel.  This is used for example to distribute new
 724    channel key to all our locally connected clients on the channel.
 725    The packets are always encrypted with the session key shared between
 726    the client, this means these are not _to the channel_ but _to the client_
 727    on the channel. */
 728
 729 void silc_server_packet_send_local_channel(SilcServer server,
 730                                            SilcChannelEntry channel,
 731                                            SilcPacketType type,
 732                                            SilcPacketFlags flags,
 733                                            unsigned char *data,
 734                                            unsigned int data_len,
 735                                            int force_send)
 736 {
 737   SilcChannelClientEntry chl;
 738   SilcSocketConnection sock = NULL;
 739
 740   SILC_LOG_DEBUG(("Start"));
 741
 742   /* Send the message to clients on the channel's client list. */
 743   silc_list_start(channel->user_list);
 744   while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END) {
 745     if (chl->client && !chl->client->router) {
 746       sock = (SilcSocketConnection)chl->client->connection;
 747
 748       /* Send the packet to the client */
 749       silc_server_packet_send_dest(server, sock, type, flags, chl->client->id,
 750                                    SILC_ID_CLIENT, data, data_len,
 751                                    force_send);
 752     }
 753   }
 754 }
 755
 756 /* Routine used to send (relay, route) private messages to some destination.
 757    If the private message key does not exist then the message is re-encrypted,
 758    otherwise we just pass it along. This really is not used to send new
 759    private messages (as server does not send them) but to relay received
 760    private messages. */
 761
 762 void silc_server_send_private_message(SilcServer server,
 763                                       SilcSocketConnection dst_sock,
 764                                       SilcCipher cipher,
 765                                       SilcHmac hmac,
 766                                       SilcPacketContext *packet)
 767 {
 768   SilcBuffer buffer = packet->buffer;
 769
 770   /* Re-encrypt and send if private messge key does not exist */
 771   if ((packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY) == FALSE) {
 772
 773     silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
 774                      + packet->dst_id_len + packet->padlen);
 775     silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
 776     silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
 777
 778     /* Re-encrypt packet */
 779     silc_packet_encrypt(cipher, hmac, dst_sock->outbuf, buffer->len);
 780
 781     /* Send the packet */
 782     silc_server_packet_send_real(server, dst_sock, FALSE);
 783
 784   } else {
 785     /* Key exist so just send it */
 786     silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
 787                      + packet->dst_id_len + packet->padlen);
 788     silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
 789     silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
 790     silc_server_packet_send_real(server, dst_sock, FALSE);
 791   }
 792 }
 793
 794 /* Sends current motd to client */
 795
 796 void silc_server_send_motd(SilcServer server,
 797                            SilcSocketConnection sock)
 798 {
 799   char *motd;
 800   int motd_len;
 801
 802   if (server->config && server->config->motd &&
 803       server->config->motd->motd_file) {
 804
 805     motd = silc_file_read(server->config->motd->motd_file, &motd_len);
 806     if (!motd)
 807       return;
 808
 809     silc_server_send_notify(server, sock, FALSE, SILC_NOTIFY_TYPE_MOTD, 1,
 810                             motd, motd_len);
 811     silc_free(motd);
 812   }
 813 }
 814
 815 /* Sends error message. Error messages may or may not have any
 816    implications. */
 817
 818 void silc_server_send_error(SilcServer server,
 819                             SilcSocketConnection sock,
 820                             const char *fmt, ...)
 821 {
 822   va_list ap;
 823   unsigned char buf[4096];
 824
 825   memset(buf, 0, sizeof(buf));
 826   va_start(ap, fmt);
 827   vsprintf(buf, fmt, ap);
 828   va_end(ap);
 829
 830   silc_server_packet_send(server, sock, SILC_PACKET_ERROR, 0,
 831                           buf, strlen(buf), FALSE);
 832 }
 833
 834 /* Sends notify message. If format is TRUE the variable arguments are
 835    formatted and the formatted string is sent as argument payload. If it is
 836    FALSE then each argument is sent as separate argument and their format
 837    in the argument list must be { argument data, argument length }. */
 838
 839 void silc_server_send_notify(SilcServer server,
 840                              SilcSocketConnection sock,
 841                              int broadcast,
 842                              SilcNotifyType type,
 843                              unsigned int argc, ...)
 844 {
 845   va_list ap;
 846   SilcBuffer packet;
 847
 848   va_start(ap, argc);
 849
 850   packet = silc_notify_payload_encode(type, argc, ap);
 851   silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY, 0,
 852                           packet->data, packet->len, FALSE);
 853   silc_buffer_free(packet);
 854 }
 855
 856 /* Send CHANNEL_CHANGE notify type. This tells the receiver to replace the
 857    `old_id' with the `new_id'. */
 858
 859 void silc_server_send_notify_channel_change(SilcServer server,
 860                                             SilcSocketConnection sock,
 861                                             int broadcast,
 862                                             SilcChannelID *old_id,
 863                                             SilcChannelID *new_id,
 864                                             unsigned int id_len)
 865 {
 866   SilcBuffer idp1, idp2;
 867
 868   idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CHANNEL);
 869   idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CHANNEL);
 870
 871   silc_server_send_notify(server, sock, broadcast,
 872                           SILC_NOTIFY_TYPE_CHANNEL_CHANGE,
 873                           2, idp1->data, idp1->len, idp2->data, idp2->len);
 874   silc_buffer_free(idp1);
 875   silc_buffer_free(idp2);
 876 }
 877
 878 /* Send NICK_CHANGE notify type. This tells the receiver to replace the
 879    `old_id' with the `new_id'. */
 880
 881 void silc_server_send_notify_nick_change(SilcServer server,
 882                                          SilcSocketConnection sock,
 883                                          int broadcast,
 884                                          SilcClientID *old_id,
 885                                          SilcClientID *new_id,
 886                                          unsigned int id_len)
 887 {
 888   SilcBuffer idp1, idp2;
 889
 890   idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CLIENT);
 891   idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CLIENT);
 892
 893   silc_server_send_notify(server, sock, broadcast,
 894                           SILC_NOTIFY_TYPE_NICK_CHANGE,
 895                           2, idp1->data, idp1->len, idp2->data, idp2->len);
 896   silc_buffer_free(idp1);
 897   silc_buffer_free(idp2);
 898 }
 899
 900 /* Sends JOIN notify type. This tells that new client by `client_id' ID
 901    has joined to the `channel'. */
 902
 903 void silc_server_send_notify_join(SilcServer server,
 904                                   SilcSocketConnection sock,
 905                                   int broadcast,
 906                                   SilcChannelEntry channel,
 907                                   SilcClientID *client_id,
 908                                   unsigned int client_id_len)
 909 {
 910   SilcBuffer idp1, idp2;
 911
 912   idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
 913   idp2 = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
 914   silc_server_send_notify(server, sock, broadcast, SILC_NOTIFY_TYPE_JOIN,
 915                           2, idp1->data, idp1->len,
 916                           idp2->data, idp2->len);
 917   silc_buffer_free(idp1);
 918   silc_buffer_free(idp2);
 919 }
 920
 921 /* Sends LEAVE notify type. This tells that `client_id' has left the
 922    `channel'. The Notify packet is always destined to the channel. */
 923
 924 void silc_server_send_notify_leave(SilcServer server,
 925                                    SilcSocketConnection sock,
 926                                    int broadcast,
 927                                    SilcChannelEntry channel,
 928                                    SilcClientID *client_id,
 929                                    unsigned int client_id_len)
 930 {
 931   SilcBuffer idp;
 932
 933   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
 934   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
 935                                SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_LEAVE,
 936                                1, idp->data, idp->len);
 937   silc_buffer_free(idp);
 938 }
 939
 940 /* Sends CMODE_CHANGE notify type. This tells that `client_id' changed the
 941    `channel' mode to `mode. The Notify packet is always destined to
 942    the channel. */
 943
 944 void silc_server_send_notify_cmode(SilcServer server,
 945                                    SilcSocketConnection sock,
 946                                    int broadcast,
 947                                    SilcChannelEntry channel,
 948                                    unsigned int mode_mask,
 949                                    SilcClientID *client_id,
 950                                    unsigned int client_id_len)
 951 {
 952   SilcBuffer idp;
 953   unsigned char mode[4];
 954
 955   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
 956   SILC_PUT32_MSB(mode_mask, mode);
 957
 958   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
 959                                SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_CMODE_CHANGE,
 960                                2, idp->data, idp->len,
 961                                mode, 4);
 962   silc_buffer_free(idp);
 963 }
 964
 965 /* Sends CUMODE_CHANGE notify type. This tells that `client_id' changed the
 966    `target' client's mode on `channel'. The Notify packet is always
 967    destined to the channel. */
 968
 969 void silc_server_send_notify_cumode(SilcServer server,
 970                                     SilcSocketConnection sock,
 971                                     int broadcast,
 972                                     SilcChannelEntry channel,
 973                                     unsigned int mode_mask,
 974                                     SilcClientID *client_id,
 975                                     unsigned int client_id_len,
 976                                     SilcClientID *target,
 977                                     unsigned int target_len)
 978 {
 979   SilcBuffer idp1, idp2;
 980   unsigned char mode[4];
 981
 982   idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
 983   idp2 = silc_id_payload_encode((void *)target, SILC_ID_CLIENT);
 984   SILC_PUT32_MSB(mode_mask, mode);
 985
 986   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
 987                                SILC_ID_CHANNEL,
 988                                SILC_NOTIFY_TYPE_CUMODE_CHANGE, 3,
 989                                idp1->data, idp1->len,
 990                                mode, 4,
 991                                idp2->data, idp2->len);
 992   silc_buffer_free(idp1);
 993   silc_buffer_free(idp2);
 994 }
 995
 996 /* Sends SIGNOFF notify type. This tells that `client_id' client has
 997    left SILC network. This function is used only between server and router
 998    traffic. This is not used to send the notify to the channel for
 999    client. The `message may be NULL. */
1000
1001 void silc_server_send_notify_signoff(SilcServer server,
1002                                      SilcSocketConnection sock,
1003                                      int broadcast,
1004                                      SilcClientID *client_id,
1005                                      unsigned int client_id_len,
1006                                      char *message)
1007 {
1008   SilcBuffer idp;
1009
1010   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1011   silc_server_send_notify(server, sock, broadcast,
1012                           SILC_NOTIFY_TYPE_SIGNOFF,
1013                           message ? 2 : 1, idp->data, idp->len,
1014                           message, message ? strlen(message): 0);
1015   silc_buffer_free(idp);
1016 }
1017
1018 /* Sends SERVER_SIGNOFF notify type. This tells that `server_id' server
1019    has quit SILC network. */
1020
1021 void silc_server_send_notify_server_signoff(SilcServer server,
1022                                             SilcSocketConnection sock,
1023                                             int broadcast,
1024                                             SilcServerID *server_id,
1025                                             unsigned int server_id_len)
1026 {
1027   SilcBuffer idp;
1028
1029   idp = silc_id_payload_encode((void *)server_id, SILC_ID_SERVER);
1030   silc_server_send_notify(server, sock, broadcast,
1031                           SILC_NOTIFY_TYPE_SERVER_SIGNOFF,
1032                           1, idp->data, idp->len);
1033   silc_buffer_free(idp);
1034 }
1035
1036 /* Sends TOPIC_SET notify type. This tells that `client_id' changed
1037    the `channel's topic to `topic'. The Notify packet is always destined
1038    to the channel. This function is used to send the topic set notifies
1039    between routers. */
1040
1041 void silc_server_send_notify_topic_set(SilcServer server,
1042                                        SilcSocketConnection sock,
1043                                        int broadcast,
1044                                        SilcChannelEntry channel,
1045                                        SilcClientID *client_id,
1046                                        unsigned int client_id_len,
1047                                        char *topic)
1048 {
1049   SilcBuffer idp;
1050
1051   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1052   silc_server_send_notify(server, sock, broadcast,
1053                           SILC_NOTIFY_TYPE_SERVER_SIGNOFF,
1054                           topic ? 2 : 1,
1055                           idp->data, idp->len,
1056                           topic, topic ? strlen(topic) : 0);
1057   silc_buffer_free(idp);
1058 }
1059
1060 /* Send KICKED notify type. This tells that the `client_id' on `channel'
1061    was kicked off the channel.  The `comment' may indicate the reason
1062    for the kicking. This function is used only between server and router
1063    traffic. */
1064
1065 void silc_server_send_notify_kicked(SilcServer server,
1066                                     SilcSocketConnection sock,
1067                                     int broadcast,
1068                                     SilcChannelEntry channel,
1069                                     SilcClientID *client_id,
1070                                     unsigned int client_id_len,
1071                                     char *comment)
1072 {
1073   SilcBuffer idp;
1074
1075   idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1076   silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1077                                SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_KICKED,
1078                                comment ? 2 : 1, idp->data, idp->len,
1079                                comment, comment ? strlen(comment) : 0);
1080   silc_buffer_free(idp);
1081 }
1082
1083 /* Sends notify message destined to specific entity. */
1084
1085 void silc_server_send_notify_dest(SilcServer server,
1086                                   SilcSocketConnection sock,
1087                                   int broadcast,
1088                                   void *dest_id,
1089                                   SilcIdType dest_id_type,
1090                                   SilcNotifyType type,
1091                                   unsigned int argc, ...)
1092 {
1093   va_list ap;
1094   SilcBuffer packet;
1095
1096   va_start(ap, argc);
1097
1098   packet = silc_notify_payload_encode(type, argc, ap);
1099   silc_server_packet_send_dest(server, sock, SILC_PACKET_NOTIFY, 0,
1100                                dest_id, dest_id_type,
1101                                packet->data, packet->len, FALSE);
1102   silc_buffer_free(packet);
1103 }
1104
1105 /* Sends notify message to a channel. The notify message sent is
1106    distributed to all clients on the channel. If `route_notify' is TRUE
1107    then the notify may be routed to primary route or to some other routers.
1108    If FALSE it is assured that the notify is sent only locally. If `sender'
1109    is provided then the packet is not sent to that connection since it
1110    originally came from it. */
1111
1112 void silc_server_send_notify_to_channel(SilcServer server,
1113                                         SilcSocketConnection sender,
1114                                         SilcChannelEntry channel,
1115                                         unsigned char route_notify,
1116                                         SilcNotifyType type,
1117                                         unsigned int argc, ...)
1118 {
1119   va_list ap;
1120   SilcBuffer packet;
1121
1122   va_start(ap, argc);
1123
1124   packet = silc_notify_payload_encode(type, argc, ap);
1125   silc_server_packet_send_to_channel(server, sender, channel,
1126                                      SILC_PACKET_NOTIFY, route_notify,
1127                                      packet->data, packet->len, FALSE);
1128   silc_buffer_free(packet);
1129 }
1130
1131 /* Send notify message to all clients the client has joined. It is quaranteed
1132    that the message is sent only once to a client (ie. if a client is joined
1133    on two same channel it will receive only one notify message). Also, this
1134    sends only to local clients (locally connected if we are server, and to
1135    local servers if we are router). */
1136
1137 void silc_server_send_notify_on_channels(SilcServer server,
1138                                          SilcClientEntry client,
1139                                          SilcNotifyType type,
1140                                          unsigned int argc, ...)
1141 {
1142   int k;
1143   SilcSocketConnection sock = NULL;
1144   SilcPacketContext packetdata;
1145   SilcClientEntry c;
1146   SilcClientEntry *sent_clients = NULL;
1147   unsigned int sent_clients_count = 0;
1148   SilcServerEntry *routed = NULL;
1149   unsigned int routed_count = 0;
1150   SilcChannelEntry channel;
1151   SilcChannelClientEntry chl, chl2;
1152   SilcIDListData idata;
1153   SilcBuffer packet;
1154   unsigned char *data;
1155   unsigned int data_len;
1156   int force_send = FALSE;
1157   va_list ap;
1158
1159   SILC_LOG_DEBUG(("Start"));
1160
1161   if (!silc_list_count(client->channels))
1162     return;
1163
1164   va_start(ap, argc);
1165   packet = silc_notify_payload_encode(type, argc, ap);
1166   data = packet->data;
1167   data_len = packet->len;
1168
1169   /* Set the packet context pointers. */
1170   packetdata.flags = 0;
1171   packetdata.type = SILC_PACKET_NOTIFY;
1172   packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
1173   packetdata.src_id_len = SILC_ID_SERVER_LEN;
1174   packetdata.src_id_type = SILC_ID_SERVER;
1175
1176   silc_list_start(client->channels);
1177   while ((chl = silc_list_get(client->channels)) != SILC_LIST_END) {
1178     channel = chl->channel;
1179
1180     /* Send the message to all clients on the channel's client list. */
1181     silc_list_start(channel->user_list);
1182     while ((chl2 = silc_list_get(channel->user_list)) != SILC_LIST_END) {
1183       c = chl2->client;
1184
1185       /* Check if we have sent the packet to this client already */
1186       for (k = 0; k < sent_clients_count; k++)
1187         if (sent_clients[k] == c)
1188           break;
1189       if (k < sent_clients_count)
1190         continue;
1191
1192       /* If we are router and if this client has router set it is not
1193          locally connected client and we will route the message to the
1194          router set in the client. */
1195       if (c && c->router && server->server_type == SILC_ROUTER) {
1196         /* Check if we have sent the packet to this route already */
1197         for (k = 0; k < routed_count; k++)
1198           if (routed[k] == c->router)
1199             break;
1200         if (k < routed_count)
1201           continue;
1202
1203         /* Get data used in packet header encryption, keys and stuff. */
1204         sock = (SilcSocketConnection)c->router->connection;
1205         idata = (SilcIDListData)c->router;
1206
1207         packetdata.dst_id = silc_id_id2str(c->router->id, SILC_ID_SERVER);
1208         packetdata.dst_id_len = SILC_ID_SERVER_LEN;
1209         packetdata.dst_id_type = SILC_ID_SERVER;
1210         packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
1211           packetdata.src_id_len + packetdata.dst_id_len;
1212         packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen);
1213
1214         /* Send the packet */
1215         silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1216                                                 idata->send_key, idata->hmac,
1217                                                 data, data_len, FALSE,
1218                                                 force_send);
1219
1220         silc_free(packetdata.dst_id);
1221
1222         /* We want to make sure that the packet is routed to same router
1223            only once. Mark this route as sent route. */
1224         k = routed_count;
1225         routed = silc_realloc(routed, sizeof(*routed) * (k + 1));
1226         routed[k] = c->router;
1227         routed_count++;
1228
1229         continue;
1230       }
1231
1232       if (c && c->router)
1233         continue;
1234
1235       /* Send to locally connected client */
1236       if (c) {
1237
1238         /* Get data used in packet header encryption, keys and stuff. */
1239         sock = (SilcSocketConnection)c->connection;
1240         idata = (SilcIDListData)c;
1241
1242         packetdata.dst_id = silc_id_id2str(c->id, SILC_ID_CLIENT);
1243         packetdata.dst_id_len = SILC_ID_CLIENT_LEN;
1244         packetdata.dst_id_type = SILC_ID_CLIENT;
1245         packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
1246           packetdata.src_id_len + packetdata.dst_id_len;
1247         packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen);
1248
1249         /* Send the packet */
1250         silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1251                                                 idata->send_key, idata->hmac,
1252                                                 data, data_len, FALSE,
1253                                                 force_send);
1254
1255         silc_free(packetdata.dst_id);
1256
1257         /* Make sure that we send the notify only once per client. */
1258         sent_clients = silc_realloc(sent_clients, sizeof(*sent_clients) *
1259                                     (sent_clients_count + 1));
1260         sent_clients[sent_clients_count] = c;
1261         sent_clients_count++;
1262       }
1263     }
1264   }
1265
1266   if (routed_count)
1267     silc_free(routed);
1268   if (sent_clients_count)
1269     silc_free(sent_clients);
1270   silc_free(packetdata.src_id);
1271 }
1272
1273 /* Sends New ID Payload to remote end. The packet is used to distribute
1274    information about new registered clients, servers, channel etc. usually
1275    to routers so that they can keep these information up to date.
1276    If the argument `broadcast' is TRUE then the packet is sent as
1277    broadcast packet. */
1278
1279 void silc_server_send_new_id(SilcServer server,
1280                              SilcSocketConnection sock,
1281                              int broadcast,
1282                              void *id, SilcIdType id_type,
1283                              unsigned int id_len)
1284 {
1285   SilcBuffer idp;
1286
1287   SILC_LOG_DEBUG(("Start"));
1288
1289   idp = silc_id_payload_encode(id, id_type);
1290   silc_server_packet_send(server, sock, SILC_PACKET_NEW_ID,
1291                           broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1292                           idp->data, idp->len, FALSE);
1293   silc_buffer_free(idp);
1294 }
1295
1296 /* Send New Channel Payload to notify about newly created channel in the
1297    SILC network. Normal server nevers sends this packet. Router uses this
1298    to notify other routers in the network about new channel. This packet
1299    is broadcasted. */
1300
1301 void silc_server_send_new_channel(SilcServer server,
1302                                   SilcSocketConnection sock,
1303                                   int broadcast,
1304                                   char *channel_name,
1305                                   void *channel_id,
1306                                   unsigned int channel_id_len)
1307 {
1308   SilcBuffer packet;
1309   unsigned char *cid;
1310   unsigned int name_len = strlen(channel_name);
1311
1312   SILC_LOG_DEBUG(("Start"));
1313
1314   cid = silc_id_id2str(channel_id, SILC_ID_CHANNEL);
1315   if (!cid)
1316     return;
1317
1318   packet = silc_buffer_alloc(2 + 2 + name_len + channel_id_len);
1319   silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1320   silc_buffer_format(packet,
1321                      SILC_STR_UI_SHORT(name_len),
1322                      SILC_STR_UI_XNSTRING(channel_name, name_len),
1323                      SILC_STR_UI_SHORT(channel_id_len),
1324                      SILC_STR_UI_XNSTRING(cid, channel_id_len),
1325                      SILC_STR_END);
1326
1327
1328   silc_server_packet_send(server, sock, SILC_PACKET_NEW_CHANNEL,
1329                           broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1330                           packet->data, packet->len, FALSE);
1331
1332   silc_free(cid);
1333   silc_buffer_free(packet);
1334 }
1335
1336 /* Send Channel Key payload to distribute the new channel key. Normal server
1337    sends this to router when new client joins to existing channel. Router
1338    sends this to the local server who sent the join command in case where
1339    the channel did not exist yet. Both normal and router servers uses this
1340    also to send this to locally connected clients on the channel. This
1341    must not be broadcasted packet. Routers do not send this to each other.
1342    If `sender is provided then the packet is not sent to that connection since
1343    it originally came from it. */
1344
1345 void silc_server_send_channel_key(SilcServer server,
1346                                   SilcSocketConnection sender,
1347                                   SilcChannelEntry channel,
1348                                   unsigned char route)
1349 {
1350   SilcBuffer packet;
1351   unsigned char *chid;
1352   unsigned int tmp_len;
1353
1354   SILC_LOG_DEBUG(("Start"));
1355
1356   chid = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
1357   if (!chid)
1358     return;
1359
1360   /* Encode channel key packet */
1361   tmp_len = strlen(channel->channel_key->cipher->name);
1362   packet = silc_channel_key_payload_encode(SILC_ID_CHANNEL_LEN, chid, tmp_len,
1363                                            channel->channel_key->cipher->name,
1364                                            channel->key_len / 8, channel->key);
1365
1366   silc_server_packet_send_to_channel(server, sender, channel,
1367                                      SILC_PACKET_CHANNEL_KEY,
1368                                      route, packet->data, packet->len, FALSE);
1369   silc_buffer_free(packet);
1370   silc_free(chid);
1371 }
1372
1373 /* Generic function to send any command. The arguments must be sent already
1374    encoded into correct form in correct order. */
1375
1376 void silc_server_send_command(SilcServer server,
1377                               SilcSocketConnection sock,
1378                               SilcCommand command,
1379                               unsigned int argc, ...)
1380 {
1381   SilcBuffer packet;
1382   va_list ap;
1383
1384   va_start(ap, argc);
1385
1386   packet = silc_command_payload_encode_vap(command, 0, argc, ap);
1387   silc_server_packet_send(server, sock, SILC_PACKET_COMMAND, 0,
1388                           packet->data, packet->len, TRUE);
1389   silc_buffer_free(packet);
1390 }
1391
1392 /* Send the heartbeat packet. */
1393
1394 void silc_server_send_heartbeat(SilcServer server,
1395                                 SilcSocketConnection sock)
1396 {
1397   silc_server_packet_send(server, sock, SILC_PACKET_HEARTBEAT, 0,
1398                           NULL, 0, FALSE);
1399 }
1400
1401 /* Routine used to send (relay, route) key agreement packets to some
1402    destination. */
1403
1404 void silc_server_send_key_agreement(SilcServer server,
1405                                     SilcSocketConnection dst_sock,
1406                                     SilcCipher cipher,
1407                                     SilcHmac hmac,
1408                                     SilcPacketContext *packet)
1409 {
1410   silc_buffer_push(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1411                    + packet->dst_id_len + packet->padlen);
1412   silc_packet_send_prepare(dst_sock, 0, 0, packet->buffer->len);
1413   silc_buffer_put(dst_sock->outbuf, packet->buffer->data, packet->buffer->len);
1414
1415   /* Re-encrypt packet */
1416   silc_packet_encrypt(cipher, hmac, dst_sock->outbuf, packet->buffer->len);
1417
1418   /* Send the packet */
1419   silc_server_packet_send_real(server, dst_sock, FALSE);
1420 }
1421
1422 /* Routine used to send (relay, route) private message key packets to some
1423    destination. */
1424
1425 void silc_server_send_private_message_key(SilcServer server,
1426                                           SilcSocketConnection dst_sock,
1427                                           SilcCipher cipher,
1428                                           SilcHmac hmac,
1429                                           SilcPacketContext *packet)
1430 {
1431   silc_buffer_push(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1432                    + packet->dst_id_len + packet->padlen);
1433   silc_packet_send_prepare(dst_sock, 0, 0, packet->buffer->len);
1434   silc_buffer_put(dst_sock->outbuf, packet->buffer->data, packet->buffer->len);
1435
1436   /* Re-encrypt packet */
1437   silc_packet_encrypt(cipher, hmac, dst_sock->outbuf, packet->buffer->len);
1438
1439   /* Send the packet */
1440   silc_server_packet_send_real(server, dst_sock, FALSE);
1441 }