apps/silcd/server.c

   1 /*
   2
   3   server.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 1997 - 2008 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; version 2 of the License.
  12
  13   This program is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18 */
  19
  20 #include "serverincludes.h"
  21 #include "server_internal.h"
  22
  23 /************************* Types and definitions ****************************/
  24
  25 SILC_TASK_CALLBACK(silc_server_get_stats);
  26 SILC_TASK_CALLBACK(silc_server_connect_router);
  27 SILC_TASK_CALLBACK(silc_server_connect_to_router_retry);
  28 SILC_TASK_CALLBACK(silc_server_do_rekey);
  29 SILC_TASK_CALLBACK(silc_server_purge_expired_clients);
  30 static void silc_server_accept_new_connection(SilcNetStatus status,
  31                                               SilcStream stream,
  32                                               void *context);
  33 static void silc_server_packet_parse_type(SilcServer server,
  34                                           SilcPacketStream sock,
  35                                           SilcPacket packet);
  36 static void silc_server_rekey(SilcServer server, SilcPacketStream sock,
  37                               SilcPacket packet);
  38
  39
  40 /************************ Static utility functions **************************/
  41
  42 /* SKE public key verification callback */
  43
  44 static void
  45 silc_server_verify_key(SilcSKE ske,
  46                        SilcPublicKey public_key,
  47                        void *context,
  48                        SilcSKEVerifyCbCompletion completion,
  49                        void *completion_context)
  50 {
  51   SilcPacketStream sock = context;
  52   SilcUnknownEntry entry = silc_packet_get_context(sock);
  53
  54   SILC_LOG_DEBUG(("Verifying public key"));
  55
  56   if (silc_pkcs_get_type(public_key) != SILC_SKE_PK_TYPE_SILC) {
  57     SILC_LOG_WARNING(("We don't support %s (%s) port %d public key type %d",
  58                       entry->hostname, entry->ip, entry->port,
  59                       silc_pkcs_get_type(public_key)));
  60     completion(ske, SILC_SKE_STATUS_UNSUPPORTED_PUBLIC_KEY,
  61                completion_context);
  62     return;
  63   }
  64
  65   /* We accept all keys without explicit verification */
  66   completion(ske, SILC_SKE_STATUS_OK, completion_context);
  67 }
  68
  69
  70 /************************ Packet engine callbacks ***************************/
  71
  72 /* Packet engine callback to receive a packet */
  73
  74 static SilcBool silc_server_packet_receive(SilcPacketEngine engine,
  75                                            SilcPacketStream stream,
  76                                            SilcPacket packet,
  77                                            void *callback_context,
  78                                            void *stream_context)
  79 {
  80   SilcServer server = callback_context;
  81   SilcIDListData idata = stream_context;
  82
  83   if (!idata)
  84     return FALSE;
  85
  86   /* Packets we do not handle */
  87   switch (packet->type) {
  88   case SILC_PACKET_HEARTBEAT:
  89   case SILC_PACKET_SUCCESS:
  90   case SILC_PACKET_FAILURE:
  91   case SILC_PACKET_REJECT:
  92   case SILC_PACKET_KEY_EXCHANGE:
  93   case SILC_PACKET_KEY_EXCHANGE_1:
  94   case SILC_PACKET_KEY_EXCHANGE_2:
  95   case SILC_PACKET_REKEY_DONE:
  96   case SILC_PACKET_CONNECTION_AUTH:
  97     return FALSE;
  98     break;
  99   }
 100
 101   /* Only specific packets can come without source ID present. */
 102   if ((!packet->src_id ||
 103        !(idata->status & SILC_IDLIST_STATUS_REGISTERED)) &&
 104       packet->type != SILC_PACKET_NEW_CLIENT &&
 105       packet->type != SILC_PACKET_NEW_SERVER &&
 106       packet->type != SILC_PACKET_RESUME_CLIENT &&
 107       packet->type != SILC_PACKET_CONNECTION_AUTH_REQUEST &&
 108       packet->type != SILC_PACKET_DISCONNECT)
 109     return FALSE;
 110
 111   /* NEW_CLIENT and NEW_SERVER are accepted only without source ID and
 112      for unregistered connection. */
 113   if (packet->src_id && (packet->type == SILC_PACKET_NEW_CLIENT ||
 114                          packet->type == SILC_PACKET_NEW_SERVER) &&
 115       (idata->status & SILC_IDLIST_STATUS_REGISTERED))
 116     return FALSE;
 117
 118   /* Ignore packets from disabled connection */
 119   if (idata->status & SILC_IDLIST_STATUS_DISABLED &&
 120       packet->type != SILC_PACKET_HEARTBEAT &&
 121       packet->type != SILC_PACKET_RESUME_ROUTER &&
 122       packet->type != SILC_PACKET_REKEY)
 123     return FALSE;
 124
 125   /* Check that the the current client ID is same as in the client's packet. */
 126   if (idata->conn_type == SILC_CONN_CLIENT) {
 127     SilcClientEntry client = (SilcClientEntry)silc_packet_get_context(stream);
 128     SilcClientID client_id;
 129
 130     if (client->id && packet->src_id &&
 131         silc_id_str2id(packet->src_id, packet->src_id_len,
 132                        packet->src_id_type, &client_id, sizeof(client_id))) {
 133       if (!SILC_ID_CLIENT_COMPARE(client->id, &client_id)) {
 134         SILC_LOG_DEBUG(("Packet source is not same as sender, packet %s",
 135                         silc_get_packet_name(packet->type)));
 136         return FALSE;
 137       }
 138     }
 139   }
 140
 141   if (server->server_type == SILC_ROUTER) {
 142     /* Route the packet if it is not destined to us. Other ID types but
 143        server are handled separately after processing them. */
 144     if (packet->dst_id &&
 145         !(packet->flags & SILC_PACKET_FLAG_BROADCAST) &&
 146         packet->dst_id_type == SILC_ID_SERVER &&
 147         idata->conn_type != SILC_CONN_CLIENT &&
 148         memcmp(packet->dst_id, server->id_string, server->id_string_len)) {
 149       SilcPacketStream conn;
 150       SilcServerID server_id;
 151
 152       silc_id_str2id(packet->dst_id, packet->dst_id_len, packet->dst_id_type,
 153                      &server_id, sizeof(server_id));
 154
 155       conn = silc_server_route_get(server, &server_id, SILC_ID_SERVER);
 156       if (!conn) {
 157         SILC_LOG_WARNING(("Packet to unknown server ID %s, dropped (no route)",
 158                           silc_id_render(&server_id, SILC_ID_SERVER)));
 159         return FALSE;
 160       }
 161
 162       silc_server_packet_route(server, conn, packet);
 163       silc_packet_free(packet);
 164       return TRUE;
 165     }
 166   }
 167
 168   /* Broadcast packet if it is marked as broadcast packet and it is
 169      originated from router and we are router. */
 170   if (server->server_type == SILC_ROUTER &&
 171       idata->conn_type == SILC_CONN_ROUTER &&
 172       packet->flags & SILC_PACKET_FLAG_BROADCAST) {
 173     /* Broadcast to our primary route */
 174     silc_server_packet_broadcast(server, SILC_PRIMARY_ROUTE(server), packet);
 175
 176     /* If we have backup routers then we need to feed all broadcast
 177        data to those servers. */
 178     silc_server_backup_broadcast(server, stream, packet);
 179   }
 180
 181   /* Process packet */
 182   silc_server_packet_parse_type(server, stream, packet);
 183
 184   return TRUE;
 185 }
 186
 187 /* Packet engine callback to indicate end of stream */
 188
 189 static void silc_server_packet_eos(SilcPacketEngine engine,
 190                                    SilcPacketStream stream,
 191                                    void *callback_context,
 192                                    void *stream_context)
 193 {
 194   SilcServer server = callback_context;
 195   SilcIDListData idata = silc_packet_get_context(stream);
 196
 197   SILC_LOG_DEBUG(("End of stream received"));
 198
 199   if (!idata)
 200     return;
 201
 202   if (server->router_conn && server->router_conn->sock == stream &&
 203       !server->router && server->standalone) {
 204     silc_server_create_connections(server);
 205     silc_server_free_sock_user_data(server, stream, NULL);
 206   } else {
 207     /* If backup disconnected then mark that resuming will not be allowed */
 208      if (server->server_type == SILC_ROUTER && !server->backup_router &&
 209          idata->conn_type == SILC_CONN_SERVER) {
 210       SilcServerEntry server_entry = (SilcServerEntry)idata;
 211       if (server_entry->server_type == SILC_BACKUP_ROUTER)
 212         server->backup_closed = TRUE;
 213     }
 214
 215     silc_server_free_sock_user_data(server, stream, NULL);
 216   }
 217
 218   silc_server_close_connection(server, stream);
 219 }
 220
 221 SILC_TASK_CALLBACK(silc_server_packet_error_timeout)
 222 {
 223   SilcServer server = app_context;
 224   SilcPacketStream stream = context;
 225   SilcIDListData idata = silc_packet_get_context(stream);
 226
 227   if (!idata)
 228     return;
 229
 230   if (server->router_conn && server->router_conn->sock == stream &&
 231       !server->router && server->standalone) {
 232     silc_server_create_connections(server);
 233   } else {
 234     /* If backup disconnected then mark that resuming will not be allowed */
 235      if (server->server_type == SILC_ROUTER && !server->backup_router &&
 236          idata->conn_type == SILC_CONN_SERVER) {
 237       SilcServerEntry server_entry = (SilcServerEntry)idata;
 238       if (server_entry->server_type == SILC_BACKUP_ROUTER)
 239         server->backup_closed = TRUE;
 240     }
 241
 242     silc_server_free_sock_user_data(server, stream, NULL);
 243   }
 244
 245   silc_server_close_connection(server, stream);
 246 }
 247
 248 /* Packet engine callback to indicate error */
 249
 250 static void silc_server_packet_error(SilcPacketEngine engine,
 251                                      SilcPacketStream stream,
 252                                      SilcPacketError error,
 253                                      void *callback_context,
 254                                      void *stream_context)
 255 {
 256   SilcServer server = callback_context;
 257   SilcIDListData idata = silc_packet_get_context(stream);
 258   SilcStream sock = silc_packet_stream_get_stream(stream);
 259   const char *ip;
 260   SilcUInt16 port;
 261
 262   if (!idata || !sock)
 263     return;
 264
 265   if (!silc_socket_stream_get_info(sock, NULL, NULL, &ip, &port))
 266     return;
 267
 268   SILC_LOG_ERROR(("Connection %s:%d [%s]: %s", ip, port,
 269                   SILC_CONNTYPE_STRING(idata->conn_type),
 270                   silc_packet_error_string(error)));
 271
 272   if (!silc_packet_stream_is_valid(stream))
 273     return;
 274
 275   silc_schedule_task_add_timeout(server->schedule,
 276                                  silc_server_packet_error_timeout,
 277                                  stream, 0, 0);
 278 }
 279
 280 /* Packet stream callbacks */
 281 static SilcPacketCallbacks silc_server_stream_cbs =
 282 {
 283   silc_server_packet_receive,
 284   silc_server_packet_eos,
 285   silc_server_packet_error
 286 };
 287
 288 /* Parses the packet type and calls what ever routines the packet type
 289    requires. This is done for all incoming packets. */
 290
 291 static void silc_server_packet_parse_type(SilcServer server,
 292                                           SilcPacketStream sock,
 293                                           SilcPacket packet)
 294 {
 295   SilcPacketType type = packet->type;
 296   SilcIDListData idata = silc_packet_get_context(sock);
 297
 298   SILC_LOG_DEBUG(("Received %s packet [flags %d]",
 299                   silc_get_packet_name(type), packet->flags));
 300
 301   /* Parse the packet type */
 302   switch (type) {
 303   case SILC_PACKET_NOTIFY:
 304     /*
 305      * Received notify packet. Server can receive notify packets from
 306      * router. Server then relays the notify messages to clients if needed.
 307      */
 308     if (packet->flags & SILC_PACKET_FLAG_LIST)
 309       silc_server_notify_list(server, sock, packet);
 310     else
 311       silc_server_notify(server, sock, packet);
 312     break;
 313
 314     /*
 315      * Private Message packets
 316      */
 317   case SILC_PACKET_PRIVATE_MESSAGE:
 318     /*
 319      * Received private message packet. The packet is coming from either
 320      * client or server.
 321      */
 322     if (packet->flags & SILC_PACKET_FLAG_LIST)
 323       break;
 324     idata->last_receive = time(NULL);
 325     silc_server_private_message(server, sock, packet);
 326     break;
 327
 328     /*
 329      * Channel packets
 330      */
 331   case SILC_PACKET_CHANNEL_MESSAGE:
 332     /*
 333      * Received channel message. Channel messages are special packets
 334      * (although probably most common ones) thus they are handled
 335      * specially.
 336      */
 337     if (packet->flags & SILC_PACKET_FLAG_LIST)
 338       break;
 339     idata->last_receive = time(NULL);
 340     silc_server_channel_message(server, sock, packet);
 341     break;
 342
 343     /*
 344      * Command packets
 345      */
 346   case SILC_PACKET_COMMAND:
 347     /*
 348      * Recived command. Processes the command request and allocates the
 349      * command context and calls the command.
 350      */
 351     if (packet->flags & SILC_PACKET_FLAG_LIST)
 352       break;
 353     server->stat.commands_received++;
 354     silc_server_command_process(server, sock, packet);
 355     break;
 356
 357   case SILC_PACKET_COMMAND_REPLY:
 358     /*
 359      * Received command reply packet. Received command reply to command. It
 360      * may be reply to command sent by us or reply to command sent by client
 361      * that we've routed further.
 362      */
 363     if (packet->flags & SILC_PACKET_FLAG_LIST)
 364       break;
 365     server->stat.commands_received++;
 366     silc_server_command_reply(server, sock, packet);
 367     break;
 368
 369   case SILC_PACKET_DISCONNECT:
 370     {
 371       SilcStatus status;
 372       char *message = NULL;
 373       const char *hostname, *ip;
 374
 375       if (packet->flags & SILC_PACKET_FLAG_LIST)
 376         break;
 377       if (silc_buffer_len(&packet->buffer) < 1)
 378         break;
 379
 380       status = (SilcStatus)packet->buffer.data[0];
 381       if (silc_buffer_len(&packet->buffer) > 1 &&
 382           silc_utf8_valid(packet->buffer.data + 1,
 383                           silc_buffer_len(&packet->buffer) - 1))
 384         message = silc_memdup(packet->buffer.data + 1,
 385                               silc_buffer_len(&packet->buffer) - 1);
 386
 387       if (!silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
 388                                        NULL, &hostname, &ip, NULL))
 389         break;
 390
 391       SILC_LOG_INFO(("Disconnected by %s (%s): %s (%d) %s", ip, hostname,
 392                      silc_get_status_message(status), status,
 393                      message ? message : ""));
 394
 395       silc_free(message);
 396
 397       /* Do not switch to backup in case of error */
 398       server->backup_noswitch = (status == SILC_STATUS_OK ? FALSE : TRUE);
 399
 400       /* If backup disconnected then mark that resuming will not be allowed */
 401       if (server->server_type == SILC_ROUTER && !server->backup_router &&
 402           idata->conn_type == SILC_CONN_SERVER) {
 403         SilcServerEntry server_entry = (SilcServerEntry)idata;
 404         if (server_entry->server_type == SILC_BACKUP_ROUTER)
 405           server->backup_closed = TRUE;
 406       }
 407
 408       /* Handle the disconnection from our end too */
 409       if (SILC_IS_LOCAL(idata))
 410         silc_server_free_sock_user_data(server, sock, NULL);
 411       silc_server_close_connection(server, sock);
 412       server->backup_noswitch = FALSE;
 413     }
 414     break;
 415
 416   case SILC_PACKET_CHANNEL_KEY:
 417     /*
 418      * Received key for channel. As channels are created by the router
 419      * the keys are as well. We will distribute the key to all of our
 420      * locally connected clients on the particular channel. Router
 421      * never receives this channel and thus is ignored.
 422      */
 423     if (packet->flags & SILC_PACKET_FLAG_LIST)
 424       break;
 425     silc_server_channel_key(server, sock, packet);
 426     break;
 427
 428   case SILC_PACKET_PRIVATE_MESSAGE_KEY:
 429     /*
 430      * Private message key packet.
 431      */
 432     if (packet->flags & SILC_PACKET_FLAG_LIST)
 433       break;
 434     silc_server_private_message_key(server, sock, packet);
 435     break;
 436
 437   case SILC_PACKET_CONNECTION_AUTH_REQUEST:
 438     /*
 439      * Connection authentication request packet. When we receive this packet
 440      * we will send to the other end information about our mandatory
 441      * authentication method for the connection. This packet maybe received
 442      * at any time.
 443      */
 444     if (packet->flags & SILC_PACKET_FLAG_LIST)
 445       break;
 446     silc_server_connection_auth_request(server, sock, packet);
 447     break;
 448
 449   case SILC_PACKET_NEW_ID:
 450     /*
 451      * Received New ID packet. This includes some new ID that has been
 452      * created. It may be for client, server or channel. This is the way
 453      * to distribute information about new registered entities in the
 454      * SILC network.
 455      */
 456     if (packet->flags & SILC_PACKET_FLAG_LIST)
 457       silc_server_new_id_list(server, sock, packet);
 458     else
 459       silc_server_new_id(server, sock, packet);
 460     break;
 461
 462   case SILC_PACKET_NEW_CLIENT:
 463     /*
 464      * Received new client packet. This includes client information that
 465      * we will use to create initial client ID. After creating new
 466      * ID we will send it to the client.
 467      */
 468     if (packet->flags & SILC_PACKET_FLAG_LIST)
 469       break;
 470     silc_server_new_client(server, sock, packet);
 471     break;
 472
 473   case SILC_PACKET_NEW_SERVER:
 474     /*
 475      * Received new server packet. This includes Server ID and some other
 476      * information that we may save. This is received after server has
 477      * connected to us.
 478      */
 479     if (packet->flags & SILC_PACKET_FLAG_LIST)
 480       break;
 481     silc_server_new_server(server, sock, packet);
 482     break;
 483
 484   case SILC_PACKET_NEW_CHANNEL:
 485     /*
 486      * Received new channel packet. Information about new channel in the
 487      * network are distributed using this packet.
 488      */
 489     if (packet->flags & SILC_PACKET_FLAG_LIST)
 490       silc_server_new_channel_list(server, sock, packet);
 491     else
 492       silc_server_new_channel(server, sock, packet);
 493     break;
 494
 495   case SILC_PACKET_HEARTBEAT:
 496     /*
 497      * Received heartbeat.
 498      */
 499     if (packet->flags & SILC_PACKET_FLAG_LIST)
 500       break;
 501     break;
 502
 503   case SILC_PACKET_KEY_AGREEMENT:
 504     /*
 505      * Received heartbeat.
 506      */
 507     if (packet->flags & SILC_PACKET_FLAG_LIST)
 508       break;
 509     silc_server_key_agreement(server, sock, packet);
 510     break;
 511
 512   case SILC_PACKET_REKEY:
 513     /*
 514      * Received re-key packet. The sender wants to regenerate the session
 515      * keys.
 516      */
 517     if (packet->flags & SILC_PACKET_FLAG_LIST)
 518       break;
 519     silc_server_rekey(server, sock, packet);
 520     break;
 521
 522   case SILC_PACKET_FTP:
 523     /* FTP packet */
 524     if (packet->flags & SILC_PACKET_FLAG_LIST)
 525       break;
 526     silc_server_ftp(server, sock, packet);
 527     break;
 528
 529   case SILC_PACKET_RESUME_CLIENT:
 530     /* Resume client */
 531     if (packet->flags & SILC_PACKET_FLAG_LIST)
 532       break;
 533     silc_server_resume_client(server, sock, packet);
 534     break;
 535
 536   case SILC_PACKET_RESUME_ROUTER:
 537     /* Resume router packet received. This packet is received for backup
 538        router resuming protocol. */
 539     if (packet->flags & SILC_PACKET_FLAG_LIST)
 540       break;
 541     silc_server_backup_resume_router(server, sock, packet);
 542     break;
 543
 544   default:
 545     SILC_LOG_ERROR(("Incorrect packet type %d, packet dropped", type));
 546     break;
 547   }
 548 }
 549
 550 /****************************** Server API **********************************/
 551
 552 /* Allocates a new SILC server object. This has to be done before the server
 553    can be used. After allocation one must call silc_server_init to initialize
 554    the server. The new allocated server object is returned to the new_server
 555    argument. */
 556
 557 SilcBool silc_server_alloc(SilcServer *new_server)
 558 {
 559   SilcServer server;
 560
 561   SILC_LOG_DEBUG(("Allocating new server object"));
 562
 563   server = silc_calloc(1, sizeof(*server));
 564   if (!server)
 565     return FALSE;
 566   server->server_type = SILC_SERVER;
 567   server->standalone = TRUE;
 568   server->local_list = silc_calloc(1, sizeof(*server->local_list));
 569   if (!server->local_list)
 570     return FALSE;
 571   server->global_list = silc_calloc(1, sizeof(*server->global_list));
 572   if (!server->global_list)
 573     return FALSE;
 574   server->pending_commands = silc_dlist_init();
 575   if (!server->pending_commands)
 576     return FALSE;
 577   server->listeners = silc_dlist_init();
 578   if (!server->listeners)
 579     return FALSE;
 580   server->repository = silc_skr_alloc();
 581   if (!server->repository)
 582     return FALSE;
 583   server->conns = silc_dlist_init();
 584   if (!server->conns)
 585     return FALSE;
 586   server->expired_clients = silc_dlist_init();
 587   if (!server->expired_clients)
 588     return FALSE;
 589
 590   *new_server = server;
 591
 592   return TRUE;
 593 }
 594
 595 /* Free's the SILC server object. This is called at the very end before
 596    the program ends. */
 597
 598 void silc_server_free(SilcServer server)
 599 {
 600   SilcList list;
 601   SilcIDCacheEntry cache;
 602   SilcIDListData idata;
 603
 604   SILC_LOG_DEBUG(("Free server %p", server));
 605
 606   if (!server)
 607     return;
 608
 609   silc_server_backup_free(server);
 610   silc_server_config_unref(&server->config_ref);
 611   if (server->rng)
 612     silc_rng_free(server->rng);
 613   if (server->public_key)
 614     silc_pkcs_public_key_free(server->public_key);
 615   if (server->private_key)
 616     silc_pkcs_private_key_free(server->private_key);
 617   if (server->pending_commands)
 618     silc_dlist_uninit(server->pending_commands);
 619   if (server->id_entry) {
 620     if (server->id_entry->data.sconn)
 621       silc_schedule_task_del_by_context(server->schedule,
 622                                         server->id_entry->data.sconn->sock);
 623     silc_idlist_del_server(server->local_list, server->id_entry);
 624   }
 625
 626   /* Delete all channels */
 627   if (silc_idcache_get_all(server->local_list->channels, &list)) {
 628     silc_list_start(list);
 629     while ((cache = silc_list_get(list)))
 630       silc_idlist_del_channel(server->local_list, cache->context);
 631   }
 632   if (silc_idcache_get_all(server->global_list->channels, &list)) {
 633     silc_list_start(list);
 634     while ((cache = silc_list_get(list)))
 635       silc_idlist_del_channel(server->global_list, cache->context);
 636   }
 637
 638   /* Delete all clients */
 639   if (silc_idcache_get_all(server->local_list->clients, &list)) {
 640     silc_list_start(list);
 641     while ((cache = silc_list_get(list))) {
 642       silc_schedule_task_del_by_context(server->schedule, cache->context);
 643       silc_idlist_del_client(server->local_list, cache->context);
 644     }
 645   }
 646   if (silc_idcache_get_all(server->global_list->clients, &list)) {
 647     silc_list_start(list);
 648     while ((cache = silc_list_get(list))) {
 649       silc_schedule_task_del_by_context(server->schedule, cache->context);
 650       silc_idlist_del_client(server->global_list, cache->context);
 651     }
 652   }
 653
 654   /* Delete all servers */
 655   if (silc_idcache_get_all(server->local_list->servers, &list)) {
 656     silc_list_start(list);
 657     while ((cache = silc_list_get(list))) {
 658       idata = (SilcIDListData)cache->context;
 659       if (idata->sconn)
 660         silc_schedule_task_del_by_context(server->schedule,
 661                                           idata->sconn->sock);
 662       silc_idlist_del_server(server->local_list, cache->context);
 663     }
 664   }
 665   if (silc_idcache_get_all(server->global_list->servers, &list)) {
 666     while ((cache = silc_list_get(list))) {
 667       idata = (SilcIDListData)cache->context;
 668       if (idata->sconn)
 669         silc_schedule_task_del_by_context(server->schedule,
 670                                           idata->sconn->sock);
 671       silc_idlist_del_server(server->global_list, cache->context);
 672     }
 673   }
 674
 675   silc_schedule_task_del_by_context(server->schedule, server);
 676   silc_schedule_uninit(server->schedule);
 677   server->schedule = NULL;
 678
 679   silc_idcache_free(server->local_list->clients);
 680   silc_idcache_free(server->local_list->servers);
 681   silc_idcache_free(server->local_list->channels);
 682   silc_idcache_free(server->global_list->clients);
 683   silc_idcache_free(server->global_list->servers);
 684   silc_idcache_free(server->global_list->channels);
 685   silc_hash_table_free(server->watcher_list);
 686   silc_hash_table_free(server->watcher_list_pk);
 687   silc_hash_free(server->md5hash);
 688   silc_hash_free(server->sha1hash);
 689
 690   silc_dlist_uninit(server->listeners);
 691   silc_dlist_uninit(server->conns);
 692   silc_dlist_uninit(server->expired_clients);
 693   silc_skr_free(server->repository);
 694   silc_packet_engine_stop(server->packet_engine);
 695
 696   silc_free(server->local_list);
 697   silc_free(server->global_list);
 698   silc_free(server->server_name);
 699   silc_free(server);
 700
 701   silc_hmac_unregister_all();
 702   silc_hash_unregister_all();
 703   silc_cipher_unregister_all();
 704   silc_pkcs_unregister_all();
 705 }
 706
 707 /* Creates a new server listener. */
 708
 709 static SilcNetListener
 710 silc_server_listen(SilcServer server, const char *server_ip, SilcUInt16 port)
 711 {
 712   SilcNetListener listener;
 713
 714   listener =
 715     silc_net_tcp_create_listener(&server_ip, 1, port, TRUE,
 716                                  server->config->require_reverse_lookup,
 717                                  server->schedule,
 718                                  silc_server_accept_new_connection, server);
 719   if (!listener) {
 720     SILC_SERVER_LOG_ERROR(("Could not create server listener: %s on %hu",
 721                            server_ip, port));
 722     return NULL;
 723   }
 724
 725   return listener;
 726 }
 727
 728 /* Adds a secondary listener. */
 729
 730 SilcBool silc_server_init_secondary(SilcServer server)
 731 {
 732   SilcServerConfigServerInfoInterface *interface;
 733   SilcNetListener listener;
 734
 735   for (interface = server->config->server_info->secondary; interface;
 736        interface = interface->next) {
 737     listener = silc_server_listen(server, interface->server_ip,
 738                                   interface->port);
 739     if (!listener)
 740       return FALSE;
 741     silc_dlist_add(server->listeners, listener);
 742   }
 743
 744   return TRUE;
 745 }
 746
 747 /* Initializes the entire SILC server. This is called always before running
 748    the server. This is called only once at the initialization of the program.
 749    This binds the server to its listenning port. After this function returns
 750    one should call silc_server_run to start the server. This returns TRUE
 751    when everything is ok to run the server. Configuration file must be
 752    read and parsed before calling this. */
 753
 754 SilcBool silc_server_init(SilcServer server)
 755 {
 756   SilcServerID *id;
 757   SilcServerEntry id_entry;
 758   SilcNetListener listener;
 759   SilcUInt16 *port;
 760   char **ip;
 761
 762   SILC_LOG_DEBUG(("Initializing server"));
 763
 764   server->starttime = time(NULL);
 765
 766   /* Take config object for us */
 767   silc_server_config_ref(&server->config_ref, server->config,
 768                          server->config);
 769
 770 #ifdef SILC_DEBUG
 771   /* Set debugging on if configured */
 772   if (server->config->debug_string) {
 773     silc_log_debug(TRUE);
 774     silc_log_set_debug_string(server->config->debug_string);
 775   }
 776 #endif /* SILC_DEBUG */
 777
 778   /* Steal public and private key from the config object */
 779   server->public_key = server->config->server_info->public_key;
 780   server->private_key = server->config->server_info->private_key;
 781   server->config->server_info->public_key = NULL;
 782   server->config->server_info->private_key = NULL;
 783
 784   /* Register all configured ciphers, PKCS and hash functions. */
 785   if (!silc_server_config_register_ciphers(server))
 786     silc_cipher_register_default();
 787   if (!silc_server_config_register_pkcs(server))
 788     silc_pkcs_register_default();
 789   if (!silc_server_config_register_hashfuncs(server))
 790     silc_hash_register_default();
 791   if (!silc_server_config_register_hmacs(server))
 792     silc_hmac_register_default();
 793
 794   /* Initialize random number generator for the server. */
 795   server->rng = silc_rng_alloc();
 796   silc_rng_init(server->rng);
 797   silc_rng_global_init(server->rng);
 798
 799   /* Initialize hash functions for server to use */
 800   silc_hash_alloc("md5", &server->md5hash);
 801   silc_hash_alloc("sha1", &server->sha1hash);
 802
 803   /* Initialize the scheduler */
 804   server->schedule = silc_schedule_init(server->config->param.connections_max,
 805                                         server);
 806   if (!server->schedule)
 807     goto err;
 808
 809   /* First, register log files configuration for error output */
 810   silc_server_config_setlogfiles(server);
 811
 812   /* Initialize ID caches */
 813   server->local_list->clients =
 814     silc_idcache_alloc(0, SILC_ID_CLIENT, silc_idlist_client_destructor,
 815                        server);
 816   server->local_list->servers =
 817     silc_idcache_alloc(0, SILC_ID_SERVER, silc_idlist_server_destructor,
 818                        server);
 819   server->local_list->channels =
 820     silc_idcache_alloc(0, SILC_ID_CHANNEL, silc_idlist_channel_destructor,
 821                        NULL);
 822
 823   /* These are allocated for normal server as well as these hold some
 824      global information that the server has fetched from its router. For
 825      router these are used as they are supposed to be used on router. */
 826   server->global_list->clients =
 827     silc_idcache_alloc(0, SILC_ID_CLIENT, silc_idlist_client_destructor,
 828                        server);
 829   server->global_list->servers =
 830     silc_idcache_alloc(0, SILC_ID_SERVER, silc_idlist_server_destructor,
 831                        server);
 832   server->global_list->channels =
 833     silc_idcache_alloc(0, SILC_ID_CHANNEL, silc_idlist_channel_destructor,
 834                        NULL);
 835
 836   /* Init watcher lists */
 837   server->watcher_list =
 838     silc_hash_table_alloc(1, silc_hash_client_id_hash, NULL,
 839                           silc_hash_data_compare, (void *)CLIENTID_HASH_LEN,
 840                           NULL, NULL, TRUE);
 841   if (!server->watcher_list)
 842     goto err;
 843   server->watcher_list_pk =
 844     silc_hash_table_alloc(1, silc_hash_public_key, NULL,
 845                           silc_hash_public_key_compare, NULL,
 846                           NULL, NULL, TRUE);
 847   if (!server->watcher_list_pk)
 848     goto err;
 849
 850   /* Create TCP listener */
 851   listener = silc_server_listen(
 852                    server,
 853                    server->config->server_info->primary == NULL ? NULL :
 854                    server->config->server_info->primary->server_ip,
 855                    server->config->server_info->primary == NULL ? 0 :
 856                    server->config->server_info->primary->port);
 857   if (!listener)
 858     goto err;
 859   silc_dlist_add(server->listeners, listener);
 860
 861   /* Create a Server ID for the server. */
 862   port = silc_net_listener_get_port(listener, NULL);
 863   ip = silc_net_listener_get_ip(listener, NULL);
 864   silc_id_create_server_id(server->config->server_info->primary->public_ip ?
 865                            server->config->server_info->primary->public_ip :
 866                            ip[0], port[0], server->rng, &id);
 867   if (!id)
 868     goto err;
 869
 870   silc_free(port);
 871   silc_free(ip[0]);
 872   silc_free(ip);
 873
 874   server->id = id;
 875   server->server_name = server->config->server_info->server_name;
 876   server->config->server_info->server_name = NULL;
 877   silc_id_id2str(server->id, SILC_ID_SERVER, server->id_string,
 878                  sizeof(server->id_string), &server->id_string_len);
 879
 880   /* Add ourselves to the server list. We don't have a router yet
 881      beacuse we haven't established a route yet. It will be done later.
 882      For now, NULL is sent as router. This allocates new entry to
 883      the ID list. */
 884   id_entry =
 885     silc_idlist_add_server(server->local_list, strdup(server->server_name),
 886                            server->server_type,
 887                            silc_id_dup(server->id, SILC_ID_SERVER),
 888                            NULL, NULL);
 889   if (!id_entry) {
 890     SILC_LOG_ERROR(("Could not add local server to cache"));
 891     goto err;
 892   }
 893   id_entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
 894   id_entry->data.conn_type = (server->server_type == SILC_SERVER ?
 895                               SILC_CONN_SERVER : SILC_CONN_ROUTER);
 896   server->id_entry = id_entry;
 897
 898   /* Create secondary TCP listeners */
 899   if (silc_server_init_secondary(server) == FALSE)
 900     goto err;
 901
 902   server->listenning = TRUE;
 903
 904   /* Create connections to configured routers. */
 905   silc_server_create_connections(server);
 906
 907   /* If server connections has been configured then we must be router as
 908      normal server cannot have server connections, only router connections. */
 909   if (server->config->servers) {
 910     SilcServerConfigServer *ptr = server->config->servers;
 911
 912     server->server_type = SILC_ROUTER;
 913     while (ptr) {
 914       if (ptr->backup_router) {
 915         server->server_type = SILC_BACKUP_ROUTER;
 916         server->backup_router = TRUE;
 917         server->id_entry->server_type = SILC_BACKUP_ROUTER;
 918         break;
 919       }
 920       ptr = ptr->next;
 921     }
 922   }
 923
 924   if (server->server_type != SILC_ROUTER) {
 925     server->stat.servers = 1;
 926     server->stat.cell_servers = 1;
 927   } else {
 928     server->stat.routers = 1;
 929   }
 930
 931   /* If we are normal server we'll retrieve network statisticial information
 932      once in a while from the router. */
 933   if (server->server_type != SILC_ROUTER)
 934     silc_schedule_task_add_timeout(server->schedule, silc_server_get_stats,
 935                                    server, 10, 0);
 936
 937   /* Start packet engine */
 938   server->packet_engine =
 939     silc_packet_engine_start(server->rng, server->server_type == SILC_ROUTER,
 940                              &silc_server_stream_cbs, server);
 941   if (!server->packet_engine)
 942     goto err;
 943
 944   /* Register client entry expiration timeout */
 945   silc_schedule_task_add_timeout(server->schedule,
 946                                  silc_server_purge_expired_clients, server,
 947                                  120, 0);
 948
 949   /* Initialize HTTP server */
 950   silc_server_http_init(server);
 951
 952   SILC_LOG_DEBUG(("Server initialized"));
 953
 954   /* We are done here, return succesfully */
 955   return TRUE;
 956
 957  err:
 958   silc_server_config_unref(&server->config_ref);
 959   return FALSE;
 960 }
 961
 962 /* Task callback to close a socket connection after rehash */
 963
 964 SILC_TASK_CALLBACK(silc_server_rehash_close_connection)
 965 {
 966   SilcServer server = app_context;
 967   SilcPacketStream sock = context;
 968   SilcIDListData idata = silc_packet_get_context(sock);
 969   const char *hostname;
 970   SilcUInt16 port;
 971
 972   silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
 973                               NULL, &hostname, NULL, &port);
 974
 975   SILC_LOG_INFO(("Connection %s:%d [%s] is unconfigured",
 976                  hostname, port, SILC_CONNTYPE_STRING(idata->conn_type)));
 977   silc_schedule_task_del_by_context(server->schedule, sock);
 978   silc_server_disconnect_remote(server, sock,
 979                                 SILC_STATUS_ERR_BANNED_FROM_SERVER,
 980                                 "This connection is removed from "
 981                                 "configuration");
 982   silc_server_free_sock_user_data(server, sock, NULL);
 983 }
 984
 985 /* This function basically reads the config file again and switches the config
 986    object pointed by the server object. After that, we have to fix various
 987    things such as the server_name and the listening ports.
 988    Keep in mind that we no longer have the root privileges at this point. */
 989
 990 SilcBool silc_server_rehash(SilcServer server)
 991 {
 992   SilcServerConfig newconfig;
 993
 994   SILC_LOG_INFO(("Rehashing server"));
 995
 996   /* Reset the logging system */
 997   silc_log_quick(TRUE);
 998   silc_log_flush_all();
 999
1000   /* Start the main rehash phase (read again the config file) */
1001   newconfig = silc_server_config_alloc(server->config_file, server);
1002   if (!newconfig) {
1003     SILC_LOG_ERROR(("Rehash FAILED."));
1004     return FALSE;
1005   }
1006
1007   /* Fix the server_name field */
1008   if (strcmp(server->server_name, newconfig->server_info->server_name)) {
1009     silc_free(server->server_name);
1010
1011     /* Check server name */
1012     server->server_name =
1013       silc_identifier_check(newconfig->server_info->server_name,
1014                             strlen(newconfig->server_info->server_name),
1015                             SILC_STRING_LOCALE, 256, NULL);
1016     if (!server->server_name) {
1017       SILC_LOG_ERROR(("Malformed server name string '%s'",
1018                       server->config->server_info->server_name));
1019       return FALSE;
1020     }
1021
1022     /* Update the idcache list with a fresh pointer */
1023     silc_free(server->id_entry->server_name);
1024     server->id_entry->server_name = strdup(server->server_name);
1025     silc_idcache_update_by_context(server->local_list->servers,
1026                                    server->id_entry, NULL,
1027                                    strdup(server->id_entry->server_name),
1028                                    TRUE);
1029   }
1030
1031   /* Set logging */
1032   silc_server_config_setlogfiles(server);
1033
1034   /* Change new key pair if necessary */
1035   if (newconfig->server_info->public_key &&
1036       !silc_pkcs_public_key_compare(server->public_key,
1037                                     newconfig->server_info->public_key)) {
1038     silc_pkcs_public_key_free(server->public_key);
1039     silc_pkcs_private_key_free(server->private_key);
1040     server->public_key = newconfig->server_info->public_key;
1041     server->private_key = newconfig->server_info->private_key;
1042     newconfig->server_info->public_key = NULL;
1043     newconfig->server_info->private_key = NULL;
1044   }
1045
1046   /* Check for unconfigured server and router connections and close
1047      connections that were unconfigured. */
1048
1049   if (server->config->routers) {
1050     SilcServerConfigRouter *ptr;
1051     SilcServerConfigRouter *newptr;
1052     SilcBool found;
1053
1054     for (ptr = server->config->routers; ptr; ptr = ptr->next) {
1055       found = FALSE;
1056
1057       /* Check whether new config has this one too */
1058       for (newptr = newconfig->routers; newptr; newptr = newptr->next) {
1059         if (silc_string_compare(newptr->host, ptr->host) &&
1060             newptr->port == ptr->port &&
1061             newptr->initiator == ptr->initiator) {
1062           found = TRUE;
1063           break;
1064         }
1065       }
1066
1067       if (!found && ptr->host) {
1068         /* Remove this connection */
1069         SilcPacketStream sock;
1070         sock = silc_server_find_socket_by_host(server, SILC_CONN_ROUTER,
1071                                                ptr->host, ptr->port);
1072         if (sock)
1073           silc_schedule_task_add_timeout(server->schedule,
1074                                          silc_server_rehash_close_connection,
1075                                          sock, 0, 1);
1076       }
1077     }
1078   }
1079
1080   if (server->config->servers) {
1081     SilcServerConfigServer *ptr;
1082     SilcServerConfigServer *newptr;
1083     SilcBool found;
1084
1085     for (ptr = server->config->servers; ptr; ptr = ptr->next) {
1086       found = FALSE;
1087
1088       /* Check whether new config has this one too */
1089       for (newptr = newconfig->servers; newptr; newptr = newptr->next) {
1090         if (silc_string_compare(newptr->host, ptr->host)) {
1091           found = TRUE;
1092           break;
1093         }
1094       }
1095
1096       if (!found && ptr->host) {
1097         /* Remove this connection */
1098         SilcPacketStream sock;
1099         sock = silc_server_find_socket_by_host(server, SILC_CONN_SERVER,
1100                                                ptr->host, 0);
1101         if (sock)
1102           silc_schedule_task_add_timeout(server->schedule,
1103                                          silc_server_rehash_close_connection,
1104                                          sock, 0, 1);
1105       }
1106     }
1107   }
1108
1109   if (server->config->clients) {
1110     SilcServerConfigClient *ptr;
1111     SilcServerConfigClient *newptr;
1112     SilcBool found;
1113
1114     for (ptr = server->config->clients; ptr; ptr = ptr->next) {
1115       found = FALSE;
1116
1117       /* Check whether new config has this one too */
1118       for (newptr = newconfig->clients; newptr; newptr = newptr->next) {
1119         if (silc_string_compare(newptr->host, ptr->host)) {
1120           found = TRUE;
1121           break;
1122         }
1123       }
1124
1125       if (!found && ptr->host) {
1126         /* Remove this connection */
1127         SilcPacketStream sock;
1128         sock = silc_server_find_socket_by_host(server, SILC_CONN_CLIENT,
1129                                                ptr->host, 0);
1130         if (sock)
1131           silc_schedule_task_add_timeout(server->schedule,
1132                                          silc_server_rehash_close_connection,
1133                                          sock, 0, 1);
1134       }
1135     }
1136   }
1137
1138   /* Create connections after rehash */
1139   silc_server_create_connections(server);
1140
1141   /* Check whether our router status has changed */
1142   if (newconfig->servers) {
1143     SilcServerConfigServer *ptr = newconfig->servers;
1144
1145     server->server_type = SILC_ROUTER;
1146     while (ptr) {
1147       if (ptr->backup_router) {
1148         server->server_type = SILC_BACKUP_ROUTER;
1149         server->backup_router = TRUE;
1150         server->id_entry->server_type = SILC_BACKUP_ROUTER;
1151         break;
1152       }
1153       ptr = ptr->next;
1154     }
1155   }
1156
1157   /* Our old config is gone now. We'll unreference our reference made in
1158      silc_server_init and then destroy it since we are destroying it
1159      underneath the application (layer which called silc_server_init). */
1160   silc_server_config_unref(&server->config_ref);
1161   silc_server_config_destroy(server->config);
1162
1163   /* Take new config context */
1164   server->config = newconfig;
1165   silc_server_config_ref(&server->config_ref, server->config, server->config);
1166
1167 #ifdef SILC_DEBUG
1168   /* Set debugging on if configured */
1169   if (server->config->debug_string) {
1170     silc_log_debug(TRUE);
1171     silc_log_set_debug_string(server->config->debug_string);
1172   }
1173 #endif /* SILC_DEBUG */
1174
1175   SILC_LOG_DEBUG(("Server rehashed"));
1176
1177   return TRUE;
1178 }
1179
1180 /* The heart of the server. This runs the scheduler thus runs the server.
1181    When this returns the server has been stopped and the program will
1182    be terminated. */
1183
1184 void silc_server_run(SilcServer server)
1185 {
1186   SILC_LOG_INFO(("SILC Server started"));
1187
1188   /* Start the scheduler, the heart of the SILC server. When this returns
1189      the program will be terminated. */
1190   silc_schedule(server->schedule);
1191 }
1192
1193 /* Stops the SILC server. This function is used to shutdown the server.
1194    This is usually called after the scheduler has returned. After stopping
1195    the server one should call silc_server_free. */
1196
1197 void silc_server_stop(SilcServer server)
1198 {
1199   SilcDList list;
1200   SilcPacketStream ps;
1201   SilcNetListener listener;
1202
1203   SILC_LOG_INFO(("SILC Server shutting down"));
1204
1205   server->server_shutdown = TRUE;
1206
1207   /* Close all connections */
1208   if (server->packet_engine) {
1209     list = silc_packet_engine_get_streams(server->packet_engine);
1210
1211     silc_dlist_start(list);
1212     while ((ps = silc_dlist_get(list))) {
1213       SilcIDListData idata = silc_packet_get_context(ps);
1214
1215       if (!silc_packet_stream_is_valid(ps))
1216         continue;
1217
1218       if (idata)
1219         idata->status &= ~SILC_IDLIST_STATUS_DISABLED;
1220
1221       silc_server_disconnect_remote(server, ps, SILC_STATUS_OK,
1222                                     "Server is shutting down");
1223       silc_server_free_sock_user_data(server, ps,
1224                                       "Server is shutting down");
1225     }
1226     silc_packet_engine_free_streams_list(list);
1227   }
1228
1229   /* We are not connected to network anymore */
1230   server->standalone = TRUE;
1231
1232   silc_dlist_start(server->listeners);
1233   while ((listener = silc_dlist_get(server->listeners)))
1234     silc_net_close_listener(listener);
1235
1236   silc_server_http_uninit(server);
1237
1238   /* Cancel any possible retry timeouts */
1239   silc_schedule_task_del_by_callback(server->schedule,
1240                                      silc_server_connect_router);
1241   silc_schedule_task_del_by_callback(server->schedule,
1242                                      silc_server_connect_to_router_retry);
1243   silc_schedule_task_del_by_callback(server->schedule,
1244                                      silc_server_connect_to_router);
1245
1246   silc_schedule_stop(server->schedule);
1247
1248   SILC_LOG_DEBUG(("Server stopped"));
1249 }
1250
1251 /* Purge expired client entries from the server */
1252
1253 SILC_TASK_CALLBACK(silc_server_purge_expired_clients)
1254 {
1255   SilcServer server = context;
1256   SilcClientEntry client;
1257   SilcIDList id_list;
1258   SilcUInt64 curtime = silc_time();
1259
1260   SILC_LOG_DEBUG(("Expire timeout"));
1261
1262   silc_dlist_start(server->expired_clients);
1263   while ((client = silc_dlist_get(server->expired_clients))) {
1264     if (client->data.status & SILC_IDLIST_STATUS_REGISTERED)
1265       continue;
1266
1267     /* For unregistered clients the created timestamp is actually
1268        unregistered timestamp.  Make sure client remains in history
1269        at least 500 seconds. */
1270     if (curtime - client->data.created < 500)
1271       continue;
1272
1273     id_list = (client->data.status & SILC_IDLIST_STATUS_LOCAL ?
1274                server->local_list : server->global_list);
1275
1276     silc_idlist_del_data(client);
1277     silc_idlist_del_client(id_list, client);
1278     silc_dlist_del(server->expired_clients, client);
1279   }
1280
1281   silc_schedule_task_add_timeout(server->schedule,
1282                                  silc_server_purge_expired_clients, server,
1283                                  120, 0);
1284 }
1285
1286
1287 /******************************* Connecting *********************************/
1288
1289 /* Free connection context */
1290
1291 void silc_server_connection_free(SilcServerConnection sconn)
1292 {
1293   SILC_LOG_DEBUG(("Free connection %p", sconn));
1294   silc_dlist_del(sconn->server->conns, sconn);
1295   silc_server_config_unref(&sconn->conn);
1296   silc_free(sconn->remote_host);
1297   silc_free(sconn->backup_replace_ip);
1298   silc_free(sconn);
1299 }
1300
1301 /* Creates connection to a remote router. */
1302
1303 void silc_server_create_connection(SilcServer server,
1304                                    SilcBool reconnect,
1305                                    SilcBool dynamic,
1306                                    const char *remote_host, SilcUInt32 port,
1307                                    SilcServerConnectCallback callback,
1308                                    void *context)
1309 {
1310   SilcServerConnection sconn;
1311
1312   /* Allocate connection object for hold connection specific stuff. */
1313   sconn = silc_calloc(1, sizeof(*sconn));
1314   if (!sconn)
1315     return;
1316   sconn->remote_host = strdup(remote_host);
1317   sconn->remote_port = port;
1318   sconn->no_reconnect = reconnect == FALSE;
1319   sconn->callback = callback;
1320   sconn->callback_context = context;
1321   sconn->no_conf = dynamic;
1322   sconn->server = server;
1323
1324   SILC_LOG_DEBUG(("Created connection %p", sconn));
1325
1326   silc_schedule_task_add_timeout(server->schedule, silc_server_connect_router,
1327                                  sconn, 0, 0);
1328 }
1329
1330 /* Connection authentication completion callback */
1331
1332 static void
1333 silc_server_ke_auth_compl(SilcConnAuth connauth, SilcBool success,
1334                           void *context)
1335 {
1336   SilcServerConnection sconn = context;
1337   SilcUnknownEntry entry = silc_packet_get_context(sconn->sock);
1338   SilcServer server = entry->server;
1339   SilcServerConfigServer *conn;
1340   SilcServerConfigConnParams *param;
1341   SilcIDListData idata;
1342   SilcServerEntry id_entry = NULL;
1343   unsigned char id[32];
1344   SilcUInt32 id_len;
1345   SilcID remote_id;
1346   const char *ip;
1347
1348   SILC_LOG_DEBUG(("Connection %p authentication completed", sconn));
1349
1350   entry->op = NULL;
1351
1352   if (success == FALSE) {
1353     /* Authentication failed */
1354     /* XXX retry connecting */
1355
1356     silc_server_disconnect_remote(server, sconn->sock,
1357                                   SILC_STATUS_ERR_AUTH_FAILED, NULL);
1358     if (sconn->callback)
1359       (*sconn->callback)(server, NULL, sconn->callback_context);
1360     silc_server_free_sock_user_data(server, sconn->sock, NULL);
1361     silc_server_connection_free(sconn);
1362     return;
1363   }
1364
1365   /* XXX For now remote is router always */
1366   entry->data.conn_type = SILC_CONN_ROUTER;
1367
1368   SILC_LOG_INFO(("Connected to %s %s",
1369                  SILC_CONNTYPE_STRING(entry->data.conn_type),
1370                  sconn->remote_host));
1371
1372   /* Create the actual entry for remote entity */
1373   switch (entry->data.conn_type) {
1374   case SILC_CONN_SERVER:
1375     SILC_LOG_DEBUG(("Remote is SILC server"));
1376
1377     /* Add new server.  The server must register itself to us before it
1378        becomes registered to SILC network. */
1379     id_entry = silc_idlist_add_server(server->local_list,
1380                                       strdup(sconn->remote_host),
1381                                       SILC_SERVER, NULL, NULL, sconn->sock);
1382     if (!id_entry) {
1383       silc_server_disconnect_remote(server, sconn->sock,
1384                                     SILC_STATUS_ERR_RESOURCE_LIMIT, NULL);
1385       if (sconn->callback)
1386         (*sconn->callback)(server, NULL, sconn->callback_context);
1387       silc_server_free_sock_user_data(server, sconn->sock, NULL);
1388       silc_server_connection_free(sconn);
1389       silc_free(entry);
1390       return;
1391     }
1392
1393     /* Statistics */
1394     server->stat.my_servers++;
1395     if (server->server_type == SILC_ROUTER)
1396       server->stat.servers++;
1397     SILC_LOG_DEBUG(("my_servers %d", server->stat.my_servers));
1398
1399     silc_idlist_add_data(id_entry, (SilcIDListData)entry);
1400     break;
1401
1402   case SILC_CONN_ROUTER:
1403     SILC_LOG_DEBUG(("Remote is SILC router"));
1404
1405     /* Register to network */
1406     silc_id_id2str(server->id, SILC_ID_SERVER, id, sizeof(id), &id_len);
1407     if (!silc_packet_send_va(sconn->sock, SILC_PACKET_NEW_SERVER, 0,
1408                              SILC_STR_UI_SHORT(id_len),
1409                              SILC_STR_DATA(id, id_len),
1410                              SILC_STR_UI_SHORT(strlen(server->server_name)),
1411                              SILC_STR_DATA(server->server_name,
1412                                            strlen(server->server_name)),
1413                              SILC_STR_END)) {
1414       silc_server_disconnect_remote(server, sconn->sock,
1415                                     SILC_STATUS_ERR_RESOURCE_LIMIT, NULL);
1416       if (sconn->callback)
1417         (*sconn->callback)(server, NULL, sconn->callback_context);
1418       silc_server_free_sock_user_data(server, sconn->sock, NULL);
1419       silc_server_connection_free(sconn);
1420       silc_free(entry);
1421       return;
1422     }
1423
1424     /* Get remote ID */
1425     silc_packet_get_ids(sconn->sock, NULL, NULL, NULL, &remote_id);
1426
1427     /* Check that we do not have this ID already */
1428     id_entry = silc_idlist_find_server_by_id(server->local_list,
1429                                              &remote_id.u.server_id,
1430                                              TRUE, NULL);
1431     if (id_entry) {
1432       silc_idcache_del_by_context(server->local_list->servers, id_entry, NULL);
1433     } else {
1434       id_entry = silc_idlist_find_server_by_id(server->global_list,
1435                                                &remote_id.u.server_id,
1436                                                TRUE, NULL);
1437       if (id_entry)
1438         silc_idcache_del_by_context(server->global_list->servers, id_entry,
1439                                     NULL);
1440     }
1441
1442     SILC_LOG_DEBUG(("New server id(%s)",
1443                     silc_id_render(&remote_id.u.server_id, SILC_ID_SERVER)));
1444
1445     /* Add the connected router to global server list.  Router is sent
1446        as NULL since it's local to us. */
1447     id_entry = silc_idlist_add_server(server->global_list,
1448                                       strdup(sconn->remote_host),
1449                                       SILC_ROUTER,
1450                                       silc_id_dup(&remote_id.u.server_id,
1451                                                   SILC_ID_SERVER),
1452                                       NULL, sconn->sock);
1453     if (!id_entry) {
1454       silc_server_disconnect_remote(server, sconn->sock,
1455                                     SILC_STATUS_ERR_RESOURCE_LIMIT, NULL);
1456       if (sconn->callback)
1457         (*sconn->callback)(server, NULL, sconn->callback_context);
1458       silc_server_free_sock_user_data(server, sconn->sock, NULL);
1459       silc_server_connection_free(sconn);
1460       silc_free(entry);
1461       return;
1462     }
1463
1464     /* Registered */
1465     silc_idlist_add_data(id_entry, (SilcIDListData)entry);
1466     idata = (SilcIDListData)id_entry;
1467     idata->status |= (SILC_IDLIST_STATUS_REGISTERED |
1468                       SILC_IDLIST_STATUS_LOCAL);
1469     idata->sconn = sconn;
1470
1471     /* Statistics */
1472     server->stat.my_routers++;
1473     if (server->server_type == SILC_ROUTER)
1474       server->stat.routers++;
1475     SILC_LOG_DEBUG(("my_routers %d", server->stat.my_routers));
1476
1477     if (!sconn->backup) {
1478       /* Mark this router our primary router if we're still standalone */
1479       if (server->standalone) {
1480         SILC_LOG_DEBUG(("This connection is our primary router"));
1481         server->id_entry->router = id_entry;
1482         server->router = id_entry;
1483         server->router->server_type = SILC_ROUTER;
1484         server->standalone = FALSE;
1485         server->backup_primary = FALSE;
1486
1487         /* Announce data if we are not backup router (unless not as primary
1488            currently).  Backup router announces later at the end of
1489            resuming protocol. */
1490         if (server->backup_router && server->server_type == SILC_ROUTER) {
1491           SILC_LOG_DEBUG(("Announce data after resume protocol"));
1492         } else {
1493           /* If we are router then announce our possible servers.  Backup
1494              router announces also global servers. */
1495           if (server->server_type == SILC_ROUTER)
1496             silc_server_announce_servers(server,
1497                                          server->backup_router ? TRUE : FALSE,
1498                                          0, SILC_PRIMARY_ROUTE(server));
1499
1500           /* Announce our clients and channels to the router */
1501           silc_server_announce_clients(server, 0, SILC_PRIMARY_ROUTE(server));
1502           silc_server_announce_channels(server, 0, SILC_PRIMARY_ROUTE(server));
1503         }
1504
1505         /* If we are backup router then this primary router is whom we are
1506            backing up. */
1507         if (server->server_type == SILC_BACKUP_ROUTER) {
1508           silc_socket_stream_get_info(silc_packet_stream_get_stream(sconn->
1509                                                                     sock),
1510                                       NULL, NULL, &ip, NULL);
1511           silc_server_backup_add(server, server->id_entry, ip,
1512                                  sconn->remote_port, TRUE);
1513         }
1514 #if 0
1515       } else {
1516         /* We already have primary router.  Disconnect this connection */
1517         SILC_LOG_DEBUG(("We already have primary router, disconnect"));
1518         silc_idlist_del_server(server->global_list, id_entry);
1519         silc_server_disconnect_remote(server, sconn->sock,
1520                                       SILC_STATUS_ERR_RESOURCE_LIMIT, NULL);
1521         if (sconn->callback)
1522           (*sconn->callback)(server, NULL, sconn->callback_context);
1523         silc_server_connection_free(sconn);
1524         silc_free(entry);
1525         return;
1526 #endif /* 0 */
1527       }
1528     } else {
1529       /* Add this server to be our backup router */
1530       id_entry->server_type = SILC_BACKUP_ROUTER;
1531       silc_server_backup_add(server, id_entry, sconn->backup_replace_ip,
1532                              sconn->backup_replace_port, FALSE);
1533     }
1534
1535     break;
1536
1537   default:
1538     silc_server_disconnect_remote(server, sconn->sock,
1539                                   SILC_STATUS_ERR_AUTH_FAILED, NULL);
1540     if (sconn->callback)
1541       (*sconn->callback)(server, NULL, sconn->callback_context);
1542     silc_server_free_sock_user_data(server, sconn->sock, NULL);
1543     silc_server_connection_free(sconn);
1544     silc_free(entry);
1545     return;
1546   }
1547
1548   SILC_LOG_DEBUG(("Connection established, sock %p", sconn->sock));
1549
1550   conn = sconn->conn.ref_ptr;
1551   param = &server->config->param;
1552   if (conn && conn->param)
1553     param = conn->param;
1554
1555   /* Register rekey timeout */
1556   sconn->rekey_timeout = param->key_exchange_rekey;
1557   silc_schedule_task_add_timeout(server->schedule, silc_server_do_rekey,
1558                                  sconn->sock, sconn->rekey_timeout, 0);
1559
1560   /* Set the entry as packet stream context */
1561   silc_packet_set_context(sconn->sock, id_entry);
1562
1563   /* Call the completion callback to indicate that we've connected to
1564      the router */
1565   if (sconn && sconn->callback)
1566     (*sconn->callback)(server, id_entry, sconn->callback_context);
1567
1568   if (sconn == server->router_conn)
1569     server->router_conn = NULL;
1570
1571   silc_free(entry);
1572 }
1573
1574 /* SKE completion callback */
1575
1576 static void silc_server_ke_completed(SilcSKE ske, SilcSKEStatus status,
1577                                      SilcSKESecurityProperties prop,
1578                                      SilcSKEKeyMaterial keymat,
1579                                      SilcSKERekeyMaterial rekey,
1580                                      void *context)
1581 {
1582   SilcPacketStream sock = context;
1583   SilcUnknownEntry entry = silc_packet_get_context(sock);
1584   SilcServerConnection sconn = silc_ske_get_context(ske);
1585   SilcServer server = entry->server;
1586   SilcServerConfigRouter *conn = sconn->conn.ref_ptr;
1587   SilcAuthMethod auth_meth = SILC_AUTH_NONE;
1588   void *auth_data = NULL;
1589   SilcUInt32 auth_data_len = 0;
1590   SilcConnAuth connauth;
1591   SilcCipher send_key, receive_key;
1592   SilcHmac hmac_send, hmac_receive;
1593   SilcHash hash;
1594
1595   SILC_LOG_DEBUG(("Connection %p, SKE completed", sconn));
1596
1597   entry->op = NULL;
1598
1599   if (status != SILC_SKE_STATUS_OK) {
1600     /* SKE failed */
1601     SILC_LOG_ERROR(("Error (%s) during Key Exchange protocol with %s (%s)",
1602                     silc_ske_map_status(status), entry->hostname, entry->ip));
1603
1604     /* XXX retry connecting */
1605     silc_ske_free(ske);
1606     silc_server_disconnect_remote(server, sconn->sock,
1607                                   SILC_STATUS_ERR_KEY_EXCHANGE_FAILED, NULL);
1608     if (sconn->callback)
1609       (*sconn->callback)(server, NULL, sconn->callback_context);
1610     silc_server_free_sock_user_data(server, sconn->sock, NULL);
1611     silc_server_connection_free(sconn);
1612     return;
1613   }
1614
1615   SILC_LOG_DEBUG(("Setting keys into use"));
1616
1617   /* Set the keys into use.  The data will be encrypted after this. */
1618   if (!silc_ske_set_keys(ske, keymat, prop, &send_key, &receive_key,
1619                          &hmac_send, &hmac_receive, &hash)) {
1620
1621     /* XXX retry connecting */
1622
1623     /* Error setting keys */
1624     silc_ske_free(ske);
1625     silc_server_disconnect_remote(server, sconn->sock,
1626                                   SILC_STATUS_ERR_KEY_EXCHANGE_FAILED, NULL);
1627     if (sconn->callback)
1628       (*sconn->callback)(server, NULL, sconn->callback_context);
1629     silc_server_free_sock_user_data(server, sconn->sock, NULL);
1630     silc_server_connection_free(sconn);
1631     return;
1632   }
1633   silc_packet_set_keys(sconn->sock, send_key, receive_key, hmac_send,
1634                        hmac_receive, FALSE);
1635
1636   SILC_LOG_DEBUG(("Starting connection authentication"));
1637
1638   connauth = silc_connauth_alloc(server->schedule, ske,
1639                                  server->config->conn_auth_timeout);
1640   if (!connauth) {
1641     /* XXX retry connecting */
1642
1643     /** Error allocating auth protocol */
1644     silc_ske_free(ske);
1645     silc_server_disconnect_remote(server, sconn->sock,
1646                                   SILC_STATUS_ERR_RESOURCE_LIMIT, NULL);
1647     if (sconn->callback)
1648       (*sconn->callback)(server, NULL, sconn->callback_context);
1649     silc_server_free_sock_user_data(server, sconn->sock, NULL);
1650     silc_server_connection_free(sconn);
1651     return;
1652   }
1653
1654   /* Get authentication method */
1655   if (conn) {
1656     if (conn->passphrase) {
1657       if (conn->publickeys && !server->config->prefer_passphrase_auth) {
1658         auth_meth = SILC_AUTH_PUBLIC_KEY;
1659         auth_data = server->private_key;
1660       } else {
1661         auth_meth = SILC_AUTH_PASSWORD;
1662         auth_data = conn->passphrase;
1663         auth_data_len = conn->passphrase_len;
1664       }
1665     } else {
1666       auth_meth = SILC_AUTH_PUBLIC_KEY;
1667       auth_data = server->private_key;
1668     }
1669   }
1670
1671   entry->data.rekey = rekey;
1672
1673   /* Start connection authentication */
1674   entry->op =
1675     silc_connauth_initiator(connauth, server->server_type == SILC_SERVER ?
1676                             SILC_CONN_SERVER : SILC_CONN_ROUTER, auth_meth,
1677                             auth_data, auth_data_len,
1678                             silc_server_ke_auth_compl, sconn);
1679 }
1680
1681 /* Function that is called when the network connection to a router has
1682    been established.  This will continue with the key exchange protocol
1683    with the remote router. */
1684
1685 void silc_server_start_key_exchange(SilcServerConnection sconn)
1686 {
1687   SilcServer server = sconn->server;
1688   SilcServerConfigRouter *conn = sconn->conn.ref_ptr;
1689   SilcUnknownEntry entry;
1690   SilcSKEParamsStruct params;
1691   SilcSKE ske;
1692
1693   /* Cancel any possible retry timeouts */
1694   silc_schedule_task_del_by_context(server->schedule, sconn);
1695
1696   /* Create packet stream */
1697   sconn->sock = silc_packet_stream_create(server->packet_engine,
1698                                           server->schedule, sconn->stream);
1699   if (!sconn->sock) {
1700     SILC_LOG_ERROR(("Cannot connect: cannot create packet stream"));
1701     silc_stream_destroy(sconn->stream);
1702     if (sconn->callback)
1703       (*sconn->callback)(server, NULL, sconn->callback_context);
1704     silc_server_connection_free(sconn);
1705     return;
1706   }
1707   server->stat.conn_num++;
1708
1709   /* Set source ID to packet stream */
1710   if (!silc_packet_set_ids(sconn->sock, SILC_ID_SERVER, server->id,
1711                            0, NULL)) {
1712     silc_packet_stream_destroy(sconn->sock);
1713     if (sconn->callback)
1714       (*sconn->callback)(server, NULL, sconn->callback_context);
1715     silc_server_connection_free(sconn);
1716     return;
1717   }
1718
1719   /* Create entry for remote entity */
1720   entry = silc_calloc(1, sizeof(*entry));
1721   if (!entry) {
1722     silc_packet_stream_destroy(sconn->sock);
1723     silc_server_connection_free(sconn);
1724     return;
1725   }
1726   entry->server = server;
1727   silc_packet_set_context(sconn->sock, entry);
1728
1729   /* Set Key Exchange flags from configuration, but fall back to global
1730      settings too. */
1731   memset(&params, 0, sizeof(params));
1732   SILC_GET_SKE_FLAGS(conn, params.flags);
1733   if (server->config->param.key_exchange_pfs)
1734     params.flags |= SILC_SKE_SP_FLAG_PFS;
1735
1736   /* Start SILC Key Exchange protocol */
1737   SILC_LOG_DEBUG(("Starting key exchange protocol, connection %p", sconn));
1738   ske = silc_ske_alloc(server->rng, server->schedule, server->repository,
1739                        server->public_key, server->private_key, sconn);
1740   if (!ske) {
1741     silc_free(entry);
1742     silc_packet_stream_destroy(sconn->sock);
1743     if (sconn->callback)
1744       (*sconn->callback)(server, NULL, sconn->callback_context);
1745     silc_server_connection_free(sconn);
1746     return;
1747   }
1748   silc_ske_set_callbacks(ske, silc_server_verify_key,
1749                          silc_server_ke_completed, sconn->sock);
1750
1751   /* Start key exchange protocol */
1752   params.version = silc_version_string;
1753   params.timeout_secs = server->config->key_exchange_timeout;
1754   entry->op = silc_ske_initiator(ske, sconn->sock, &params, NULL);
1755 }
1756
1757 /* Timeout callback that will be called to retry connecting to remote
1758    router. This is used by both normal and router server. This will wait
1759    before retrying the connecting. The timeout is generated by exponential
1760    backoff algorithm. */
1761
1762 SILC_TASK_CALLBACK(silc_server_connect_to_router_retry)
1763 {
1764   SilcServerConnection sconn = context;
1765   SilcServer server = sconn->server;
1766   SilcServerConfigRouter *conn = sconn->conn.ref_ptr;
1767   SilcServerConfigConnParams *param =
1768                 (conn->param ? conn->param : &server->config->param);
1769
1770   SILC_LOG_INFO(("Retrying connecting to %s:%d", sconn->remote_host,
1771                  sconn->remote_port));
1772
1773   /* Calculate next timeout */
1774   if (sconn->retry_count >= 1) {
1775     sconn->retry_timeout = sconn->retry_timeout * SILC_SERVER_RETRY_MULTIPLIER;
1776     if (sconn->retry_timeout > param->reconnect_interval_max)
1777       sconn->retry_timeout = param->reconnect_interval_max;
1778   } else {
1779     sconn->retry_timeout = param->reconnect_interval;
1780   }
1781   sconn->retry_count++;
1782   sconn->retry_timeout = sconn->retry_timeout +
1783     (silc_rng_get_rn32(server->rng) % SILC_SERVER_RETRY_RANDOMIZER);
1784
1785   /* If we've reached max retry count, give up. */
1786   if ((sconn->retry_count > param->reconnect_count) &&
1787       !param->reconnect_keep_trying) {
1788     SILC_LOG_ERROR(("Could not connect, giving up"));
1789
1790     if (sconn->callback)
1791       (*sconn->callback)(server, NULL, sconn->callback_context);
1792     silc_server_connection_free(sconn);
1793     return;
1794   }
1795
1796   SILC_LOG_DEBUG(("Retrying connecting %d seconds", sconn->retry_timeout));
1797
1798   /* We will lookup a fresh pointer later */
1799   silc_server_config_unref(&sconn->conn);
1800
1801   /* Wait before retrying */
1802   silc_schedule_task_del_by_context(server->schedule, sconn);
1803   silc_schedule_task_add_timeout(server->schedule, silc_server_connect_router,
1804                                  sconn, sconn->retry_timeout, 0);
1805 }
1806
1807 /* Callback for async connection to remote router */
1808
1809 static void silc_server_connection_established(SilcNetStatus status,
1810                                                SilcStream stream,
1811                                                void *context)
1812 {
1813   SilcServerConnection sconn = context;
1814   SilcServer server = sconn->server;
1815
1816   silc_schedule_task_del_by_context(server->schedule, sconn);
1817   sconn->op = NULL;
1818
1819   switch (status) {
1820   case SILC_NET_OK:
1821     SILC_LOG_DEBUG(("Connection %p to %s:%d established", sconn,
1822                     sconn->remote_host, sconn->remote_port));
1823
1824     /* Continue with key exchange protocol */
1825     sconn->stream = stream;
1826     silc_server_start_key_exchange(sconn);
1827     break;
1828
1829   case SILC_NET_UNKNOWN_IP:
1830   case SILC_NET_UNKNOWN_HOST:
1831     SILC_LOG_ERROR(("Could not connect to %s:%d: %s",
1832                     sconn->remote_host, sconn->remote_port,
1833                     silc_net_get_error_string(status)));
1834
1835     if (sconn->callback)
1836       (*sconn->callback)(server, NULL, sconn->callback_context);
1837     silc_server_connection_free(sconn);
1838     break;
1839
1840   default:
1841     SILC_LOG_ERROR(("Could not connect to %s:%d: %s",
1842                     sconn->remote_host, sconn->remote_port,
1843                     silc_net_get_error_string(status)));
1844     if (!sconn->no_reconnect) {
1845       silc_schedule_task_add_timeout(sconn->server->schedule,
1846                                      silc_server_connect_to_router_retry,
1847                                      sconn, 1, 0);
1848       silc_dlist_del(server->conns, sconn);
1849     } else {
1850       if (sconn->callback)
1851         (*sconn->callback)(server, NULL, sconn->callback_context);
1852       silc_server_connection_free(sconn);
1853     }
1854     break;
1855   }
1856 }
1857
1858 /* Generic routine to use connect to a router. */
1859
1860 SILC_TASK_CALLBACK(silc_server_connect_router)
1861 {
1862   SilcServerConnection sconn = context;
1863   SilcServer server = sconn->server;
1864   SilcServerConfigRouter *rconn;
1865
1866   silc_schedule_task_del_by_context(server->schedule, sconn);
1867
1868   /* Don't connect if we are shutting down. */
1869   if (server->server_shutdown) {
1870     if (sconn->callback)
1871       (*sconn->callback)(server, NULL, sconn->callback_context);
1872     silc_server_connection_free(sconn);
1873     return;
1874   }
1875
1876   SILC_LOG_INFO(("Connecting to the %s %s on port %d",
1877                  (sconn->backup ? "backup router" : "router"),
1878                  sconn->remote_host, sconn->remote_port));
1879
1880   if (!sconn->no_conf) {
1881     /* Find connection configuration */
1882     rconn = silc_server_config_find_router_conn(server, sconn->remote_host,
1883                                                 sconn->remote_port);
1884     if (!rconn) {
1885       SILC_LOG_INFO(("Unconfigured %s connection %s:%d, cannot connect",
1886                      (sconn->backup ? "backup router" : "router"),
1887                      sconn->remote_host, sconn->remote_port));
1888       silc_server_connection_free(sconn);
1889       return;
1890     }
1891     silc_server_config_ref(&sconn->conn, server->config, (void *)rconn);
1892   }
1893
1894   /* Connect to remote host */
1895   sconn->op =
1896     silc_net_tcp_connect((!server->config->server_info->primary ? NULL :
1897                           server->config->server_info->primary->server_ip),
1898                          sconn->remote_host, sconn->remote_port,
1899                          server->schedule, silc_server_connection_established,
1900                          sconn);
1901   if (!sconn->op) {
1902     SILC_LOG_ERROR(("Could not connect to router %s:%d",
1903                     sconn->remote_host, sconn->remote_port));
1904     silc_server_connection_free(sconn);
1905     return;
1906   }
1907
1908   /* Add to connection list */
1909   silc_dlist_add(server->conns, sconn);
1910 }
1911
1912 /* This function connects to our primary router or if we are a router this
1913    establishes all our primary routes. This is called at the start of the
1914    server to do authentication and key exchange with our router - called
1915    from schedule. */
1916
1917 SILC_TASK_CALLBACK(silc_server_connect_to_router)
1918 {
1919   SilcServer server = context;
1920   SilcServerConnection sconn;
1921   SilcServerConfigRouter *ptr;
1922
1923   /* Don't connect if we are shutting down. */
1924   if (server->server_shutdown)
1925     return;
1926
1927   SILC_LOG_DEBUG(("We are %s",
1928                   (server->server_type == SILC_SERVER ?
1929                    "normal server" : server->server_type == SILC_ROUTER ?
1930                    "router" : "backup router/normal server")));
1931
1932   if (!server->config->routers) {
1933     /* There wasn't a configured router, we will continue but we don't
1934        have a connection to outside world.  We will be standalone server. */
1935     SILC_LOG_DEBUG(("No router(s), we are standalone"));
1936     server->standalone = TRUE;
1937     return;
1938   }
1939
1940   /* Cancel any possible retry timeouts */
1941   silc_schedule_task_del_by_callback(server->schedule,
1942                                      silc_server_connect_router);
1943   silc_schedule_task_del_by_callback(server->schedule,
1944                                      silc_server_connect_to_router_retry);
1945
1946   /* Create the connections to all our routes */
1947   for (ptr = server->config->routers; ptr; ptr = ptr->next) {
1948
1949     SILC_LOG_DEBUG(("%s connection [%s] %s:%d",
1950                     ptr->backup_router ? "Backup router" : "Router",
1951                     ptr->initiator ? "Initiator" : "Responder",
1952                     ptr->host, ptr->port));
1953
1954     if (server->server_type == SILC_ROUTER && ptr->backup_router &&
1955         ptr->initiator == FALSE && !server->backup_router &&
1956         !silc_server_config_get_backup_router(server))
1957       server->wait_backup = TRUE;
1958
1959     if (!ptr->initiator)
1960       continue;
1961     if (ptr->dynamic_connection)
1962       continue;
1963
1964     /* Check whether we are connecting or connected to this host already */
1965     if (silc_server_num_sockets_by_remote(server,
1966                                           silc_net_is_ip(ptr->host) ?
1967                                           ptr->host : NULL,
1968                                           silc_net_is_ip(ptr->host) ?
1969                                           NULL : ptr->host, ptr->port,
1970                                           SILC_CONN_ROUTER)) {
1971       SILC_LOG_DEBUG(("We are already connected to %s:%d",
1972                       ptr->host, ptr->port));
1973
1974       /* If we don't have primary router and this connection is our
1975          primary router we are in desync.  Reconnect to the primary. */
1976       if (server->standalone && !server->router) {
1977         /* XXX */
1978         SilcPacketStream sock;
1979         SilcServerConfigRouter *primary =
1980           silc_server_config_get_primary_router(server);
1981         if (primary != ptr)
1982           continue;
1983         sock = silc_server_find_socket_by_host(server, SILC_CONN_ROUTER,
1984                                                ptr->host, ptr->port);
1985         if (!sock)
1986           continue;
1987         server->backup_noswitch = TRUE;
1988         silc_server_free_sock_user_data(server, sock, NULL);
1989         silc_server_disconnect_remote(server, sock, 0, NULL);
1990         server->backup_noswitch = FALSE;
1991         SILC_LOG_DEBUG(("Reconnecting to primary router"));
1992       } else {
1993         continue;
1994       }
1995     }
1996
1997     /* Allocate connection object for hold connection specific stuff. */
1998     sconn = silc_calloc(1, sizeof(*sconn));
1999     if (!sconn)
2000       continue;
2001     sconn->server = server;
2002     sconn->remote_host = strdup(ptr->host);
2003     sconn->remote_port = ptr->port;
2004     sconn->backup = ptr->backup_router;
2005     if (sconn->backup) {
2006       sconn->backup_replace_ip = strdup(ptr->backup_replace_ip);
2007       sconn->backup_replace_port = ptr->backup_replace_port;
2008     }
2009
2010     SILC_LOG_DEBUG(("Created connection %p", sconn));
2011
2012     if (!server->router_conn && !sconn->backup)
2013       server->router_conn = sconn;
2014
2015     /* Connect */
2016     silc_server_connect_router(server->schedule, server, SILC_TASK_EXPIRE,
2017                                0, sconn);
2018   }
2019 }
2020
2021
2022 /************************ Accepting new connection **************************/
2023
2024 /* After this is called, server don't wait for backup router anymore.
2025    This gets called automatically even after we have backup router
2026    connection established. */
2027
2028 SILC_TASK_CALLBACK(silc_server_backup_router_wait)
2029 {
2030   SilcServer server = context;
2031   server->wait_backup = FALSE;
2032 }
2033
2034 /* Authentication data callback */
2035
2036 static SilcBool
2037 silc_server_accept_get_auth(SilcConnAuth connauth,
2038                             SilcConnectionType conn_type,
2039                             unsigned char **passphrase,
2040                             SilcUInt32 *passphrase_len,
2041                             SilcSKR *repository,
2042                             void *context)
2043 {
2044   SilcPacketStream sock = context;
2045   SilcUnknownEntry entry = silc_packet_get_context(sock);
2046   SilcServer server = entry->server;
2047
2048   SILC_LOG_DEBUG(("Remote connection type %d", conn_type));
2049
2050   /* Remote end is client */
2051   if (conn_type == SILC_CONN_CLIENT) {
2052     SilcServerConfigClient *cconfig = entry->cconfig.ref_ptr;
2053     if (!cconfig)
2054       return FALSE;
2055
2056     *passphrase = cconfig->passphrase;
2057     *passphrase_len = cconfig->passphrase_len;
2058     if (cconfig->publickeys)
2059       *repository = server->repository;
2060
2061     if (cconfig->publickeys) {
2062       if (server->config->prefer_passphrase_auth) {
2063         *repository = NULL;
2064       } else {
2065         *passphrase = NULL;
2066         *passphrase_len = 0;
2067       }
2068     }
2069
2070     entry->conn_type = conn_type;
2071     return TRUE;
2072   }
2073
2074   /* Remote end is server */
2075   if (conn_type == SILC_CONN_SERVER) {
2076     SilcServerConfigServer *sconfig;
2077
2078     /* If we are normal server, don't accept the connection */
2079     if (server->server_type == SILC_SERVER)
2080       return FALSE;
2081
2082     sconfig = entry->sconfig.ref_ptr;
2083     if (!sconfig)
2084       return FALSE;
2085
2086     *passphrase = sconfig->passphrase;
2087     *passphrase_len = sconfig->passphrase_len;
2088     if (sconfig->publickeys)
2089       *repository = server->repository;
2090
2091     if (sconfig->publickeys) {
2092       if (server->config->prefer_passphrase_auth) {
2093         *repository = NULL;
2094       } else {
2095         *passphrase = NULL;
2096         *passphrase_len = 0;
2097       }
2098     }
2099
2100     entry->conn_type = conn_type;
2101     return TRUE;
2102   }
2103
2104   /* Remote end is router */
2105   if (conn_type == SILC_CONN_ROUTER) {
2106     SilcServerConfigRouter *rconfig = entry->rconfig.ref_ptr;
2107     if (!rconfig)
2108       return FALSE;
2109
2110     *passphrase = rconfig->passphrase;
2111     *passphrase_len = rconfig->passphrase_len;
2112     if (rconfig->publickeys)
2113       *repository = server->repository;
2114
2115     if (rconfig->publickeys) {
2116       if (server->config->prefer_passphrase_auth) {
2117         *repository = NULL;
2118       } else {
2119         *passphrase = NULL;
2120         *passphrase_len = 0;
2121       }
2122     }
2123
2124     entry->conn_type = conn_type;
2125     return TRUE;
2126   }
2127
2128   return FALSE;
2129 }
2130
2131 /* Authentication completion callback. */
2132
2133 static void
2134 silc_server_accept_auth_compl(SilcConnAuth connauth, SilcBool success,
2135                               void *context)
2136 {
2137   SilcPacketStream sock = context;
2138   SilcUnknownEntry entry = silc_packet_get_context(sock);
2139   SilcIDListData idata = (SilcIDListData)entry;
2140   SilcServer server = entry->server;
2141   SilcServerConfigConnParams *param = &server->config->param;
2142   SilcServerConnection sconn;
2143   void *id_entry;
2144   const char *hostname, *ip;
2145   SilcUInt16 port;
2146
2147   entry->op = NULL;
2148   silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
2149                               NULL, &hostname, &ip, &port);
2150
2151   if (success == FALSE) {
2152     /* Authentication failed */
2153     SILC_LOG_INFO(("Authentication failed for %s (%s) [%s]", entry->hostname,
2154                    entry->ip, SILC_CONNTYPE_STRING(entry->data.conn_type)));
2155     server->stat.auth_failures++;
2156     silc_server_disconnect_remote(server, sock,
2157                                   SILC_STATUS_ERR_KEY_EXCHANGE_FAILED, NULL);
2158     silc_server_free_sock_user_data(server, sock, NULL);
2159     goto out;
2160   }
2161
2162   SILC_LOG_DEBUG(("Checking whether connection is allowed"));
2163
2164   switch (entry->conn_type) {
2165   case SILC_CONN_CLIENT:
2166     {
2167       SilcClientEntry client;
2168       SilcServerConfigClient *conn = entry->cconfig.ref_ptr;
2169
2170       /* Verify whether this connection is after all allowed to connect */
2171       if (!silc_server_connection_allowed(server, sock, entry->conn_type,
2172                                           &server->config->param,
2173                                           conn->param,
2174                                           silc_connauth_get_ske(connauth))) {
2175         server->stat.auth_failures++;
2176         goto out;
2177       }
2178
2179       /* If we are primary router and we have backup router configured
2180          but it has not connected to use yet, do not accept any other
2181          connection. */
2182       if (server->wait_backup && server->server_type == SILC_ROUTER &&
2183           !server->backup_router) {
2184         SilcServerConfigRouter *router;
2185         router = silc_server_config_get_backup_router(server);
2186         if (router && strcmp(server->config->server_info->primary->server_ip,
2187                              entry->ip) &&
2188             silc_server_find_socket_by_host(server,
2189                                             SILC_CONN_SERVER,
2190                                             router->backup_replace_ip, 0)) {
2191           SILC_LOG_INFO(("Will not accept connections because we do "
2192                          "not have backup router connection established"));
2193           silc_server_disconnect_remote(server, sock,
2194                                         SILC_STATUS_ERR_PERM_DENIED,
2195                                         "We do not have connection to backup "
2196                                         "router established, try later");
2197           silc_server_free_sock_user_data(server, sock, NULL);
2198           server->stat.auth_failures++;
2199
2200           /* From here on, wait 20 seconds for the backup router to appear. */
2201           silc_schedule_task_add_timeout(server->schedule,
2202                                          silc_server_backup_router_wait,
2203                                          (void *)server, 20, 0);
2204           goto out;
2205         }
2206       }
2207
2208       SILC_LOG_DEBUG(("Remote host is client"));
2209       SILC_LOG_INFO(("Connection %s (%s) is client", entry->hostname,
2210                      entry->ip));
2211
2212       /* Add the client to the client ID cache. The nickname and Client ID
2213          and other information is created after we have received NEW_CLIENT
2214          packet from client. */
2215       client = silc_idlist_add_client(server->local_list,
2216                                       NULL, NULL, NULL, NULL, NULL, sock);
2217       if (!client) {
2218         SILC_LOG_ERROR(("Could not add new client to cache"));
2219         server->stat.auth_failures++;
2220         silc_server_disconnect_remote(server, sock,
2221                                       SILC_STATUS_ERR_AUTH_FAILED, NULL);
2222         silc_server_free_sock_user_data(server, sock, NULL);
2223         goto out;
2224       }
2225       entry->data.status |= SILC_IDLIST_STATUS_LOCAL;
2226       entry->data.conn_type = SILC_CONN_CLIENT;
2227
2228       /* Statistics */
2229       server->stat.my_clients++;
2230       server->stat.clients++;
2231       server->stat.cell_clients++;
2232
2233       /* Get connection parameters */
2234       if (conn->param) {
2235         param = conn->param;
2236
2237         if (!param->keepalive_secs)
2238           param->keepalive_secs = server->config->param.keepalive_secs;
2239
2240         if (!param->qos && server->config->param.qos) {
2241           param->qos = server->config->param.qos;
2242           param->qos_rate_limit = server->config->param.qos_rate_limit;
2243           param->qos_bytes_limit = server->config->param.qos_bytes_limit;
2244           param->qos_limit_sec = server->config->param.qos_limit_sec;
2245           param->qos_limit_usec = server->config->param.qos_limit_usec;
2246         }
2247
2248         /* Check if to be anonymous connection */
2249         if (param->anonymous)
2250           client->mode |= SILC_UMODE_ANONYMOUS;
2251       }
2252
2253       /* Add public key to repository */
2254       SILC_LOG_DEBUG(("Add client public key to repository"));
2255       if (!silc_server_get_public_key_by_client(server, client, NULL))
2256         silc_skr_add_public_key_simple(server->repository,
2257                                        entry->data.public_key,
2258                                        SILC_SKR_USAGE_IDENTIFICATION, client,
2259                                        NULL);
2260
2261       id_entry = (void *)client;
2262       break;
2263     }
2264
2265   case SILC_CONN_SERVER:
2266   case SILC_CONN_ROUTER:
2267     {
2268       SilcServerEntry new_server;
2269       SilcBool initiator = FALSE;
2270       SilcBool backup_local = FALSE;
2271       SilcBool backup_router = FALSE;
2272       char *backup_replace_ip = NULL;
2273       SilcUInt16 backup_replace_port = 0;
2274       SilcServerConfigServer *srvconn = entry->sconfig.ref_ptr;
2275       SilcServerConfigRouter *rconn = entry->rconfig.ref_ptr;
2276
2277       /* If we are backup router and this is incoming server connection
2278          and we do not have connection to primary router, do not allow
2279          the connection. */
2280       if (server->server_type == SILC_BACKUP_ROUTER &&
2281           entry->conn_type == SILC_CONN_SERVER &&
2282           !SILC_PRIMARY_ROUTE(server)) {
2283         SILC_LOG_INFO(("Will not accept server connection because we do "
2284                        "not have primary router connection established"));
2285         silc_server_disconnect_remote(server, sock,
2286                                       SILC_STATUS_ERR_PERM_DENIED,
2287                                       "We do not have connection to primary "
2288                                       "router established, try later");
2289         silc_server_free_sock_user_data(server, sock, NULL);
2290         server->stat.auth_failures++;
2291         goto out;
2292       }
2293
2294       if (entry->conn_type == SILC_CONN_ROUTER) {
2295         /* Verify whether this connection is after all allowed to connect */
2296         if (!silc_server_connection_allowed(server, sock,
2297                                             entry->conn_type,
2298                                             &server->config->param,
2299                                             rconn ? rconn->param : NULL,
2300                                             silc_connauth_get_ske(connauth))) {
2301           server->stat.auth_failures++;
2302           goto out;
2303         }
2304
2305         if (rconn) {
2306           if (rconn->param) {
2307             param = rconn->param;
2308
2309             if (!param->keepalive_secs)
2310               param->keepalive_secs = server->config->param.keepalive_secs;
2311
2312             if (!param->qos && server->config->param.qos) {
2313               param->qos = server->config->param.qos;
2314               param->qos_rate_limit = server->config->param.qos_rate_limit;
2315               param->qos_bytes_limit = server->config->param.qos_bytes_limit;
2316               param->qos_limit_sec = server->config->param.qos_limit_sec;
2317               param->qos_limit_usec = server->config->param.qos_limit_usec;
2318             }
2319           }
2320
2321           initiator = rconn->initiator;
2322           backup_local = rconn->backup_local;
2323           backup_router = rconn->backup_router;
2324           backup_replace_ip = rconn->backup_replace_ip;
2325           backup_replace_port = rconn->backup_replace_port;
2326         }
2327       }
2328
2329       if (entry->conn_type == SILC_CONN_SERVER) {
2330         /* Verify whether this connection is after all allowed to connect */
2331         if (!silc_server_connection_allowed(server, sock,
2332                                             entry->conn_type,
2333                                             &server->config->param,
2334                                             srvconn ? srvconn->param : NULL,
2335                                             silc_connauth_get_ske(connauth))) {
2336           server->stat.auth_failures++;
2337           goto out;
2338         }
2339         if (srvconn) {
2340           if (srvconn->param) {
2341             param = srvconn->param;
2342
2343             if (!param->keepalive_secs)
2344               param->keepalive_secs = server->config->param.keepalive_secs;
2345
2346             if (!param->qos && server->config->param.qos) {
2347               param->qos = server->config->param.qos;
2348               param->qos_rate_limit = server->config->param.qos_rate_limit;
2349               param->qos_bytes_limit = server->config->param.qos_bytes_limit;
2350               param->qos_limit_sec = server->config->param.qos_limit_sec;
2351               param->qos_limit_usec = server->config->param.qos_limit_usec;
2352             }
2353           }
2354
2355           backup_router = srvconn->backup_router;
2356         }
2357       }
2358
2359       /* If we are primary router and we have backup router configured
2360          but it has not connected to use yet, do not accept any other
2361          connection. */
2362       if (server->wait_backup && server->server_type == SILC_ROUTER &&
2363           !server->backup_router && !backup_router) {
2364         SilcServerConfigRouter *router;
2365         router = silc_server_config_get_backup_router(server);
2366         if (router && strcmp(server->config->server_info->primary->server_ip,
2367                              ip) &&
2368             silc_server_find_socket_by_host(server,
2369                                             SILC_CONN_SERVER,
2370                                             router->backup_replace_ip, 0)) {
2371           SILC_LOG_INFO(("Will not accept connections because we do "
2372                          "not have backup router connection established"));
2373           silc_server_disconnect_remote(server, sock,
2374                                         SILC_STATUS_ERR_PERM_DENIED,
2375                                         "We do not have connection to backup "
2376                                         "router established, try later");
2377           silc_server_free_sock_user_data(server, sock, NULL);
2378           server->stat.auth_failures++;
2379
2380           /* From here on, wait 20 seconds for the backup router to appear. */
2381           silc_schedule_task_add_timeout(server->schedule,
2382                                          silc_server_backup_router_wait,
2383                                          (void *)server, 20, 0);
2384           goto out;
2385         }
2386       }
2387
2388       SILC_LOG_DEBUG(("Remote host is %s",
2389                       entry->conn_type == SILC_CONN_SERVER ?
2390                       "server" : (backup_router ?
2391                                   "backup router" : "router")));
2392       SILC_LOG_INFO(("Connection %s (%s) is %s", entry->hostname,
2393                      entry->ip, entry->conn_type == SILC_CONN_SERVER ?
2394                      "server" : (backup_router ?
2395                                  "backup router" : "router")));
2396
2397       /* Add the server into server cache. The server name and Server ID
2398          is updated after we have received NEW_SERVER packet from the
2399          server. We mark ourselves as router for this server if we really
2400          are router. */
2401       new_server =
2402         silc_idlist_add_server((entry->conn_type == SILC_CONN_SERVER ?
2403                                 server->local_list : (backup_router ?
2404                                                       server->local_list :
2405                                                       server->global_list)),
2406                                NULL,
2407                                (entry->conn_type == SILC_CONN_SERVER ?
2408                                 SILC_SERVER : SILC_ROUTER),
2409                                NULL,
2410                                (entry->conn_type == SILC_CONN_SERVER ?
2411                                 server->id_entry : (backup_router ?
2412                                                     server->id_entry : NULL)),
2413                                sock);
2414       if (!new_server) {
2415         SILC_LOG_ERROR(("Could not add new server to cache"));
2416         silc_server_disconnect_remote(server, sock,
2417                                       SILC_STATUS_ERR_AUTH_FAILED, NULL);
2418         silc_server_free_sock_user_data(server, sock, NULL);
2419         server->stat.auth_failures++;
2420         goto out;
2421       }
2422       entry->data.status |= SILC_IDLIST_STATUS_LOCAL;
2423       entry->data.conn_type = entry->conn_type;
2424
2425       id_entry = (void *)new_server;
2426
2427       /* If the incoming connection is router and marked as backup router
2428          then add it to be one of our backups */
2429       if (entry->data.conn_type == SILC_CONN_ROUTER && backup_router) {
2430         /* Change it back to SERVER type since that's what it really is. */
2431         if (backup_local)
2432           entry->data.conn_type = SILC_CONN_SERVER;
2433         new_server->server_type = SILC_BACKUP_ROUTER;
2434
2435         SILC_SERVER_SEND_OPERS(server, FALSE, TRUE, SILC_NOTIFY_TYPE_NONE,
2436                                ("Backup router %s is now online",
2437                                 entry->hostname));
2438
2439         /* Remove the backup waiting with timeout */
2440         silc_schedule_task_add_timeout(server->schedule,
2441                                        silc_server_backup_router_wait,
2442                                        (void *)server, 10, 0);
2443       }
2444
2445       /* Statistics */
2446       if (entry->data.conn_type == SILC_CONN_SERVER) {
2447         server->stat.my_servers++;
2448         server->stat.servers++;
2449         SILC_LOG_DEBUG(("my_servers %d", server->stat.my_servers));
2450       } else {
2451         server->stat.my_routers++;
2452         server->stat.routers++;
2453         SILC_LOG_DEBUG(("my_routers %d", server->stat.my_routers));
2454       }
2455
2456       /* Check whether this connection is to be our primary router connection
2457          if we do not already have the primary route. */
2458       if (!backup_router &&
2459           server->standalone && entry->data.conn_type == SILC_CONN_ROUTER) {
2460         if (silc_server_config_is_primary_route(server) && !initiator)
2461           break;
2462
2463         SILC_LOG_DEBUG(("We are not standalone server anymore"));
2464         server->standalone = FALSE;
2465         if (!server->id_entry->router) {
2466           server->id_entry->router = id_entry;
2467           server->router = id_entry;
2468         }
2469       }
2470
2471       break;
2472     }
2473
2474   default:
2475     goto out;
2476     break;
2477   }
2478
2479   /* Add connection to server->conns so that we know we have connection
2480      to this peer. */
2481   sconn = silc_calloc(1, sizeof(*sconn));
2482   sconn->server = server;
2483   sconn->sock = sock;
2484   sconn->remote_host = strdup(hostname);
2485   sconn->remote_port = port;
2486   silc_dlist_add(server->conns, sconn);
2487   idata->sconn = sconn;
2488   idata->last_receive = time(NULL);
2489
2490   /* Add the common data structure to the ID entry. */
2491   silc_idlist_add_data(id_entry, (SilcIDListData)entry);
2492   silc_packet_set_context(sock, id_entry);
2493
2494   /* Connection has been fully established now. Everything is ok. */
2495   SILC_LOG_DEBUG(("New connection %p authenticated", sconn));
2496
2497   /* Perform Quality of Service */
2498   if (param->qos)
2499     silc_socket_stream_set_qos(silc_packet_stream_get_stream(sock),
2500                                param->qos_rate_limit, param->qos_bytes_limit,
2501                                param->qos_limit_sec, param->qos_limit_usec);
2502
2503   silc_server_config_unref(&entry->cconfig);
2504   silc_server_config_unref(&entry->sconfig);
2505   silc_server_config_unref(&entry->rconfig);
2506   silc_free(entry);
2507
2508  out:
2509   silc_ske_free(silc_connauth_get_ske(connauth));
2510   silc_connauth_free(connauth);
2511 }
2512
2513 /* SKE completion callback.  We set the new keys into use here. */
2514
2515 static void
2516 silc_server_accept_completed(SilcSKE ske, SilcSKEStatus status,
2517                              SilcSKESecurityProperties prop,
2518                              SilcSKEKeyMaterial keymat,
2519                              SilcSKERekeyMaterial rekey,
2520                              void *context)
2521 {
2522   SilcPacketStream sock = context;
2523   SilcUnknownEntry entry = silc_packet_get_context(sock);
2524   SilcIDListData idata = (SilcIDListData)entry;
2525   SilcServer server = entry->server;
2526   SilcConnAuth connauth;
2527   SilcCipher send_key, receive_key;
2528   SilcHmac hmac_send, hmac_receive;
2529   SilcHash hash;
2530   unsigned char *pk;
2531   SilcUInt32 pk_len;
2532
2533   entry->op = NULL;
2534
2535   if (status != SILC_SKE_STATUS_OK) {
2536     /* SKE failed */
2537     SILC_LOG_ERROR(("Error (%s) during Key Exchange protocol with %s (%s)",
2538                     silc_ske_map_status(status), entry->hostname, entry->ip));
2539     silc_ske_free(ske);
2540     silc_server_disconnect_remote(server, sock,
2541                                   SILC_STATUS_ERR_KEY_EXCHANGE_FAILED, NULL);
2542     silc_server_free_sock_user_data(server, sock, NULL);
2543     return;
2544   }
2545
2546   SILC_LOG_DEBUG(("Setting keys into use"));
2547
2548   /* Set the keys into use.  The data will be encrypted after this. */
2549   if (!silc_ske_set_keys(ske, keymat, prop, &send_key, &receive_key,
2550                          &hmac_send, &hmac_receive, &hash)) {
2551     /* Error setting keys */
2552     silc_ske_free(ske);
2553     silc_server_disconnect_remote(server, sock,
2554                                   SILC_STATUS_ERR_KEY_EXCHANGE_FAILED, NULL);
2555     silc_server_free_sock_user_data(server, sock, NULL);
2556     return;
2557   }
2558   silc_packet_set_keys(sock, send_key, receive_key, hmac_send,
2559                        hmac_receive, FALSE);
2560
2561   idata->rekey = rekey;
2562   idata->public_key = silc_pkcs_public_key_copy(prop->public_key);
2563   pk = silc_pkcs_public_key_encode(idata->public_key, &pk_len);
2564   silc_hash_make(server->sha1hash, pk, pk_len, idata->fingerprint);
2565
2566   silc_hash_alloc(silc_hash_get_name(prop->hash), &idata->hash);
2567
2568   SILC_LOG_DEBUG(("Starting connection authentication"));
2569   server->stat.auth_attempts++;
2570
2571   connauth = silc_connauth_alloc(server->schedule, ske,
2572                                  server->config->conn_auth_timeout);
2573   if (!connauth) {
2574     /** Error allocating auth protocol */
2575     silc_ske_free(ske);
2576     silc_server_disconnect_remote(server, sock,
2577                                   SILC_STATUS_ERR_RESOURCE_LIMIT, NULL);
2578     silc_server_free_sock_user_data(server, sock, NULL);
2579     return;
2580   }
2581
2582   /* Start connection authentication */
2583   entry->op =
2584     silc_connauth_responder(connauth, silc_server_accept_get_auth,
2585                             silc_server_accept_auth_compl, sock);
2586 }
2587
2588 /* Accept new TCP connection */
2589
2590 static void silc_server_accept_new_connection(SilcNetStatus status,
2591                                               SilcStream stream,
2592                                               void *context)
2593 {
2594   SilcServer server = context;
2595   SilcPacketStream packet_stream;
2596   SilcServerConfigClient *cconfig = NULL;
2597   SilcServerConfigServer *sconfig = NULL;
2598   SilcServerConfigRouter *rconfig = NULL;
2599   SilcServerConfigDeny *deny;
2600   SilcUnknownEntry entry;
2601   SilcSKE ske;
2602   SilcSKEParamsStruct params;
2603   char *hostname, *ip;
2604   SilcUInt16 port;
2605
2606   SILC_LOG_DEBUG(("Accepting new connection"));
2607
2608   /* Check for maximum allowed connections */
2609   server->stat.conn_attempts++;
2610   if (silc_dlist_count(server->conns) >
2611       server->config->param.connections_max) {
2612     SILC_LOG_ERROR(("Refusing connection, server is full"));
2613     server->stat.conn_failures++;
2614     silc_stream_destroy(stream);
2615     return;
2616   }
2617
2618   /* Get hostname, IP and port */
2619   if (!silc_socket_stream_get_info(stream, NULL, (const char **)&hostname,
2620                                    (const char **)&ip, &port)) {
2621     /* Bad socket stream */
2622     server->stat.conn_failures++;
2623     silc_stream_destroy(stream);
2624     return;
2625   }
2626
2627   /* Create packet stream */
2628   packet_stream = silc_packet_stream_create(server->packet_engine,
2629                                             server->schedule, stream);
2630   if (!packet_stream) {
2631     SILC_LOG_ERROR(("Refusing connection, cannot create packet stream"));
2632     server->stat.conn_failures++;
2633     silc_stream_destroy(stream);
2634     return;
2635   }
2636   server->stat.conn_num++;
2637
2638   /* Set source ID to packet stream */
2639   if (!silc_packet_set_ids(packet_stream, SILC_ID_SERVER, server->id,
2640                            0, NULL)) {
2641     /* Out of memory */
2642     server->stat.conn_failures++;
2643     silc_packet_stream_destroy(packet_stream);
2644     return;
2645   }
2646
2647   /* Check whether this connection is denied to connect to us. */
2648   deny = silc_server_config_find_denied(server, ip);
2649   if (!deny)
2650     deny = silc_server_config_find_denied(server, hostname);
2651   if (deny) {
2652     /* The connection is denied */
2653     SILC_LOG_INFO(("Connection %s (%s) is denied", hostname, ip));
2654     silc_server_disconnect_remote(server, packet_stream,
2655                                   SILC_STATUS_ERR_BANNED_FROM_SERVER,
2656                                   deny->reason);
2657     silc_server_free_sock_user_data(server, packet_stream, NULL);
2658     return;
2659   }
2660
2661   /* Check whether we have configured this sort of connection at all. We
2662      have to check all configurations since we don't know what type of
2663      connection this is. */
2664   if (!(cconfig = silc_server_config_find_client(server, ip)))
2665     cconfig = silc_server_config_find_client(server, hostname);
2666   if (!(sconfig = silc_server_config_find_server_conn(server, ip)))
2667     sconfig = silc_server_config_find_server_conn(server, hostname);
2668   if (server->server_type == SILC_ROUTER)
2669     if (!(rconfig = silc_server_config_find_router_conn(server, ip, port)))
2670       rconfig = silc_server_config_find_router_conn(server, hostname, port);
2671   if (!cconfig && !sconfig && !rconfig) {
2672     SILC_LOG_INFO(("Connection %s (%s) is not allowed", hostname, ip));
2673     server->stat.conn_failures++;
2674     silc_server_disconnect_remote(server, packet_stream,
2675                                   SILC_STATUS_ERR_BANNED_FROM_SERVER, NULL);
2676     silc_server_free_sock_user_data(server, packet_stream, NULL);
2677     return;
2678   }
2679
2680   /* The connection is allowed */
2681   entry = silc_calloc(1, sizeof(*entry));
2682   if (!entry) {
2683     server->stat.conn_failures++;
2684     silc_server_disconnect_remote(server, packet_stream,
2685                                   SILC_STATUS_ERR_RESOURCE_LIMIT, NULL);
2686     silc_server_free_sock_user_data(server, packet_stream, NULL);
2687     return;
2688   }
2689   entry->hostname = hostname;
2690   entry->ip = ip;
2691   entry->port = port;
2692   entry->server = server;
2693   entry->data.conn_type = SILC_CONN_UNKNOWN;
2694   silc_packet_set_context(packet_stream, entry);
2695
2696   silc_server_config_ref(&entry->cconfig, server->config, cconfig);
2697   silc_server_config_ref(&entry->sconfig, server->config, sconfig);
2698   silc_server_config_ref(&entry->rconfig, server->config, rconfig);
2699
2700   /* Take flags for key exchange. Since we do not know what type of connection
2701      this is, we go through all found configurations and use the global ones
2702      as well. This will result always into strictest key exchange flags. */
2703   memset(&params, 0, sizeof(params));
2704   SILC_GET_SKE_FLAGS(cconfig, params.flags);
2705   SILC_GET_SKE_FLAGS(sconfig, params.flags);
2706   SILC_GET_SKE_FLAGS(rconfig, params.flags);
2707   if (server->config->param.key_exchange_pfs)
2708     params.flags |= SILC_SKE_SP_FLAG_PFS;
2709
2710   SILC_LOG_INFO(("Incoming connection %s (%s)", hostname, ip));
2711   server->stat.conn_attempts++;
2712
2713   /* Start SILC Key Exchange protocol */
2714   SILC_LOG_DEBUG(("Starting key exchange protocol"));
2715   ske = silc_ske_alloc(server->rng, server->schedule, server->repository,
2716                        server->public_key, server->private_key,
2717                        packet_stream);
2718   if (!ske) {
2719     server->stat.conn_failures++;
2720     silc_server_disconnect_remote(server, packet_stream,
2721                                   SILC_STATUS_ERR_RESOURCE_LIMIT, NULL);
2722     silc_server_free_sock_user_data(server, packet_stream, NULL);
2723     return;
2724   }
2725   silc_ske_set_callbacks(ske, silc_server_verify_key,
2726                          silc_server_accept_completed, packet_stream);
2727
2728   /* Start key exchange protocol */
2729   params.version = silc_version_string;
2730   params.timeout_secs = server->config->key_exchange_timeout;
2731   entry->op = silc_ske_responder(ske, packet_stream, &params);
2732 }
2733
2734
2735 /********************************** Rekey ***********************************/
2736
2737 /* Initiator rekey completion callback */
2738
2739 static void silc_server_rekey_completion(SilcSKE ske,
2740                                          SilcSKEStatus status,
2741                                          const SilcSKESecurityProperties prop,
2742                                          const SilcSKEKeyMaterial keymat,
2743                                          SilcSKERekeyMaterial rekey,
2744                                          void *context)
2745 {
2746   SilcPacketStream sock = context;
2747   SilcIDListData idata = silc_packet_get_context(sock);
2748   SilcServer server = idata->sconn->server;
2749
2750   idata->sconn->op = NULL;
2751   if (status != SILC_SKE_STATUS_OK) {
2752     SILC_LOG_ERROR(("Error during rekey protocol with %s",
2753                     idata->sconn->remote_host));
2754     return;
2755   }
2756
2757   SILC_LOG_DEBUG(("Rekey protocol completed with %s:%d [%s]",
2758                   idata->sconn->remote_host, idata->sconn->remote_port,
2759                   SILC_CONNTYPE_STRING(idata->conn_type)));
2760
2761   /* Save rekey data for next rekey */
2762   idata->rekey = rekey;
2763
2764   /* Register new rekey timeout */
2765   silc_schedule_task_add_timeout(server->schedule, silc_server_do_rekey,
2766                                  sock, idata->sconn->rekey_timeout, 0);
2767 }
2768
2769 /* Rekey callback.  Start rekey as initiator */
2770
2771 SILC_TASK_CALLBACK(silc_server_do_rekey)
2772 {
2773   SilcServer server = app_context;
2774   SilcPacketStream sock = context;
2775   SilcIDListData idata = silc_packet_get_context(sock);
2776   SilcSKE ske;
2777
2778   SILC_LOG_DEBUG(("Perform rekey, sock %p", sock));
2779
2780   /* Do not execute rekey with disabled connections */
2781   if (idata->status & SILC_IDLIST_STATUS_DISABLED)
2782     return;
2783
2784   /* If another protocol is active do not start rekey */
2785   if (idata->sconn->op) {
2786     SILC_LOG_DEBUG(("Waiting for other protocol to finish before rekeying"));
2787     silc_schedule_task_add_timeout(server->schedule, silc_server_do_rekey,
2788                                    sock, 60, 0);
2789     return;
2790   }
2791
2792   SILC_LOG_DEBUG(("Executing rekey protocol with %s:%d [%s]",
2793                   idata->sconn->remote_host, idata->sconn->remote_port,
2794                   SILC_CONNTYPE_STRING(idata->conn_type)));
2795
2796   /* Allocate SKE */
2797   ske = silc_ske_alloc(server->rng, server->schedule, NULL,
2798                        server->public_key, NULL, sock);
2799   if (!ske)
2800     return;
2801
2802   /* Set SKE callbacks */
2803   silc_ske_set_callbacks(ske, NULL, silc_server_rekey_completion, sock);
2804
2805   /* Perform rekey */
2806   idata->sconn->op = silc_ske_rekey_initiator(ske, sock, idata->rekey);
2807 }
2808
2809 /* Responder rekey completion callback */
2810
2811 static void
2812 silc_server_rekey_resp_completion(SilcSKE ske,
2813                                   SilcSKEStatus status,
2814                                   const SilcSKESecurityProperties prop,
2815                                   const SilcSKEKeyMaterial keymat,
2816                                   SilcSKERekeyMaterial rekey,
2817                                   void *context)
2818 {
2819   SilcPacketStream sock = context;
2820   SilcIDListData idata = silc_packet_get_context(sock);
2821
2822   idata->sconn->op = NULL;
2823   if (status != SILC_SKE_STATUS_OK) {
2824     SILC_LOG_ERROR(("Error during rekey protocol with %s",
2825                     idata->sconn->remote_host));
2826     return;
2827   }
2828
2829   SILC_LOG_DEBUG(("Rekey protocol completed with %s:%d [%s]",
2830                   idata->sconn->remote_host, idata->sconn->remote_port,
2831                   SILC_CONNTYPE_STRING(idata->conn_type)));
2832
2833   /* Save rekey data for next rekey */
2834   idata->rekey = rekey;
2835 }
2836
2837 /* Start rekey as responder */
2838
2839 static void silc_server_rekey(SilcServer server, SilcPacketStream sock,
2840                               SilcPacket packet)
2841 {
2842   SilcIDListData idata = silc_packet_get_context(sock);
2843   SilcSKE ske;
2844
2845   SILC_LOG_DEBUG(("Executing rekey protocol with %s:%d [%s]",
2846                   idata->sconn->remote_host, idata->sconn->remote_port,
2847                   SILC_CONNTYPE_STRING(idata->conn_type)));
2848
2849   /* Allocate SKE */
2850   ske = silc_ske_alloc(server->rng, server->schedule, NULL,
2851                        server->public_key, NULL, sock);
2852   if (!ske) {
2853     silc_packet_free(packet);
2854     return;
2855   }
2856
2857   /* Set SKE callbacks */
2858   silc_ske_set_callbacks(ske, NULL, silc_server_rekey_resp_completion, sock);
2859
2860   /* Perform rekey */
2861   idata->sconn->op = silc_ske_rekey_responder(ske, sock, idata->rekey,
2862                                               packet);
2863 }
2864
2865
2866 /****************************** Disconnection *******************************/
2867
2868 /* Destroys packet stream. */
2869
2870 SILC_TASK_CALLBACK(silc_server_close_connection_final)
2871 {
2872   silc_packet_stream_unref(context);
2873 }
2874
2875 /* Closes connection to socket connection */
2876
2877 void silc_server_close_connection(SilcServer server,
2878                                   SilcPacketStream sock)
2879 {
2880   SilcIDListData idata = silc_packet_get_context(sock);
2881   char tmp[128];
2882   const char *hostname;
2883   SilcUInt16 port;
2884
2885   if (!silc_packet_stream_is_valid(sock))
2886     return;
2887
2888   memset(tmp, 0, sizeof(tmp));
2889   //  silc_socket_get_error(sock, tmp, sizeof(tmp));
2890   silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
2891                               NULL, &hostname, NULL, &port);
2892   SILC_LOG_INFO(("Closing connection %s:%d [%s] %s", hostname, port,
2893                  idata ? SILC_CONNTYPE_STRING(idata->conn_type) : "",
2894                  tmp[0] ? tmp : ""));
2895
2896   //  silc_socket_set_qos(sock, 0, 0, 0, 0, NULL);
2897
2898   if (idata && idata->sconn) {
2899     silc_server_connection_free(idata->sconn);
2900     idata->sconn = NULL;
2901   }
2902
2903   /* Take a reference and then destroy the stream.  The last reference
2904      is released later in a timeout callback. */
2905   silc_packet_stream_ref(sock);
2906   silc_packet_stream_destroy(sock);
2907
2908   /* Close connection with timeout */
2909   server->stat.conn_num--;
2910   silc_schedule_task_del_by_all(server->schedule, 0,
2911                                 silc_server_close_connection_final, sock);
2912   silc_schedule_task_add_timeout(server->schedule,
2913                                  silc_server_close_connection_final,
2914                                  sock, 0, 1);
2915 }
2916
2917 /* Sends disconnect message to remote connection and disconnects the
2918    connection. */
2919
2920 void silc_server_disconnect_remote(SilcServer server,
2921                                    SilcPacketStream sock,
2922                                    SilcStatus status, ...)
2923 {
2924   unsigned char buf[512];
2925   va_list ap;
2926   char *cp;
2927
2928   if (!sock)
2929     return;
2930
2931   SILC_LOG_DEBUG(("Disconnecting remote host"));
2932
2933   va_start(ap, status);
2934   cp = va_arg(ap, char *);
2935   if (cp)
2936     silc_vsnprintf(buf, sizeof(buf), cp, ap);
2937   va_end(ap);
2938
2939   /* Send SILC_PACKET_DISCONNECT */
2940   silc_packet_send_va(sock, SILC_PACKET_DISCONNECT, 0,
2941                       SILC_STR_UI_CHAR(status),
2942                       SILC_STR_UI8_STRING(cp ? buf : NULL),
2943                       SILC_STR_END);
2944
2945   /* Close connection */
2946   silc_server_close_connection(server, sock);
2947 }
2948
2949 /* Frees client data and notifies about client's signoff. */
2950
2951 void silc_server_free_client_data(SilcServer server,
2952                                   SilcPacketStream sock,
2953                                   SilcClientEntry client,
2954                                   int notify,
2955                                   const char *signoff)
2956 {
2957   SILC_LOG_DEBUG(("Freeing client %p data", client));
2958
2959   if (client->id) {
2960     /* Check if anyone is watching this nickname */
2961     if (server->server_type == SILC_ROUTER)
2962       silc_server_check_watcher_list(server, client, NULL,
2963                                      SILC_NOTIFY_TYPE_SIGNOFF);
2964
2965     /* Send SIGNOFF notify to routers. */
2966     if (notify)
2967       silc_server_send_notify_signoff(server, SILC_PRIMARY_ROUTE(server),
2968                                       SILC_BROADCAST(server), client->id,
2969                                       signoff);
2970   }
2971
2972   /* Remove client from all channels */
2973   if (notify)
2974     silc_server_remove_from_channels(server, NULL, client,
2975                                      TRUE, (char *)signoff, TRUE, FALSE);
2976   else
2977     silc_server_remove_from_channels(server, NULL, client,
2978                                      FALSE, NULL, FALSE, FALSE);
2979
2980   /* Remove this client from watcher list if it is */
2981   silc_server_del_from_watcher_list(server, client);
2982
2983   /* Remove client's public key from repository, this will free it too. */
2984   if (client->data.public_key) {
2985     silc_skr_del_public_key(server->repository, client->data.public_key,
2986                             client);
2987     client->data.public_key = NULL;
2988   }
2989
2990   /* Update statistics */
2991   server->stat.my_clients--;
2992   server->stat.clients--;
2993   if (server->stat.cell_clients)
2994     server->stat.cell_clients--;
2995   SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
2996   SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
2997   silc_schedule_task_del_by_context(server->schedule, client);
2998
2999   if (client->data.sconn) {
3000     silc_server_connection_free(client->data.sconn);
3001     client->data.sconn = NULL;
3002   }
3003
3004   /* We will not delete the client entry right away. We will take it
3005      into history (for WHOWAS command) for 5 minutes, unless we're
3006      shutting down server. */
3007   if (!server->server_shutdown) {
3008     client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
3009     client->mode = 0;
3010     client->router = NULL;
3011     client->connection = NULL;
3012     client->data.created = silc_time();
3013     silc_dlist_add(server->expired_clients, client);
3014   } else {
3015     /* Delete directly since we're shutting down server */
3016     SILC_LOG_DEBUG(("Delete client directly"));
3017     silc_idlist_del_data(client);
3018     silc_idlist_del_client(server->local_list, client);
3019   }
3020 }
3021
3022 /* Frees user_data pointer from socket connection object. This also sends
3023    appropriate notify packets to the network to inform about leaving
3024    entities. */
3025
3026 void silc_server_free_sock_user_data(SilcServer server,
3027                                      SilcPacketStream sock,
3028                                      const char *signoff_message)
3029 {
3030   SilcIDListData idata = silc_packet_get_context(sock);
3031   const char *ip;
3032   SilcUInt16 port;
3033
3034   SILC_LOG_DEBUG(("Start"));
3035
3036   if (!idata)
3037     return;
3038
3039   silc_schedule_task_del_by_all(server->schedule, 0, silc_server_do_rekey,
3040                                 sock);
3041
3042   /* Cancel active protocols */
3043   if (idata) {
3044     if (idata->sconn && idata->sconn->op) {
3045       SILC_LOG_DEBUG(("Abort active protocol"));
3046       silc_async_abort(idata->sconn->op, NULL, NULL);
3047     }
3048     if (idata->conn_type == SILC_CONN_UNKNOWN &&
3049         ((SilcUnknownEntry)idata)->op) {
3050       SILC_LOG_DEBUG(("Abort active protocol"));
3051       silc_async_abort(((SilcUnknownEntry)idata)->op, NULL, NULL);
3052     }
3053   }
3054
3055   switch (idata->conn_type) {
3056   case SILC_CONN_CLIENT:
3057     {
3058       SilcClientEntry client_entry = (SilcClientEntry)idata;
3059       silc_server_free_client_data(server, sock, client_entry, TRUE,
3060                                    signoff_message);
3061       silc_packet_set_context(sock, NULL);
3062       break;
3063     }
3064
3065   case SILC_CONN_SERVER:
3066   case SILC_CONN_ROUTER:
3067     {
3068       SilcServerEntry user_data = (SilcServerEntry)idata;
3069       SilcServerEntry backup_router = NULL;
3070
3071       SILC_LOG_DEBUG(("Freeing server %p data", user_data));
3072
3073       if (user_data->id)
3074         backup_router = silc_server_backup_get(server, user_data->id);
3075
3076       if (!server->backup_router && server->server_type == SILC_ROUTER &&
3077           backup_router == server->id_entry &&
3078           idata->conn_type != SILC_CONN_ROUTER)
3079         backup_router = NULL;
3080
3081       if (server->server_shutdown || server->backup_noswitch)
3082         backup_router = NULL;
3083
3084       silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
3085                                   NULL, NULL, &ip, &port);
3086
3087       /* If this was our primary router connection then we're lost to
3088          the outside world. */
3089       if (server->router == user_data) {
3090         /* Check whether we have a backup router connection */
3091         if (!backup_router || backup_router == user_data) {
3092           if (!server->no_reconnect)
3093             silc_server_create_connections(server);
3094           server->id_entry->router = NULL;
3095           server->router = NULL;
3096           server->standalone = TRUE;
3097           server->backup_primary = FALSE;
3098           backup_router = NULL;
3099         } else {
3100           if (server->id_entry != backup_router) {
3101             SILC_LOG_INFO(("New primary router is backup router %s",
3102                            backup_router->server_name));
3103             server->id_entry->router = backup_router;
3104             server->router = backup_router;
3105             server->router_connect = time(0);
3106             server->backup_primary = TRUE;
3107             backup_router->data.status &= ~SILC_IDLIST_STATUS_DISABLED;
3108
3109             /* Send START_USE to backup router to indicate we have switched */
3110             silc_server_backup_send_start_use(server,
3111                                               backup_router->connection,
3112                                               FALSE);
3113           } else {
3114             SILC_LOG_INFO(("We are now new primary router in this cell"));
3115             server->id_entry->router = NULL;
3116             server->router = NULL;
3117             server->standalone = TRUE;
3118           }
3119
3120           /* We stop here to take a breath */
3121           sleep(2);
3122
3123           if (server->backup_router) {
3124             server->server_type = SILC_ROUTER;
3125
3126             /* We'll need to constantly try to reconnect to the primary
3127                router so that we'll see when it comes back online. */
3128             silc_server_create_connection(server, FALSE, FALSE, ip, port,
3129                                          silc_server_backup_connected,
3130                                          NULL);
3131           }
3132
3133           /* Mark this connection as replaced */
3134           silc_server_backup_replaced_add(server, user_data->id,
3135                                           backup_router);
3136         }
3137       } else if (backup_router) {
3138         SILC_LOG_INFO(("Enabling the use of backup router %s",
3139                        backup_router->server_name));
3140
3141         /* Mark this connection as replaced */
3142         silc_server_backup_replaced_add(server, user_data->id,
3143                                         backup_router);
3144       } else if (server->server_type == SILC_SERVER &&
3145                  idata->conn_type == SILC_CONN_ROUTER) {
3146         /* Reconnect to the router (backup) */
3147         if (!server->no_reconnect)
3148           silc_server_create_connections(server);
3149       }
3150
3151       if (user_data->server_name)
3152         SILC_SERVER_SEND_OPERS(server, FALSE, TRUE, SILC_NOTIFY_TYPE_NONE,
3153                                ("Server %s signoff", user_data->server_name));
3154
3155       if (!backup_router) {
3156         /* Remove all servers that are originated from this server, and
3157            remove the clients of those servers too. */
3158         silc_server_remove_servers_by_server(server, user_data, TRUE);
3159
3160 #if 0
3161         /* Remove the clients that this server owns as they will become
3162            invalid now too.  For backup router the server is actually
3163            coming from the primary router, so mark that as the owner
3164            of this entry. */
3165         if (server->server_type == SILC_BACKUP_ROUTER &&
3166             sock->type == SILC_CONN_SERVER)
3167           silc_server_remove_clients_by_server(server, server->router,
3168                                                user_data, TRUE);
3169         else
3170 #endif
3171           silc_server_remove_clients_by_server(server, user_data,
3172                                                user_data, TRUE);
3173
3174         /* Remove channels owned by this server */
3175         if (server->server_type == SILC_SERVER)
3176           silc_server_remove_channels_by_server(server, user_data);
3177       } else {
3178         /* Enable local server connections that may be disabled */
3179         silc_server_local_servers_toggle_enabled(server, TRUE);
3180
3181         /* Update the client entries of this server to the new backup
3182            router.  If we are the backup router we also resolve the real
3183            servers for the clients.  After updating is over this also
3184            removes the clients that this server explicitly owns. */
3185         silc_server_update_clients_by_server(server, user_data,
3186                                              backup_router, TRUE);
3187
3188         /* If we are router and just lost our primary router (now standlaone)
3189            we remove everything that was behind it, since we don't know
3190            any better. */
3191         if (server->server_type == SILC_ROUTER && server->standalone)
3192           /* Remove all servers that are originated from this server, and
3193              remove the clients of those servers too. */
3194           silc_server_remove_servers_by_server(server, user_data, TRUE);
3195
3196         /* Finally remove the clients that are explicitly owned by this
3197            server.  They go down with the server. */
3198         silc_server_remove_clients_by_server(server, user_data,
3199                                              user_data, TRUE);
3200
3201         /* Update our server cache to use the new backup router too. */
3202         silc_server_update_servers_by_server(server, user_data, backup_router);
3203         if (server->server_type == SILC_SERVER)
3204           silc_server_update_channels_by_server(server, user_data,
3205                                                 backup_router);
3206
3207         /* Send notify about primary router going down to local operators */
3208         if (server->backup_router)
3209           SILC_SERVER_SEND_OPERS(server, FALSE, TRUE,
3210                                  SILC_NOTIFY_TYPE_NONE,
3211                                  ("%s switched to backup router %s "
3212                                   "(we are primary router now)",
3213                                   server->server_name, server->server_name));
3214         else if (server->router)
3215           SILC_SERVER_SEND_OPERS(server, FALSE, TRUE,
3216                                  SILC_NOTIFY_TYPE_NONE,
3217                                  ("%s switched to backup router %s",
3218                                   server->server_name,
3219                                   server->router->server_name));
3220       }
3221       server->backup_noswitch = FALSE;
3222
3223       if (idata->sconn)
3224         silc_server_connection_free(idata->sconn);
3225
3226       /* Statistics */
3227       if (idata->conn_type == SILC_CONN_SERVER) {
3228         server->stat.my_servers--;
3229         server->stat.servers--;
3230         SILC_LOG_DEBUG(("my_servers %d", server->stat.my_servers));
3231       } else if (idata->conn_type == SILC_CONN_ROUTER) {
3232         server->stat.my_routers--;
3233         server->stat.routers--;
3234         SILC_LOG_DEBUG(("my_routers %d", server->stat.my_routers));
3235       }
3236       if (server->server_type == SILC_ROUTER)
3237         server->stat.cell_servers--;
3238
3239       /* Free the server entry */
3240       silc_server_backup_del(server, user_data);
3241       silc_server_backup_replaced_del(server, user_data);
3242       silc_idlist_del_data(user_data);
3243       if (!silc_idlist_del_server(server->local_list, user_data))
3244         silc_idlist_del_server(server->global_list, user_data);
3245
3246       if (backup_router && backup_router != server->id_entry) {
3247         /* Announce all of our stuff that was created about 5 minutes ago.
3248            The backup router knows all the other stuff already. */
3249         if (server->server_type == SILC_ROUTER)
3250           silc_server_announce_servers(server, FALSE, time(0) - 300,
3251                                        backup_router->connection);
3252
3253         /* Announce our clients and channels to the router */
3254         silc_server_announce_clients(server, time(0) - 300,
3255                                      backup_router->connection);
3256         silc_server_announce_channels(server, time(0) - 300,
3257                                       backup_router->connection);
3258       }
3259
3260       silc_packet_set_context(sock, NULL);
3261       break;
3262     }
3263
3264   default:
3265     {
3266       SilcUnknownEntry entry = (SilcUnknownEntry)idata;
3267
3268       SILC_LOG_DEBUG(("Freeing unknown connection data"));
3269
3270       if (idata->sconn)
3271         silc_server_connection_free(idata->sconn);
3272       silc_idlist_del_data(idata);
3273       silc_free(entry);
3274       silc_packet_set_context(sock, NULL);
3275       break;
3276     }
3277   }
3278 }
3279
3280 /* Removes client from all channels it has joined. This is used when client
3281    connection is disconnected. If the client on a channel is last, the
3282    channel is removed as well. This sends the SIGNOFF notify types. */
3283
3284 void silc_server_remove_from_channels(SilcServer server,
3285                                       SilcPacketStream sock,
3286                                       SilcClientEntry client,
3287                                       SilcBool notify,
3288                                       const char *signoff_message,
3289                                       SilcBool keygen,
3290                                       SilcBool killed)
3291 {
3292   SilcChannelEntry channel;
3293   SilcChannelClientEntry chl;
3294   SilcHashTableList htl;
3295   SilcBuffer clidp = NULL;
3296
3297   if (!client)
3298     return;
3299
3300   if (notify && !client->id)
3301     notify = FALSE;
3302
3303   SILC_LOG_DEBUG(("Removing client %s from joined channels",
3304                   notify ? silc_id_render(client->id, SILC_ID_CLIENT) : ""));
3305
3306   if (notify) {
3307     clidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
3308     if (!clidp)
3309       notify = FALSE;
3310   }
3311
3312   /* Remove the client from all channels. The client is removed from
3313      the channels' user list. */
3314   silc_hash_table_list(client->channels, &htl);
3315   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
3316     channel = chl->channel;
3317
3318     /* Remove channel if this is last client leaving the channel, unless
3319        the channel is permanent. */
3320     if (server->server_type != SILC_SERVER &&
3321         silc_hash_table_count(channel->user_list) < 2) {
3322       silc_server_channel_delete(server, channel);
3323       continue;
3324     }
3325
3326     silc_hash_table_del(client->channels, channel);
3327     silc_hash_table_del(channel->user_list, client);
3328     channel->user_count--;
3329
3330     /* If there is no global users on the channel anymore mark the channel
3331        as local channel. Do not check if the removed client is local client. */
3332     if (server->server_type == SILC_SERVER && channel->global_users &&
3333         chl->client->router && !silc_server_channel_has_global(channel))
3334       channel->global_users = FALSE;
3335
3336     memset(chl, 'A', sizeof(*chl));
3337     silc_free(chl);
3338
3339     /* Update statistics */
3340     if (SILC_IS_LOCAL(client))
3341       server->stat.my_chanclients--;
3342     if (server->server_type == SILC_ROUTER) {
3343       server->stat.cell_chanclients--;
3344       server->stat.chanclients--;
3345     }
3346
3347     /* If there is not at least one local user on the channel then we don't
3348        need the channel entry anymore, we can remove it safely, unless the
3349        channel is permanent channel */
3350     if (server->server_type == SILC_SERVER &&
3351         !silc_server_channel_has_local(channel)) {
3352       /* Notify about leaving client if this channel has global users. */
3353       if (notify && channel->global_users)
3354         silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
3355                                            SILC_NOTIFY_TYPE_SIGNOFF,
3356                                            signoff_message ? 2 : 1,
3357                                            clidp->data, silc_buffer_len(clidp),
3358                                            signoff_message, signoff_message ?
3359                                            strlen(signoff_message) : 0);
3360
3361       silc_schedule_task_del_by_context(server->schedule, channel->rekey);
3362       silc_server_channel_delete(server, channel);
3363       continue;
3364     }
3365
3366     /* Send notify to channel about client leaving SILC and channel too */
3367     if (notify)
3368       silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
3369                                          SILC_NOTIFY_TYPE_SIGNOFF,
3370                                          signoff_message ? 2 : 1,
3371                                          clidp->data, silc_buffer_len(clidp),
3372                                          signoff_message, signoff_message ?
3373                                          strlen(signoff_message) : 0);
3374
3375     if (killed && clidp) {
3376       /* Remove the client from channel's invite list */
3377       if (channel->invite_list &&
3378           silc_hash_table_count(channel->invite_list)) {
3379         SilcBuffer ab;
3380         SilcArgumentPayload iargs;
3381         ab = silc_argument_payload_encode_one(NULL, clidp->data,
3382                                               silc_buffer_len(clidp), 3);
3383         iargs = silc_argument_payload_parse(ab->data, silc_buffer_len(ab), 1);
3384         silc_server_inviteban_process(server, channel->invite_list, 1, iargs);
3385         silc_buffer_free(ab);
3386         silc_argument_payload_free(iargs);
3387       }
3388     }
3389
3390     /* Don't create keys if we are shutting down */
3391     if (server->server_shutdown)
3392       continue;
3393
3394     /* Re-generate channel key if needed */
3395     if (keygen && !(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
3396       if (!silc_server_create_channel_key(server, channel, 0))
3397         continue;
3398
3399       /* Send the channel key to the channel. The key of course is not sent
3400          to the client who was removed from the channel. */
3401       silc_server_send_channel_key(server, client->connection, channel,
3402                                    server->server_type == SILC_ROUTER ?
3403                                    FALSE : !server->standalone);
3404     }
3405   }
3406
3407   silc_hash_table_list_reset(&htl);
3408   if (clidp)
3409     silc_buffer_free(clidp);
3410 }
3411
3412 /* Removes client from one channel. This is used for example when client
3413    calls LEAVE command to remove itself from the channel. Returns TRUE
3414    if channel still exists and FALSE if the channel is removed when
3415    last client leaves the channel. If `notify' is FALSE notify messages
3416    are not sent. */
3417
3418 SilcBool silc_server_remove_from_one_channel(SilcServer server,
3419                                          SilcPacketStream sock,
3420                                          SilcChannelEntry channel,
3421                                          SilcClientEntry client,
3422                                          SilcBool notify)
3423 {
3424   SilcChannelClientEntry chl;
3425   SilcBuffer clidp;
3426
3427   SILC_LOG_DEBUG(("Removing %s from channel %s",
3428                   silc_id_render(client->id, SILC_ID_CLIENT),
3429                   channel->channel_name));
3430
3431   /* Get the entry to the channel, if this client is not on the channel
3432      then return Ok. */
3433   if (!silc_hash_table_find(client->channels, channel, NULL, (void *)&chl))
3434     return TRUE;
3435
3436   /* Remove channel if this is last client leaving the channel, unless
3437      the channel is permanent. */
3438   if (server->server_type != SILC_SERVER &&
3439       silc_hash_table_count(channel->user_list) < 2) {
3440     silc_server_channel_delete(server, channel);
3441     return FALSE;
3442   }
3443
3444   silc_hash_table_del(client->channels, channel);
3445   silc_hash_table_del(channel->user_list, client);
3446   channel->user_count--;
3447
3448   /* If there is no global users on the channel anymore mark the channel
3449      as local channel. Do not check if the client is local client. */
3450   if (server->server_type == SILC_SERVER && channel->global_users &&
3451       chl->client->router && !silc_server_channel_has_global(channel))
3452     channel->global_users = FALSE;
3453
3454   memset(chl, 'O', sizeof(*chl));
3455   silc_free(chl);
3456
3457   /* Update statistics */
3458   if (SILC_IS_LOCAL(client))
3459     server->stat.my_chanclients--;
3460   if (server->server_type == SILC_ROUTER) {
3461     server->stat.cell_chanclients--;
3462     server->stat.chanclients--;
3463   }
3464
3465   clidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
3466   if (!clidp)
3467     notify = FALSE;
3468
3469   /* If there is not at least one local user on the channel then we don't
3470      need the channel entry anymore, we can remove it safely, unless the
3471      channel is permanent channel */
3472   if (server->server_type == SILC_SERVER &&
3473       !silc_server_channel_has_local(channel)) {
3474     /* Notify about leaving client if this channel has global users. */
3475     if (notify && channel->global_users)
3476       silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
3477                                          SILC_NOTIFY_TYPE_LEAVE, 1,
3478                                          clidp->data, silc_buffer_len(clidp));
3479
3480     silc_schedule_task_del_by_context(server->schedule, channel->rekey);
3481     silc_server_channel_delete(server, channel);
3482     silc_buffer_free(clidp);
3483     return FALSE;
3484   }
3485
3486   /* Send notify to channel about client leaving the channel */
3487   if (notify)
3488     silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
3489                                        SILC_NOTIFY_TYPE_LEAVE, 1,
3490                                        clidp->data, silc_buffer_len(clidp));
3491
3492   silc_buffer_free(clidp);
3493   return TRUE;
3494 }
3495
3496 /* Creates new channel. Sends NEW_CHANNEL packet to primary route. This
3497    function may be used only by router. In real SILC network all channels
3498    are created by routers thus this function is never used by normal
3499    server. */
3500
3501 SilcChannelEntry silc_server_create_new_channel(SilcServer server,
3502                                                 SilcServerID *router_id,
3503                                                 char *cipher,
3504                                                 char *hmac,
3505                                                 char *channel_name,
3506                                                 int broadcast)
3507 {
3508   SilcChannelID *channel_id;
3509   SilcChannelEntry entry;
3510   SilcCipher send_key, receive_key;
3511   SilcHmac newhmac;
3512
3513   SILC_LOG_DEBUG(("Creating new channel %s", channel_name));
3514
3515   if (!cipher)
3516     cipher = SILC_DEFAULT_CIPHER;
3517   if (!hmac)
3518     hmac = SILC_DEFAULT_HMAC;
3519
3520   /* Allocate cipher */
3521   if (!silc_cipher_alloc(cipher, &send_key))
3522     return NULL;
3523   if (!silc_cipher_alloc(cipher, &receive_key)) {
3524     silc_cipher_free(send_key);
3525     return NULL;
3526   }
3527
3528   /* Allocate hmac */
3529   if (!silc_hmac_alloc(hmac, NULL, &newhmac)) {
3530     silc_cipher_free(send_key);
3531     silc_cipher_free(receive_key);
3532     return NULL;
3533   }
3534
3535   channel_name = strdup(channel_name);
3536
3537   /* Create the channel ID */
3538   if (!silc_id_create_channel_id(server, router_id, server->rng,
3539                                  &channel_id)) {
3540     silc_free(channel_name);
3541     silc_cipher_free(send_key);
3542     silc_cipher_free(receive_key);
3543     silc_hmac_free(newhmac);
3544     return NULL;
3545   }
3546
3547   /* Create the channel */
3548   entry = silc_idlist_add_channel(server->local_list, channel_name,
3549                                   SILC_CHANNEL_MODE_NONE, channel_id,
3550                                   NULL, send_key, receive_key, newhmac);
3551   if (!entry) {
3552     silc_free(channel_name);
3553     silc_cipher_free(send_key);
3554     silc_cipher_free(receive_key);
3555     silc_hmac_free(newhmac);
3556     silc_free(channel_id);
3557     return NULL;
3558   }
3559
3560   entry->cipher = strdup(cipher);
3561   entry->hmac_name = strdup(hmac);
3562
3563   /* Now create the actual key material */
3564   if (!silc_server_create_channel_key(server, entry,
3565                                       silc_cipher_get_key_len(send_key) / 8)) {
3566     silc_idlist_del_channel(server->local_list, entry);
3567     return NULL;
3568   }
3569
3570   /* Notify other routers about the new channel. We send the packet
3571      to our primary route. */
3572   if (broadcast)
3573     silc_server_send_new_channel(server, SILC_PRIMARY_ROUTE(server), TRUE,
3574                                  channel_name, entry->id,
3575                                  silc_id_get_len(entry->id, SILC_ID_CHANNEL),
3576                                  entry->mode);
3577
3578   /* Distribute to backup routers */
3579   if (broadcast && server->server_type == SILC_ROUTER) {
3580     SilcBuffer packet;
3581     unsigned char cid[32];
3582     SilcUInt32 name_len = strlen(channel_name);
3583     SilcUInt32 id_len;
3584
3585     silc_id_id2str(entry->id, SILC_ID_CHANNEL, cid, sizeof(cid), &id_len);
3586     packet = silc_channel_payload_encode(channel_name, name_len,
3587                                          cid, id_len, entry->mode);
3588     silc_server_backup_send(server, NULL, SILC_PACKET_NEW_CHANNEL, 0,
3589                             packet->data, silc_buffer_len(packet), FALSE,
3590                             TRUE);
3591     silc_buffer_free(packet);
3592   }
3593
3594   server->stat.my_channels++;
3595   if (server->server_type == SILC_ROUTER) {
3596     server->stat.channels++;
3597     server->stat.cell_channels++;
3598     entry->users_resolved = TRUE;
3599   }
3600
3601   return entry;
3602 }
3603
3604 /* Same as above but creates the channel with Channel ID `channel_id. */
3605
3606 SilcChannelEntry
3607 silc_server_create_new_channel_with_id(SilcServer server,
3608                                        char *cipher,
3609                                        char *hmac,
3610                                        char *channel_name,
3611                                        SilcChannelID *channel_id,
3612                                        int broadcast)
3613 {
3614   SilcChannelEntry entry;
3615   SilcCipher send_key, receive_key;
3616   SilcHmac newhmac;
3617
3618   SILC_LOG_DEBUG(("Creating new channel %s", channel_name));
3619
3620   if (!cipher)
3621     cipher = SILC_DEFAULT_CIPHER;
3622   if (!hmac)
3623     hmac = SILC_DEFAULT_HMAC;
3624
3625   /* Allocate cipher */
3626   if (!silc_cipher_alloc(cipher, &send_key))
3627     return NULL;
3628   if (!silc_cipher_alloc(cipher, &receive_key)) {
3629     silc_cipher_free(send_key);
3630     return NULL;
3631   }
3632
3633   /* Allocate hmac */
3634   if (!silc_hmac_alloc(hmac, NULL, &newhmac)) {
3635     silc_cipher_free(send_key);
3636     silc_cipher_free(receive_key);
3637     return NULL;
3638   }
3639
3640   channel_name = strdup(channel_name);
3641
3642   /* Create the channel */
3643   entry = silc_idlist_add_channel(server->local_list, channel_name,
3644                                   SILC_CHANNEL_MODE_NONE, channel_id,
3645                                   NULL, send_key, receive_key, newhmac);
3646   if (!entry) {
3647     silc_cipher_free(send_key);
3648     silc_cipher_free(receive_key);
3649     silc_hmac_free(newhmac);
3650     silc_free(channel_name);
3651     return NULL;
3652   }
3653
3654   /* Now create the actual key material */
3655   if (!silc_server_create_channel_key(server, entry,
3656                                       silc_cipher_get_key_len(send_key) / 8)) {
3657     silc_idlist_del_channel(server->local_list, entry);
3658     return NULL;
3659   }
3660
3661   /* Notify other routers about the new channel. We send the packet
3662      to our primary route. */
3663   if (broadcast)
3664     silc_server_send_new_channel(server, SILC_PRIMARY_ROUTE(server), TRUE,
3665                                  channel_name, entry->id,
3666                                  silc_id_get_len(entry->id, SILC_ID_CHANNEL),
3667                                  entry->mode);
3668
3669   /* Distribute to backup routers */
3670   if (broadcast && server->server_type == SILC_ROUTER) {
3671     SilcBuffer packet;
3672     unsigned char cid[32];
3673     SilcUInt32 name_len = strlen(channel_name);
3674     SilcUInt32 id_len;
3675
3676     silc_id_id2str(entry->id, SILC_ID_CHANNEL, cid, sizeof(cid), &id_len);
3677     packet = silc_channel_payload_encode(channel_name, name_len,
3678                                          cid, id_len, entry->mode);
3679     silc_server_backup_send(server, NULL, SILC_PACKET_NEW_CHANNEL, 0,
3680                             packet->data, silc_buffer_len(packet), FALSE,
3681                             TRUE);
3682     silc_buffer_free(packet);
3683   }
3684
3685   server->stat.my_channels++;
3686   if (server->server_type == SILC_ROUTER) {
3687     server->stat.channels++;
3688     server->stat.cell_channels++;
3689     entry->users_resolved = TRUE;
3690   }
3691
3692   return entry;
3693 }
3694
3695 /* Channel's key re-key timeout callback. */
3696
3697 SILC_TASK_CALLBACK(silc_server_channel_key_rekey)
3698 {
3699   SilcServer server = app_context;
3700   SilcServerChannelRekey rekey = (SilcServerChannelRekey)context;
3701
3702   rekey->task = NULL;
3703
3704   /* Return now if we are shutting down */
3705   if (server->server_shutdown)
3706     return;
3707
3708   if (!silc_server_create_channel_key(server, rekey->channel, rekey->key_len))
3709     return;
3710
3711   silc_server_send_channel_key(server, NULL, rekey->channel, FALSE);
3712 }
3713
3714 /* Generates new channel key. This is used to create the initial channel key
3715    but also to re-generate new key for channel. If `key_len' is provided
3716    it is the bytes of the key length. */
3717
3718 SilcBool silc_server_create_channel_key(SilcServer server,
3719                                         SilcChannelEntry channel,
3720                                         SilcUInt32 key_len)
3721 {
3722   int i;
3723   unsigned char channel_key[32], hash[SILC_HASH_MAXLEN];
3724   SilcUInt32 len;
3725
3726   if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY) {
3727     SILC_LOG_DEBUG(("Channel has private keys, will not generate new key"));
3728     return TRUE;
3729   }
3730
3731   SILC_LOG_DEBUG(("Generating channel %s key", channel->channel_name));
3732
3733   if (!channel->send_key)
3734     if (!silc_cipher_alloc(SILC_DEFAULT_CIPHER, &channel->send_key)) {
3735       channel->send_key = NULL;
3736       return FALSE;
3737     }
3738   if (!channel->receive_key)
3739     if (!silc_cipher_alloc(SILC_DEFAULT_CIPHER, &channel->receive_key)) {
3740       silc_cipher_free(channel->send_key);
3741       channel->send_key = channel->receive_key = NULL;
3742       return FALSE;
3743     }
3744
3745   if (key_len)
3746     len = key_len;
3747   else if (channel->key_len)
3748     len = channel->key_len / 8;
3749   else
3750     len = silc_cipher_get_key_len(channel->send_key) / 8;
3751
3752   /* Create channel key */
3753   for (i = 0; i < len; i++) channel_key[i] = silc_rng_get_byte(server->rng);
3754
3755   /* Set the key */
3756   silc_cipher_set_key(channel->send_key, channel_key, len * 8, TRUE);
3757   silc_cipher_set_key(channel->receive_key, channel_key, len * 8, FALSE);
3758
3759   /* Remove old key if exists */
3760   if (channel->key) {
3761     memset(channel->key, 0, channel->key_len / 8);
3762     silc_free(channel->key);
3763   }
3764
3765   /* Save the key */
3766   channel->key_len = len * 8;
3767   channel->key = silc_memdup(channel_key, len);
3768   memset(channel_key, 0, sizeof(channel_key));
3769
3770   /* Generate HMAC key from the channel key data and set it */
3771   if (!channel->hmac)
3772     if (!silc_hmac_alloc(SILC_DEFAULT_HMAC, NULL, &channel->hmac)) {
3773       memset(channel->key, 0, channel->key_len / 8);
3774       silc_free(channel->key);
3775       silc_cipher_free(channel->send_key);
3776       silc_cipher_free(channel->receive_key);
3777       channel->send_key = channel->receive_key = NULL;
3778       return FALSE;
3779     }
3780   silc_hash_make(silc_hmac_get_hash(channel->hmac), channel->key, len, hash);
3781   silc_hmac_set_key(channel->hmac, hash,
3782                     silc_hash_len(silc_hmac_get_hash(channel->hmac)));
3783   memset(hash, 0, sizeof(hash));
3784
3785   if (server->server_type == SILC_ROUTER) {
3786     if (!channel->rekey)
3787       channel->rekey = silc_calloc(1, sizeof(*channel->rekey));
3788     channel->rekey->channel = channel;
3789     channel->rekey->key_len = key_len;
3790     if (channel->rekey->task)
3791       silc_schedule_task_del(server->schedule, channel->rekey->task);
3792
3793     channel->rekey->task =
3794       silc_schedule_task_add_timeout(server->schedule,
3795                                      silc_server_channel_key_rekey,
3796                                      (void *)channel->rekey,
3797                                      server->config->channel_rekey_secs, 0);
3798   }
3799
3800   return TRUE;
3801 }
3802
3803 /* Saves the channel key found in the encoded `key_payload' buffer. This
3804    function is used when we receive Channel Key Payload and also when we're
3805    processing JOIN command reply. Returns entry to the channel. */
3806
3807 SilcChannelEntry silc_server_save_channel_key(SilcServer server,
3808                                               SilcBuffer key_payload,
3809                                               SilcChannelEntry channel)
3810 {
3811   SilcChannelKeyPayload payload = NULL;
3812   SilcChannelID id;
3813   unsigned char *tmp, hash[SILC_HASH_MAXLEN];
3814   SilcUInt32 tmp_len;
3815   char *cipher;
3816
3817   /* Decode channel key payload */
3818   payload = silc_channel_key_payload_parse(key_payload->data,
3819                                            silc_buffer_len(key_payload));
3820   if (!payload) {
3821     SILC_LOG_ERROR(("Bad channel key payload received, dropped"));
3822     channel = NULL;
3823     goto out;
3824   }
3825
3826   /* Get the channel entry */
3827   if (!channel) {
3828
3829     /* Get channel ID */
3830     tmp = silc_channel_key_get_id(payload, &tmp_len);
3831     if (!silc_id_str2id(tmp, tmp_len, SILC_ID_CHANNEL, &id, sizeof(id))) {
3832       channel = NULL;
3833       goto out;
3834     }
3835
3836     channel = silc_idlist_find_channel_by_id(server->local_list, &id, NULL);
3837     if (!channel) {
3838       channel = silc_idlist_find_channel_by_id(server->global_list, &id, NULL);
3839       if (!channel) {
3840         if (server->server_type == SILC_ROUTER)
3841           SILC_LOG_ERROR(("Received key for non-existent channel %s",
3842                           silc_id_render(&id, SILC_ID_CHANNEL)));
3843         goto out;
3844       }
3845     }
3846   }
3847
3848   SILC_LOG_DEBUG(("Saving new channel %s key", channel->channel_name));
3849
3850   tmp = silc_channel_key_get_key(payload, &tmp_len);
3851   if (!tmp) {
3852     channel = NULL;
3853     goto out;
3854   }
3855
3856   cipher = silc_channel_key_get_cipher(payload, NULL);
3857   if (!cipher) {
3858     channel = NULL;
3859     goto out;
3860   }
3861
3862   /* Remove old key if exists */
3863   if (channel->key) {
3864     memset(channel->key, 0, channel->key_len / 8);
3865     silc_free(channel->key);
3866     silc_cipher_free(channel->send_key);
3867     silc_cipher_free(channel->receive_key);
3868   }
3869
3870   /* Create new cipher */
3871   if (!silc_cipher_alloc(cipher, &channel->send_key)) {
3872     channel->send_key = NULL;
3873     channel = NULL;
3874     goto out;
3875   }
3876   if (!silc_cipher_alloc(cipher, &channel->receive_key)) {
3877     silc_cipher_free(channel->send_key);
3878     channel->send_key = channel->receive_key = NULL;
3879     channel = NULL;
3880     goto out;
3881   }
3882
3883   if (channel->cipher)
3884     silc_free(channel->cipher);
3885   channel->cipher = strdup(cipher);
3886
3887   /* Save the key */
3888   channel->key_len = tmp_len * 8;
3889   channel->key = silc_memdup(tmp, tmp_len);
3890   silc_cipher_set_key(channel->send_key, tmp, channel->key_len, TRUE);
3891   silc_cipher_set_key(channel->receive_key, tmp, channel->key_len, FALSE);
3892
3893   /* Generate HMAC key from the channel key data and set it */
3894   if (!channel->hmac)
3895     if (!silc_hmac_alloc(SILC_DEFAULT_HMAC, NULL, &channel->hmac)) {
3896       memset(channel->key, 0, channel->key_len / 8);
3897       silc_free(channel->key);
3898       silc_cipher_free(channel->send_key);
3899       silc_cipher_free(channel->receive_key);
3900       channel->send_key = channel->receive_key = NULL;
3901       return FALSE;
3902     }
3903   silc_hash_make(silc_hmac_get_hash(channel->hmac), tmp, tmp_len, hash);
3904   silc_hmac_set_key(channel->hmac, hash,
3905                     silc_hash_len(silc_hmac_get_hash(channel->hmac)));
3906
3907   memset(hash, 0, sizeof(hash));
3908   memset(tmp, 0, tmp_len);
3909
3910   if (server->server_type == SILC_ROUTER) {
3911     if (!channel->rekey)
3912       channel->rekey = silc_calloc(1, sizeof(*channel->rekey));
3913     channel->rekey->channel = channel;
3914     if (channel->rekey->task)
3915       silc_schedule_task_del(server->schedule, channel->rekey->task);
3916
3917     channel->rekey->task =
3918       silc_schedule_task_add_timeout(server->schedule,
3919                                      silc_server_channel_key_rekey,
3920                                      (void *)channel->rekey,
3921                                      server->config->channel_rekey_secs, 0);
3922   }
3923
3924  out:
3925   if (payload)
3926     silc_channel_key_payload_free(payload);
3927
3928   return channel;
3929 }
3930
3931 /* Returns assembled of all servers in the given ID list. The packet's
3932    form is dictated by the New ID payload. */
3933
3934 static void silc_server_announce_get_servers(SilcServer server,
3935                                              SilcServerEntry remote,
3936                                              SilcIDList id_list,
3937                                              SilcBuffer *servers,
3938                                              unsigned long creation_time)
3939 {
3940   SilcList list;
3941   SilcIDCacheEntry id_cache;
3942   SilcServerEntry entry;
3943   SilcBuffer idp;
3944
3945   /* Go through all clients in the list */
3946   if (silc_idcache_get_all(id_list->servers, &list)) {
3947     silc_list_start(list);
3948     while ((id_cache = silc_list_get(list))) {
3949       entry = (SilcServerEntry)id_cache->context;
3950
3951       /* Do not announce the one we've sending our announcements and
3952          do not announce ourself. Also check the creation time if it's
3953          provided. */
3954       if ((entry == remote) || (entry == server->id_entry) ||
3955           (creation_time && entry->data.created < creation_time))
3956         continue;
3957
3958       idp = silc_id_payload_encode(entry->id, SILC_ID_SERVER);
3959
3960       *servers = silc_buffer_realloc(*servers,
3961                                      (*servers ?
3962                                       silc_buffer_truelen((*servers)) +
3963                                       silc_buffer_len(idp) :
3964                                       silc_buffer_len(idp)));
3965       silc_buffer_pull_tail(*servers, ((*servers)->end - (*servers)->data));
3966       silc_buffer_put(*servers, idp->data, silc_buffer_len(idp));
3967       silc_buffer_pull(*servers, silc_buffer_len(idp));
3968       silc_buffer_free(idp);
3969     }
3970   }
3971 }
3972
3973 static SilcBuffer
3974 silc_server_announce_encode_notify(SilcNotifyType notify, SilcUInt32 argc, ...)
3975 {
3976   va_list ap;
3977   SilcBuffer p;
3978
3979   va_start(ap, argc);
3980   p = silc_notify_payload_encode(notify, argc, ap);
3981   va_end(ap);
3982
3983   return p;
3984 }
3985
3986 /* This function is used by router to announce existing servers to our
3987    primary router when we've connected to it. If `creation_time' is non-zero
3988    then only the servers that has been created after the `creation_time'
3989    will be announced. */
3990
3991 void silc_server_announce_servers(SilcServer server, SilcBool global,
3992                                   unsigned long creation_time,
3993                                   SilcPacketStream remote)
3994 {
3995   SilcBuffer servers = NULL;
3996
3997   SILC_LOG_DEBUG(("Announcing servers"));
3998
3999   /* Get servers in local list */
4000   silc_server_announce_get_servers(server, silc_packet_get_context(remote),
4001                                    server->local_list, &servers,
4002                                    creation_time);
4003
4004   if (global)
4005     /* Get servers in global list */
4006     silc_server_announce_get_servers(server, silc_packet_get_context(remote),
4007                                      server->global_list, &servers,
4008                                      creation_time);
4009
4010   if (servers) {
4011     silc_buffer_push(servers, servers->data - servers->head);
4012     SILC_LOG_HEXDUMP(("servers"), servers->data, silc_buffer_len(servers));
4013
4014     /* Send the packet */
4015     silc_server_packet_send(server, remote,
4016                             SILC_PACKET_NEW_ID, SILC_PACKET_FLAG_LIST,
4017                             servers->data, silc_buffer_len(servers));
4018
4019     silc_buffer_free(servers);
4020   }
4021 }
4022
4023 /* Returns assembled packet of all clients in the given ID list. The
4024    packet's form is dictated by the New ID Payload. */
4025
4026 static void silc_server_announce_get_clients(SilcServer server,
4027                                              SilcIDList id_list,
4028                                              SilcBuffer *clients,
4029                                              SilcBuffer *umodes,
4030                                              unsigned long creation_time)
4031 {
4032   SilcList list;
4033   SilcIDCacheEntry id_cache;
4034   SilcClientEntry client;
4035   SilcBuffer idp;
4036   SilcBuffer tmp;
4037   unsigned char mode[4];
4038
4039   /* Go through all clients in the list */
4040   if (silc_idcache_get_all(id_list->clients, &list)) {
4041     silc_list_start(list);
4042     while ((id_cache = silc_list_get(list))) {
4043       client = (SilcClientEntry)id_cache->context;
4044
4045       if (creation_time && client->data.created < creation_time)
4046         continue;
4047       if (!(client->data.status & SILC_IDLIST_STATUS_REGISTERED))
4048         continue;
4049       if (!client->connection && !client->router)
4050         continue;
4051
4052       SILC_LOG_DEBUG(("Announce Client ID %s",
4053                       silc_id_render(client->id, SILC_ID_CLIENT)));
4054
4055       idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
4056
4057       *clients = silc_buffer_realloc(*clients,
4058                                      (*clients ?
4059                                       silc_buffer_truelen((*clients)) +
4060                                       silc_buffer_len(idp) :
4061                                       silc_buffer_len(idp)));
4062       silc_buffer_pull_tail(*clients, ((*clients)->end - (*clients)->data));
4063       silc_buffer_put(*clients, idp->data, silc_buffer_len(idp));
4064       silc_buffer_pull(*clients, silc_buffer_len(idp));
4065
4066       SILC_PUT32_MSB(client->mode, mode);
4067       tmp =
4068         silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_UMODE_CHANGE,
4069                                            2, idp->data, silc_buffer_len(idp),
4070                                            mode, 4);
4071       *umodes = silc_buffer_realloc(*umodes,
4072                                     (*umodes ?
4073                                      silc_buffer_truelen((*umodes)) +
4074                                      silc_buffer_len(tmp) :
4075                                      silc_buffer_len(tmp)));
4076       silc_buffer_pull_tail(*umodes, ((*umodes)->end - (*umodes)->data));
4077       silc_buffer_put(*umodes, tmp->data, silc_buffer_len(tmp));
4078       silc_buffer_pull(*umodes, silc_buffer_len(tmp));
4079       silc_buffer_free(tmp);
4080
4081       silc_buffer_free(idp);
4082     }
4083   }
4084 }
4085
4086 /* This function is used to announce our existing clients to our router
4087    when we've connected to it. If `creation_time' is non-zero then only
4088    the clients that has been created after the `creation_time' will be
4089    announced. */
4090
4091 void silc_server_announce_clients(SilcServer server,
4092                                   unsigned long creation_time,
4093                                   SilcPacketStream remote)
4094 {
4095   SilcBuffer clients = NULL;
4096   SilcBuffer umodes = NULL;
4097
4098   SILC_LOG_DEBUG(("Announcing clients"));
4099
4100   /* Get clients in local list */
4101   silc_server_announce_get_clients(server, server->local_list,
4102                                    &clients, &umodes, creation_time);
4103
4104   /* As router we announce our global list as well */
4105   if (server->server_type == SILC_ROUTER)
4106     silc_server_announce_get_clients(server, server->global_list,
4107                                      &clients, &umodes, creation_time);
4108
4109   if (clients) {
4110     silc_buffer_push(clients, clients->data - clients->head);
4111     SILC_LOG_HEXDUMP(("clients"), clients->data, silc_buffer_len(clients));
4112
4113     /* Send the packet */
4114     silc_server_packet_send(server, remote,
4115                             SILC_PACKET_NEW_ID, SILC_PACKET_FLAG_LIST,
4116                             clients->data, silc_buffer_len(clients));
4117
4118     silc_buffer_free(clients);
4119   }
4120
4121   if (umodes) {
4122     silc_buffer_push(umodes, umodes->data - umodes->head);
4123     SILC_LOG_HEXDUMP(("umodes"), umodes->data, silc_buffer_len(umodes));
4124
4125     /* Send the packet */
4126     silc_server_packet_send(server, remote,
4127                             SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4128                             umodes->data, silc_buffer_len(umodes));
4129
4130     silc_buffer_free(umodes);
4131   }
4132 }
4133
4134 /* Returns channel's topic for announcing it */
4135
4136 void silc_server_announce_get_channel_topic(SilcServer server,
4137                                             SilcChannelEntry channel,
4138                                             SilcBuffer *topic)
4139 {
4140   SilcBuffer chidp;
4141
4142   if (channel->topic) {
4143     chidp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL);
4144     *topic = silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_TOPIC_SET, 2,
4145                                                 chidp->data,
4146                                                 silc_buffer_len(chidp),
4147                                                 channel->topic,
4148                                                 strlen(channel->topic));
4149     silc_buffer_free(chidp);
4150   }
4151 }
4152
4153 /* Returns channel's invite and ban lists */
4154
4155 void silc_server_announce_get_inviteban(SilcServer server,
4156                                         SilcChannelEntry channel,
4157                                         SilcBuffer *invite,
4158                                         SilcBuffer *ban)
4159 {
4160   SilcBuffer list, idp, idp2, tmp2;
4161   SilcUInt32 type;
4162   void *ptype;
4163   SilcHashTableList htl;
4164   const unsigned char a[1] = { 0x03 };
4165
4166   idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
4167
4168   /* Encode invite list */
4169   if (channel->invite_list && silc_hash_table_count(channel->invite_list)) {
4170     list = silc_buffer_alloc_size(2);
4171     type = silc_hash_table_count(channel->invite_list);
4172     SILC_PUT16_MSB(type, list->data);
4173     silc_hash_table_list(channel->invite_list, &htl);
4174     while (silc_hash_table_get(&htl, (void *)&ptype, (void *)&tmp2))
4175       list = silc_argument_payload_encode_one(list, tmp2->data,
4176                                               silc_buffer_len(tmp2),
4177                                               SILC_PTR_TO_32(ptype));
4178     silc_hash_table_list_reset(&htl);
4179
4180     idp2 = silc_id_payload_encode(server->id, SILC_ID_SERVER);
4181     *invite =
4182       silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_INVITE, 5,
4183                                          idp->data, silc_buffer_len(idp),
4184                                          channel->channel_name,
4185                                          strlen(channel->channel_name),
4186                                          idp2->data, silc_buffer_len(idp2),
4187                                          a, 1,
4188                                          list->data, silc_buffer_len(list));
4189     silc_buffer_free(idp2);
4190     silc_buffer_free(list);
4191   }
4192
4193   /* Encode ban list */
4194   if (channel->ban_list && silc_hash_table_count(channel->ban_list)) {
4195     list = silc_buffer_alloc_size(2);
4196     type = silc_hash_table_count(channel->ban_list);
4197     SILC_PUT16_MSB(type, list->data);
4198     silc_hash_table_list(channel->ban_list, &htl);
4199     while (silc_hash_table_get(&htl, (void *)&ptype, (void *)&tmp2))
4200       list = silc_argument_payload_encode_one(list, tmp2->data,
4201                                               silc_buffer_len(tmp2),
4202                                               SILC_PTR_TO_32(ptype));
4203     silc_hash_table_list_reset(&htl);
4204
4205     *ban =
4206       silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_BAN, 3,
4207                                          idp->data, silc_buffer_len(idp),
4208                                          a, 1,
4209                                          list->data, silc_buffer_len(list));
4210     silc_buffer_free(list);
4211   }
4212
4213   silc_buffer_free(idp);
4214 }
4215
4216 /* Returns assembled packets for channel users of the `channel'. */
4217
4218 void silc_server_announce_get_channel_users(SilcServer server,
4219                                             SilcChannelEntry channel,
4220                                             SilcBuffer *channel_modes,
4221                                             SilcBuffer *channel_users,
4222                                             SilcBuffer *channel_users_modes)
4223 {
4224   SilcChannelClientEntry chl;
4225   SilcHashTableList htl;
4226   SilcBuffer chidp, clidp, csidp;
4227   SilcBuffer tmp, fkey = NULL, chpklist;
4228   int len;
4229   unsigned char mode[4], ulimit[4];
4230   char *hmac;
4231
4232   SILC_LOG_DEBUG(("Start"));
4233
4234   chidp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL);
4235   csidp = silc_id_payload_encode(server->id, SILC_ID_SERVER);
4236   chpklist = silc_server_get_channel_pk_list(server, channel, TRUE, FALSE);
4237
4238   /* CMODE notify */
4239   SILC_PUT32_MSB(channel->mode, mode);
4240   if (channel->mode & SILC_CHANNEL_MODE_ULIMIT)
4241     SILC_PUT32_MSB(channel->user_limit, ulimit);
4242   hmac = channel->hmac ? (char *)silc_hmac_get_name(channel->hmac) : NULL;
4243   if (channel->founder_key)
4244     fkey = silc_public_key_payload_encode(channel->founder_key);
4245   tmp =
4246     silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_CMODE_CHANGE,
4247                                        8, csidp->data,
4248                                        silc_buffer_len(csidp),
4249                                        mode, sizeof(mode),
4250                                        NULL, 0,
4251                                        hmac, hmac ? strlen(hmac) : 0,
4252                                        channel->passphrase,
4253                                        channel->passphrase ?
4254                                        strlen(channel->passphrase) : 0,
4255                                        fkey ? fkey->data : NULL,
4256                                        fkey ? silc_buffer_len(fkey) : 0,
4257                                        chpklist ? chpklist->data : NULL,
4258                                        chpklist ?
4259                                        silc_buffer_len(chpklist) : 0,
4260                                        (channel->mode &
4261                                         SILC_CHANNEL_MODE_ULIMIT ?
4262                                         ulimit : NULL),
4263                                        (channel->mode &
4264                                         SILC_CHANNEL_MODE_ULIMIT ?
4265                                         sizeof(ulimit) : 0));
4266   len = silc_buffer_len(tmp);
4267   *channel_modes =
4268     silc_buffer_realloc(*channel_modes,
4269                         (*channel_modes ?
4270                          silc_buffer_truelen((*channel_modes)) + len : len));
4271   silc_buffer_pull_tail(*channel_modes,
4272                         ((*channel_modes)->end -
4273                          (*channel_modes)->data));
4274   silc_buffer_put(*channel_modes, tmp->data, silc_buffer_len(tmp));
4275   silc_buffer_pull(*channel_modes, len);
4276   silc_buffer_free(tmp);
4277   silc_buffer_free(fkey);
4278   fkey = NULL;
4279
4280   /* Now find all users on the channel */
4281   silc_hash_table_list(channel->user_list, &htl);
4282   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
4283     clidp = silc_id_payload_encode(chl->client->id, SILC_ID_CLIENT);
4284
4285     SILC_LOG_DEBUG(("JOIN Client %s", silc_id_render(chl->client->id,
4286                                                      SILC_ID_CLIENT)));
4287
4288     /* JOIN Notify */
4289     tmp = silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_JOIN, 2,
4290                                              clidp->data,
4291                                              silc_buffer_len(clidp),
4292                                              chidp->data,
4293                                              silc_buffer_len(chidp));
4294     len = silc_buffer_len(tmp);
4295     *channel_users =
4296       silc_buffer_realloc(*channel_users,
4297                           (*channel_users ?
4298                            silc_buffer_truelen((*channel_users)) + len : len));
4299     silc_buffer_pull_tail(*channel_users,
4300                           ((*channel_users)->end -
4301                            (*channel_users)->data));
4302
4303     silc_buffer_put(*channel_users, tmp->data, silc_buffer_len(tmp));
4304     silc_buffer_pull(*channel_users, len);
4305     silc_buffer_free(tmp);
4306
4307     /* CUMODE notify for mode change on the channel */
4308     SILC_PUT32_MSB(chl->mode, mode);
4309     if (chl->mode & SILC_CHANNEL_UMODE_CHANFO && channel->founder_key)
4310       fkey = silc_public_key_payload_encode(channel->founder_key);
4311     tmp = silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_CUMODE_CHANGE,
4312                                              4, csidp->data,
4313                                              silc_buffer_len(csidp),
4314                                              mode, sizeof(mode),
4315                                              clidp->data,
4316                                              silc_buffer_len(clidp),
4317                                              fkey ? fkey->data : NULL,
4318                                              fkey ? silc_buffer_len(fkey) : 0);
4319     len = silc_buffer_len(tmp);
4320     *channel_users_modes =
4321       silc_buffer_realloc(*channel_users_modes,
4322                           (*channel_users_modes ?
4323                            silc_buffer_truelen((*channel_users_modes)) +
4324                            len : len));
4325     silc_buffer_pull_tail(*channel_users_modes,
4326                           ((*channel_users_modes)->end -
4327                            (*channel_users_modes)->data));
4328
4329     silc_buffer_put(*channel_users_modes, tmp->data, silc_buffer_len(tmp));
4330     silc_buffer_pull(*channel_users_modes, len);
4331     silc_buffer_free(tmp);
4332     silc_buffer_free(fkey);
4333     fkey = NULL;
4334     silc_buffer_free(clidp);
4335   }
4336   silc_hash_table_list_reset(&htl);
4337   silc_buffer_free(chidp);
4338   silc_buffer_free(csidp);
4339 }
4340
4341 /* Returns assembled packets for all channels and users on those channels
4342    from the given ID List. The packets are in the form dictated by the
4343    New Channel and New Channel User payloads. */
4344
4345 void silc_server_announce_get_channels(SilcServer server,
4346                                        SilcIDList id_list,
4347                                        SilcBuffer *channels,
4348                                        SilcBuffer **channel_modes,
4349                                        SilcBuffer *channel_users,
4350                                        SilcBuffer **channel_users_modes,
4351                                        SilcUInt32 *channel_users_modes_c,
4352                                        SilcBuffer **channel_topics,
4353                                        SilcBuffer **channel_invites,
4354                                        SilcBuffer **channel_bans,
4355                                        SilcChannelID ***channel_ids,
4356                                        unsigned long creation_time)
4357 {
4358   SilcList list;
4359   SilcIDCacheEntry id_cache;
4360   SilcChannelEntry channel;
4361   unsigned char cid[32];
4362   SilcUInt32 id_len;
4363   SilcUInt16 name_len;
4364   int len;
4365   int i = *channel_users_modes_c;
4366   SilcBool announce;
4367
4368   SILC_LOG_DEBUG(("Start"));
4369
4370   /* Go through all channels in the list */
4371   if (silc_idcache_get_all(id_list->channels, &list)) {
4372     silc_list_start(list);
4373     while ((id_cache = silc_list_get(list))) {
4374       channel = (SilcChannelEntry)id_cache->context;
4375
4376       if (creation_time && channel->created < creation_time)
4377         announce = FALSE;
4378       else
4379         announce = TRUE;
4380
4381       SILC_LOG_DEBUG(("Announce Channel ID %s",
4382                       silc_id_render(channel->id, SILC_ID_CHANNEL)));
4383
4384       silc_id_id2str(channel->id, SILC_ID_CHANNEL, cid, sizeof(cid), &id_len);
4385       name_len = strlen(channel->channel_name);
4386
4387       if (announce) {
4388         len = 4 + name_len + id_len + 4;
4389         *channels =
4390           silc_buffer_realloc(*channels,
4391                               (*channels ?
4392                                silc_buffer_truelen((*channels)) +
4393                                len : len));
4394         silc_buffer_pull_tail(*channels,
4395                               ((*channels)->end - (*channels)->data));
4396         silc_buffer_format(*channels,
4397                            SILC_STR_UI_SHORT(name_len),
4398                            SILC_STR_UI_XNSTRING(channel->channel_name,
4399                                                 name_len),
4400                            SILC_STR_UI_SHORT(id_len),
4401                              SILC_STR_UI_XNSTRING(cid, id_len),
4402                            SILC_STR_UI_INT(channel->mode),
4403                            SILC_STR_END);
4404         silc_buffer_pull(*channels, len);
4405       }
4406
4407       if (creation_time && channel->updated < creation_time)
4408         announce = FALSE;
4409       else
4410         announce = TRUE;
4411
4412       if (announce) {
4413         /* Channel user modes */
4414         *channel_users_modes = silc_realloc(*channel_users_modes,
4415                                             sizeof(**channel_users_modes) *
4416                                             (i + 1));
4417         (*channel_users_modes)[i] = NULL;
4418         *channel_modes = silc_realloc(*channel_modes,
4419                                       sizeof(**channel_modes) * (i + 1));
4420         (*channel_modes)[i] = NULL;
4421         *channel_ids = silc_realloc(*channel_ids,
4422                                       sizeof(**channel_ids) * (i + 1));
4423         (*channel_ids)[i] = NULL;
4424         silc_server_announce_get_channel_users(server, channel,
4425                                                &(*channel_modes)[i],
4426                                                channel_users,
4427                                                &(*channel_users_modes)[i]);
4428         (*channel_ids)[i] = channel->id;
4429
4430         /* Channel's topic */
4431         *channel_topics = silc_realloc(*channel_topics,
4432                                        sizeof(**channel_topics) * (i + 1));
4433         (*channel_topics)[i] = NULL;
4434         silc_server_announce_get_channel_topic(server, channel,
4435                                                &(*channel_topics)[i]);
4436
4437         /* Channel's invite and ban list */
4438         *channel_invites = silc_realloc(*channel_invites,
4439                                         sizeof(**channel_invites) * (i + 1));
4440         (*channel_invites)[i] = NULL;
4441         *channel_bans = silc_realloc(*channel_bans,
4442                                      sizeof(**channel_bans) * (i + 1));
4443         (*channel_bans)[i] = NULL;
4444         silc_server_announce_get_inviteban(server, channel,
4445                                            &(*channel_invites)[i],
4446                                            &(*channel_bans)[i]);
4447
4448         (*channel_users_modes_c)++;
4449
4450         i++;
4451       }
4452     }
4453   }
4454 }
4455
4456 /* This function is used to announce our existing channels to our router
4457    when we've connected to it. This also announces the users on the
4458    channels to the router. If the `creation_time' is non-zero only the
4459    channels that was created after the `creation_time' are announced.
4460    Note that the channel users are still announced even if the `creation_time'
4461    was provided. */
4462
4463 void silc_server_announce_channels(SilcServer server,
4464                                    unsigned long creation_time,
4465                                    SilcPacketStream remote)
4466 {
4467   SilcBuffer channels = NULL, *channel_modes = NULL, channel_users = NULL;
4468   SilcBuffer *channel_users_modes = NULL;
4469   SilcBuffer *channel_topics = NULL;
4470   SilcBuffer *channel_invites = NULL;
4471   SilcBuffer *channel_bans = NULL;
4472   SilcUInt32 channel_users_modes_c = 0;
4473   SilcChannelID **channel_ids = NULL;
4474
4475   SILC_LOG_DEBUG(("Announcing channels and channel users"));
4476
4477   /* Get channels and channel users in local list */
4478   silc_server_announce_get_channels(server, server->local_list,
4479                                     &channels, &channel_modes,
4480                                     &channel_users,
4481                                     &channel_users_modes,
4482                                     &channel_users_modes_c,
4483                                     &channel_topics,
4484                                     &channel_invites,
4485                                     &channel_bans,
4486                                     &channel_ids, creation_time);
4487
4488   /* Get channels and channel users in global list */
4489   if (server->server_type != SILC_SERVER)
4490     silc_server_announce_get_channels(server, server->global_list,
4491                                       &channels, &channel_modes,
4492                                       &channel_users,
4493                                       &channel_users_modes,
4494                                       &channel_users_modes_c,
4495                                       &channel_topics,
4496                                       &channel_invites,
4497                                       &channel_bans,
4498                                       &channel_ids, creation_time);
4499
4500   if (channels) {
4501     silc_buffer_push(channels, channels->data - channels->head);
4502     SILC_LOG_HEXDUMP(("channels"), channels->data, silc_buffer_len(channels));
4503
4504     /* Send the packet */
4505     silc_server_packet_send(server, remote,
4506                             SILC_PACKET_NEW_CHANNEL, SILC_PACKET_FLAG_LIST,
4507                             channels->data, silc_buffer_len(channels));
4508
4509     silc_buffer_free(channels);
4510   }
4511
4512   if (channel_users) {
4513     silc_buffer_push(channel_users, channel_users->data - channel_users->head);
4514     SILC_LOG_HEXDUMP(("channel users"), channel_users->data,
4515                      silc_buffer_len(channel_users));
4516
4517     /* Send the packet */
4518     silc_server_packet_send(server, remote,
4519                             SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4520                             channel_users->data, silc_buffer_len(channel_users));
4521
4522     silc_buffer_free(channel_users);
4523   }
4524
4525   if (channel_modes) {
4526     int i;
4527
4528     for (i = 0; i < channel_users_modes_c; i++) {
4529       if (!channel_modes[i])
4530         continue;
4531       silc_buffer_push(channel_modes[i],
4532                        channel_modes[i]->data -
4533                        channel_modes[i]->head);
4534       SILC_LOG_HEXDUMP(("channel modes"), channel_modes[i]->data,
4535                        silc_buffer_len(channel_modes[i]));
4536       silc_server_packet_send_dest(server, remote,
4537                                    SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4538                                    channel_ids[i], SILC_ID_CHANNEL,
4539                                    channel_modes[i]->data,
4540                                    silc_buffer_len(channel_modes[i]));
4541       silc_buffer_free(channel_modes[i]);
4542     }
4543     silc_free(channel_modes);
4544   }
4545
4546   if (channel_users_modes) {
4547     int i;
4548
4549     for (i = 0; i < channel_users_modes_c; i++) {
4550       if (!channel_users_modes[i])
4551         continue;
4552       silc_buffer_push(channel_users_modes[i],
4553                        channel_users_modes[i]->data -
4554                        channel_users_modes[i]->head);
4555       SILC_LOG_HEXDUMP(("channel users modes"), channel_users_modes[i]->data,
4556                        silc_buffer_len(channel_users_modes[i]));
4557       silc_server_packet_send_dest(server, remote,
4558                                    SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4559                                    channel_ids[i], SILC_ID_CHANNEL,
4560                                    channel_users_modes[i]->data,
4561                                    silc_buffer_len(channel_users_modes[i]));
4562       silc_buffer_free(channel_users_modes[i]);
4563     }
4564     silc_free(channel_users_modes);
4565   }
4566
4567   if (channel_topics) {
4568     int i;
4569
4570     for (i = 0; i < channel_users_modes_c; i++) {
4571       if (!channel_topics[i])
4572         continue;
4573
4574       silc_buffer_push(channel_topics[i],
4575                        channel_topics[i]->data -
4576                        channel_topics[i]->head);
4577       SILC_LOG_HEXDUMP(("channel topic"), channel_topics[i]->data,
4578                        silc_buffer_len(channel_topics[i]));
4579       silc_server_packet_send_dest(server, remote,
4580                                    SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4581                                    channel_ids[i], SILC_ID_CHANNEL,
4582                                    channel_topics[i]->data,
4583                                    silc_buffer_len(channel_topics[i]));
4584       silc_buffer_free(channel_topics[i]);
4585     }
4586     silc_free(channel_topics);
4587   }
4588
4589   if (channel_invites) {
4590     int i;
4591
4592     for (i = 0; i < channel_users_modes_c; i++) {
4593       if (!channel_invites[i])
4594         continue;
4595
4596       silc_buffer_push(channel_invites[i],
4597                        channel_invites[i]->data -
4598                        channel_invites[i]->head);
4599       SILC_LOG_HEXDUMP(("channel invite list"), channel_invites[i]->data,
4600                        silc_buffer_len(channel_invites[i]));
4601       silc_server_packet_send_dest(server, remote,
4602                                    SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4603                                    channel_ids[i], SILC_ID_CHANNEL,
4604                                    channel_invites[i]->data,
4605                                    silc_buffer_len(channel_invites[i]));
4606       silc_buffer_free(channel_invites[i]);
4607     }
4608     silc_free(channel_invites);
4609   }
4610
4611   if (channel_bans) {
4612     int i;
4613
4614     for (i = 0; i < channel_users_modes_c; i++) {
4615       if (!channel_bans[i])
4616         continue;
4617
4618       silc_buffer_push(channel_bans[i],
4619                        channel_bans[i]->data -
4620                        channel_bans[i]->head);
4621       SILC_LOG_HEXDUMP(("channel ban list"), channel_bans[i]->data,
4622                        silc_buffer_len(channel_bans[i]));
4623       silc_server_packet_send_dest(server, remote,
4624                                    SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4625                                    channel_ids[i], SILC_ID_CHANNEL,
4626                                    channel_bans[i]->data,
4627                                    silc_buffer_len(channel_bans[i]));
4628       silc_buffer_free(channel_bans[i]);
4629     }
4630     silc_free(channel_bans);
4631   }
4632
4633   silc_free(channel_ids);
4634 }
4635
4636 /* Announces WATCH list. */
4637
4638 void silc_server_announce_watches(SilcServer server,
4639                                   SilcPacketStream remote)
4640 {
4641   SilcHashTableList htl;
4642   SilcBuffer buffer, idp, args, pkp;
4643   SilcClientEntry client;
4644   void *key;
4645
4646   SILC_LOG_DEBUG(("Announcing watch list"));
4647
4648   /* XXX because way we save the nicks (hash) we cannot announce them. */
4649
4650   /* XXX we should send all public keys in one command if client is
4651      watching more than one key */
4652   silc_hash_table_list(server->watcher_list_pk, &htl);
4653   while (silc_hash_table_get(&htl, &key, (void *)&client)) {
4654     if (!client || !client->id)
4655       continue;
4656
4657     server->stat.commands_sent++;
4658
4659     idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
4660     args = silc_buffer_alloc_size(2);
4661     silc_buffer_format(args,
4662                        SILC_STR_UI_SHORT(1),
4663                        SILC_STR_END);
4664     pkp = silc_public_key_payload_encode(key);
4665     args = silc_argument_payload_encode_one(args, pkp->data,
4666                                             silc_buffer_len(pkp), 0x00);
4667     buffer = silc_command_payload_encode_va(SILC_COMMAND_WATCH,
4668                                             ++server->cmd_ident, 2,
4669                                             1, idp->data, silc_buffer_len(idp),
4670                                             4, args->data,
4671                                             silc_buffer_len(args));
4672
4673     /* Send command */
4674     silc_server_packet_send(server, remote, SILC_PACKET_COMMAND, 0,
4675                             buffer->data, silc_buffer_len(buffer));
4676
4677     silc_buffer_free(pkp);
4678     silc_buffer_free(args);
4679     silc_buffer_free(idp);
4680     silc_buffer_free(buffer);
4681   }
4682   silc_hash_table_list_reset(&htl);
4683 }
4684
4685 /* Assembles user list and users mode list from the `channel'. */
4686
4687 SilcBool silc_server_get_users_on_channel(SilcServer server,
4688                                           SilcChannelEntry channel,
4689                                           SilcBuffer *user_list,
4690                                           SilcBuffer *mode_list,
4691                                           SilcUInt32 *user_count)
4692 {
4693   SilcChannelClientEntry chl;
4694   SilcHashTableList htl;
4695   SilcBuffer client_id_list;
4696   SilcBuffer client_mode_list;
4697   SilcBuffer idp;
4698   SilcUInt32 list_count = 0, len = 0;
4699
4700   if (!silc_hash_table_count(channel->user_list))
4701     return FALSE;
4702
4703   silc_hash_table_list(channel->user_list, &htl);
4704   while (silc_hash_table_get(&htl, NULL, (void *)&chl))
4705     len += (silc_id_get_len(chl->client->id, SILC_ID_CLIENT) + 4);
4706   silc_hash_table_list_reset(&htl);
4707
4708   client_id_list = silc_buffer_alloc(len);
4709   client_mode_list =
4710     silc_buffer_alloc(4 * silc_hash_table_count(channel->user_list));
4711   silc_buffer_pull_tail(client_id_list, silc_buffer_truelen(client_id_list));
4712   silc_buffer_pull_tail(client_mode_list,
4713                         silc_buffer_truelen(client_mode_list));
4714
4715   silc_hash_table_list(channel->user_list, &htl);
4716   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
4717     /* Client ID */
4718     idp = silc_id_payload_encode(chl->client->id, SILC_ID_CLIENT);
4719     silc_buffer_put(client_id_list, idp->data, silc_buffer_len(idp));
4720     silc_buffer_pull(client_id_list, silc_buffer_len(idp));
4721     silc_buffer_free(idp);
4722
4723     /* Client's mode on channel */
4724     SILC_PUT32_MSB(chl->mode, client_mode_list->data);
4725     silc_buffer_pull(client_mode_list, 4);
4726
4727     list_count++;
4728   }
4729   silc_hash_table_list_reset(&htl);
4730   silc_buffer_push(client_id_list,
4731                    client_id_list->data - client_id_list->head);
4732   silc_buffer_push(client_mode_list,
4733                    client_mode_list->data - client_mode_list->head);
4734
4735   *user_list = client_id_list;
4736   *mode_list = client_mode_list;
4737   *user_count = list_count;
4738   return TRUE;
4739 }
4740
4741 /* Saves users and their modes to the `channel'. */
4742
4743 void silc_server_save_users_on_channel(SilcServer server,
4744                                        SilcPacketStream sock,
4745                                        SilcChannelEntry channel,
4746                                        SilcClientID *noadd,
4747                                        SilcBuffer user_list,
4748                                        SilcBuffer mode_list,
4749                                        SilcUInt32 user_count)
4750 {
4751   int i;
4752   SilcUInt16 idp_len;
4753   SilcUInt32 mode;
4754   SilcID id;
4755   SilcClientEntry client;
4756   SilcIDCacheEntry cache;
4757   SilcChannelClientEntry chl;
4758
4759   SILC_LOG_DEBUG(("Saving %d users on %s channel", user_count,
4760                   channel->channel_name));
4761
4762   for (i = 0; i < user_count; i++) {
4763     /* Client ID */
4764     SILC_GET16_MSB(idp_len, user_list->data + 2);
4765     idp_len += 4;
4766     if (!silc_id_payload_parse_id(user_list->data, idp_len, &id))
4767       continue;
4768     silc_buffer_pull(user_list, idp_len);
4769
4770     /* Mode */
4771     SILC_GET32_MSB(mode, mode_list->data);
4772     silc_buffer_pull(mode_list, 4);
4773
4774     if (noadd && SILC_ID_CLIENT_COMPARE(&id.u.client_id, noadd))
4775       continue;
4776
4777     cache = NULL;
4778
4779     /* Check if we have this client cached already. */
4780     client = silc_idlist_find_client_by_id(server->local_list,
4781                                            &id.u.client_id,
4782                                            server->server_type, &cache);
4783     if (!client)
4784       client = silc_idlist_find_client_by_id(server->global_list,
4785                                              &id.u.client_id,
4786                                              server->server_type, &cache);
4787     if (!client) {
4788       /* If router did not find such Client ID in its lists then this must
4789          be bogus client or some router in the net is buggy. */
4790       if (server->server_type != SILC_SERVER)
4791         continue;
4792
4793       /* We don't have that client anywhere, add it. The client is added
4794          to global list since server didn't have it in the lists so it must be
4795          global. */
4796       client = silc_idlist_add_client(server->global_list, NULL, NULL, NULL,
4797                                       silc_id_dup(&id.u.client_id,
4798                                                   SILC_ID_CLIENT),
4799                                       silc_packet_get_context(sock),
4800                                       NULL);
4801       if (!client) {
4802         SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
4803         continue;
4804       }
4805
4806       client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
4807     }
4808
4809     if (!(client->data.status & SILC_IDLIST_STATUS_REGISTERED)) {
4810       SILC_LOG_ERROR(("Attempting to add unregistered client to channel ",
4811                       "%s", channel->channel_name));
4812       continue;
4813     }
4814
4815     if (!silc_server_client_on_channel(client, channel, &chl)) {
4816       /* Client was not on the channel, add it. */
4817       chl = silc_calloc(1, sizeof(*chl));
4818       chl->client = client;
4819       chl->mode = mode;
4820       chl->channel = channel;
4821       silc_hash_table_add(channel->user_list, chl->client, chl);
4822       silc_hash_table_add(client->channels, chl->channel, chl);
4823       channel->user_count++;
4824     } else {
4825       /* Update mode */
4826       chl->mode = mode;
4827     }
4828   }
4829 }
4830
4831 /* Saves channels and channels user modes to the `client'.  Removes
4832    the client from those channels that are not sent in the list but
4833    it has joined. */
4834
4835 void silc_server_save_user_channels(SilcServer server,
4836                                     SilcPacketStream sock,
4837                                     SilcClientEntry client,
4838                                     SilcBuffer channels,
4839                                     SilcBuffer channels_user_modes)
4840 {
4841   SilcDList ch;
4842   SilcUInt32 *chumodes;
4843   SilcChannelPayload entry;
4844   SilcChannelEntry channel;
4845   SilcChannelID channel_id;
4846   SilcChannelClientEntry chl;
4847   SilcHashTable ht = NULL;
4848   SilcHashTableList htl;
4849   char *name;
4850   int i = 0;
4851
4852   if (!channels || !channels_user_modes ||
4853       !(client->data.status & SILC_IDLIST_STATUS_REGISTERED))
4854     goto out;
4855
4856   ch = silc_channel_payload_parse_list(channels->data,
4857                                        silc_buffer_len(channels));
4858   if (ch && silc_get_mode_list(channels_user_modes, silc_dlist_count(ch),
4859                                &chumodes)) {
4860     ht = silc_hash_table_alloc(0, silc_hash_ptr, NULL, NULL,
4861                                NULL, NULL, NULL, TRUE);
4862     silc_dlist_start(ch);
4863     while ((entry = silc_dlist_get(ch)) != SILC_LIST_END) {
4864       /* Check if we have this channel, and add it if we don't have it.
4865          Also add the client on the channel unless it is there already. */
4866       if (!silc_channel_get_id_parse(entry, &channel_id))
4867         continue;
4868       channel = silc_idlist_find_channel_by_id(server->local_list,
4869                                                &channel_id, NULL);
4870       if (!channel)
4871         channel = silc_idlist_find_channel_by_id(server->global_list,
4872                                                  &channel_id, NULL);
4873       if (!channel) {
4874         if (server->server_type != SILC_SERVER) {
4875           i++;
4876           continue;
4877         }
4878
4879         /* We don't have that channel anywhere, add it. */
4880         name = silc_channel_get_name(entry, NULL);
4881         channel = silc_idlist_add_channel(server->global_list, strdup(name), 0,
4882                                           silc_id_dup(&channel_id,
4883                                                       SILC_ID_CHANNEL),
4884                                           server->router, NULL, NULL, 0);
4885         if (!channel) {
4886           i++;
4887           continue;
4888         }
4889       }
4890
4891       channel->mode = silc_channel_get_mode(entry);
4892
4893       /* Add the client on the channel */
4894       if (!silc_server_client_on_channel(client, channel, &chl)) {
4895         chl = silc_calloc(1, sizeof(*chl));
4896         chl->client = client;
4897         chl->mode = chumodes[i++];
4898         chl->channel = channel;
4899         silc_hash_table_add(channel->user_list, chl->client, chl);
4900         silc_hash_table_add(client->channels, chl->channel, chl);
4901         channel->user_count++;
4902       } else {
4903         /* Update mode */
4904         chl->mode = chumodes[i++];
4905       }
4906
4907       silc_hash_table_add(ht, channel, channel);
4908     }
4909     silc_channel_payload_list_free(ch);
4910     silc_free(chumodes);
4911   }
4912
4913  out:
4914   /* Go through the list again and remove client from channels that
4915      are no part of the list. */
4916   if (ht) {
4917     silc_hash_table_list(client->channels, &htl);
4918     while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
4919       if (!silc_hash_table_find(ht, chl->channel, NULL, NULL)) {
4920         silc_hash_table_del(chl->channel->user_list, chl->client);
4921         silc_hash_table_del(chl->client->channels, chl->channel);
4922         silc_free(chl);
4923       }
4924     }
4925     silc_hash_table_list_reset(&htl);
4926     silc_hash_table_free(ht);
4927   } else {
4928     silc_hash_table_list(client->channels, &htl);
4929     while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
4930       silc_hash_table_del(chl->channel->user_list, chl->client);
4931       silc_hash_table_del(chl->client->channels, chl->channel);
4932       silc_free(chl);
4933     }
4934     silc_hash_table_list_reset(&htl);
4935   }
4936 }
4937
4938 /* Lookups route to the client indicated by the `id_data'. The connection
4939    object and internal data object is returned. Returns NULL if route
4940    could not be found to the client. If the `client_id' is specified then
4941    it is used and the `id_data' is ignored. */
4942
4943 SilcPacketStream
4944 silc_server_get_client_route(SilcServer server,
4945                              unsigned char *id_data,
4946                              SilcUInt32 id_len,
4947                              SilcClientID *client_id,
4948                              SilcIDListData *idata,
4949                              SilcClientEntry *client_entry)
4950 {
4951   SilcClientID *id, clid;
4952   SilcClientEntry client;
4953
4954   SILC_LOG_DEBUG(("Start"));
4955
4956   if (client_entry)
4957     *client_entry = NULL;
4958
4959   /* Decode destination Client ID */
4960   if (!client_id) {
4961     if (!silc_id_str2id(id_data, id_len, SILC_ID_CLIENT, &clid, sizeof(clid)))
4962       return NULL;
4963     id = silc_id_dup(&clid, SILC_ID_CLIENT);
4964   } else {
4965     id = silc_id_dup(client_id, SILC_ID_CLIENT);
4966   }
4967
4968   /* If the destination belongs to our server we don't have to route
4969      the packet anywhere but to send it to the local destination. */
4970   client = silc_idlist_find_client_by_id(server->local_list, id, TRUE, NULL);
4971   if (client) {
4972     silc_free(id);
4973
4974     /* If we are router and the client has router then the client is in
4975        our cell but not directly connected to us. */
4976     if (server->server_type == SILC_ROUTER && client->router) {
4977       /* We are of course in this case the client's router thus the route
4978          to the client is the server who owns the client. So, we will send
4979          the packet to that server. */
4980       if (idata)
4981         *idata = (SilcIDListData)client->router;
4982       return client->router->connection;
4983     }
4984
4985     /* Seems that client really is directly connected to us */
4986     if (idata)
4987       *idata = (SilcIDListData)client;
4988     if (client_entry)
4989       *client_entry = client;
4990     return client->connection;
4991   }
4992
4993   /* Destination belongs to someone not in this server. If we are normal
4994      server our action is to send the packet to our router. */
4995   if (server->server_type != SILC_ROUTER && !server->standalone) {
4996     silc_free(id);
4997     if (idata)
4998       *idata = (SilcIDListData)server->router;
4999     return SILC_PRIMARY_ROUTE(server);
5000   }
5001
5002   /* We are router and we will perform route lookup for the destination
5003      and send the packet to fastest route. */
5004   if (server->server_type == SILC_ROUTER && !server->standalone) {
5005     /* Check first that the ID is valid */
5006     client = silc_idlist_find_client_by_id(server->global_list, id,
5007                                            TRUE, NULL);
5008     if (client) {
5009       SilcPacketStream dst_sock;
5010
5011       dst_sock = silc_server_route_get(server, id, SILC_ID_CLIENT);
5012
5013       silc_free(id);
5014       if (idata && dst_sock)
5015         *idata = silc_packet_get_context(dst_sock);
5016       return dst_sock;
5017     }
5018   }
5019
5020   silc_free(id);
5021   return NULL;
5022 }
5023
5024 /* Encodes and returns channel list of channels the `client' has joined.
5025    Secret channels are not put to the list. */
5026
5027 SilcBuffer silc_server_get_client_channel_list(SilcServer server,
5028                                                SilcClientEntry client,
5029                                                SilcBool get_private,
5030                                                SilcBool get_secret,
5031                                                SilcBuffer *user_mode_list)
5032 {
5033   SilcBuffer buffer = NULL;
5034   SilcChannelEntry channel;
5035   SilcChannelClientEntry chl;
5036   SilcHashTableList htl;
5037   unsigned char cid[32];
5038   SilcUInt32 id_len;
5039   SilcUInt16 name_len;
5040   int len;
5041
5042   if (user_mode_list)
5043     *user_mode_list = NULL;
5044
5045   silc_hash_table_list(client->channels, &htl);
5046   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
5047     channel = chl->channel;
5048
5049     if (channel->mode & SILC_CHANNEL_MODE_SECRET && !get_secret)
5050       continue;
5051     if (channel->mode & SILC_CHANNEL_MODE_PRIVATE && !get_private)
5052       continue;
5053
5054     silc_id_id2str(channel->id, SILC_ID_CHANNEL, cid, sizeof(cid), &id_len);
5055     name_len = strlen(channel->channel_name);
5056
5057     len = 4 + name_len + id_len + 4;
5058     buffer = silc_buffer_realloc(buffer,
5059                                  (buffer ?
5060                                   silc_buffer_truelen(buffer) + len : len));
5061     silc_buffer_pull_tail(buffer, (buffer->end - buffer->data));
5062     silc_buffer_format(buffer,
5063                        SILC_STR_UI_SHORT(name_len),
5064                        SILC_STR_DATA(channel->channel_name, name_len),
5065                        SILC_STR_UI_SHORT(id_len),
5066                        SILC_STR_DATA(cid, id_len),
5067                        SILC_STR_UI_INT(chl->channel->mode),
5068                        SILC_STR_END);
5069     silc_buffer_pull(buffer, len);
5070
5071     if (user_mode_list) {
5072       *user_mode_list =
5073         silc_buffer_realloc(*user_mode_list,
5074                             (*user_mode_list ?
5075                              silc_buffer_truelen((*user_mode_list)) + 4 : 4));
5076       silc_buffer_pull_tail(*user_mode_list, ((*user_mode_list)->end -
5077                                               (*user_mode_list)->data));
5078       SILC_PUT32_MSB(chl->mode, (*user_mode_list)->data);
5079       silc_buffer_pull(*user_mode_list, 4);
5080     }
5081   }
5082   silc_hash_table_list_reset(&htl);
5083
5084   if (buffer)
5085     silc_buffer_push(buffer, buffer->data - buffer->head);
5086   if (user_mode_list && *user_mode_list)
5087     silc_buffer_push(*user_mode_list, ((*user_mode_list)->data -
5088                                        (*user_mode_list)->head));
5089
5090   return buffer;
5091 }
5092
5093 /* Task callback used to retrieve network statistical information from
5094    router server once in a while. */
5095
5096 SILC_TASK_CALLBACK(silc_server_get_stats)
5097 {
5098   SilcServer server = (SilcServer)context;
5099   SilcBuffer idp, packet;
5100
5101   if (!server->standalone) {
5102     SILC_LOG_DEBUG(("Retrieving stats from router"));
5103     server->stat.commands_sent++;
5104     idp = silc_id_payload_encode(server->router->id, SILC_ID_SERVER);
5105     if (idp) {
5106       packet = silc_command_payload_encode_va(SILC_COMMAND_STATS,
5107                                               ++server->cmd_ident, 1,
5108                                               1, idp->data,
5109                                               silc_buffer_len(idp));
5110       silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
5111                               SILC_PACKET_COMMAND, 0, packet->data,
5112                               silc_buffer_len(packet));
5113       silc_buffer_free(packet);
5114       silc_buffer_free(idp);
5115     }
5116   }
5117
5118   silc_schedule_task_add_timeout(server->schedule, silc_server_get_stats,
5119                                  server, 120, 0);
5120 }