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