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_context(server->schedule, sock);
3040
3041   /* Cancel active protocols */
3042   if (idata) {
3043     if (idata->sconn && idata->sconn->op) {
3044       SILC_LOG_DEBUG(("Abort active protocol"));
3045       silc_async_abort(idata->sconn->op, NULL, NULL);
3046     }
3047     if (idata->conn_type == SILC_CONN_UNKNOWN &&
3048         ((SilcUnknownEntry)idata)->op) {
3049       SILC_LOG_DEBUG(("Abort active protocol"));
3050       silc_async_abort(((SilcUnknownEntry)idata)->op, NULL, NULL);
3051     }
3052   }
3053
3054   switch (idata->conn_type) {
3055   case SILC_CONN_CLIENT:
3056     {
3057       SilcClientEntry client_entry = (SilcClientEntry)idata;
3058       silc_server_free_client_data(server, sock, client_entry, TRUE,
3059                                    signoff_message);
3060       silc_packet_set_context(sock, NULL);
3061       break;
3062     }
3063
3064   case SILC_CONN_SERVER:
3065   case SILC_CONN_ROUTER:
3066     {
3067       SilcServerEntry user_data = (SilcServerEntry)idata;
3068       SilcServerEntry backup_router = NULL;
3069
3070       SILC_LOG_DEBUG(("Freeing server %p data", user_data));
3071
3072       if (user_data->id)
3073         backup_router = silc_server_backup_get(server, user_data->id);
3074
3075       if (!server->backup_router && server->server_type == SILC_ROUTER &&
3076           backup_router == server->id_entry &&
3077           idata->conn_type != SILC_CONN_ROUTER)
3078         backup_router = NULL;
3079
3080       if (server->server_shutdown || server->backup_noswitch)
3081         backup_router = NULL;
3082
3083       silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
3084                                   NULL, NULL, &ip, &port);
3085
3086       /* If this was our primary router connection then we're lost to
3087          the outside world. */
3088       if (server->router == user_data) {
3089         /* Check whether we have a backup router connection */
3090         if (!backup_router || backup_router == user_data) {
3091           if (!server->no_reconnect)
3092             silc_server_create_connections(server);
3093           server->id_entry->router = NULL;
3094           server->router = NULL;
3095           server->standalone = TRUE;
3096           server->backup_primary = FALSE;
3097           backup_router = NULL;
3098         } else {
3099           if (server->id_entry != backup_router) {
3100             SILC_LOG_INFO(("New primary router is backup router %s",
3101                            backup_router->server_name));
3102             server->id_entry->router = backup_router;
3103             server->router = backup_router;
3104             server->router_connect = time(0);
3105             server->backup_primary = TRUE;
3106             backup_router->data.status &= ~SILC_IDLIST_STATUS_DISABLED;
3107
3108             /* Send START_USE to backup router to indicate we have switched */
3109             silc_server_backup_send_start_use(server,
3110                                               backup_router->connection,
3111                                               FALSE);
3112           } else {
3113             SILC_LOG_INFO(("We are now new primary router in this cell"));
3114             server->id_entry->router = NULL;
3115             server->router = NULL;
3116             server->standalone = TRUE;
3117           }
3118
3119           /* We stop here to take a breath */
3120           sleep(2);
3121
3122           if (server->backup_router) {
3123             server->server_type = SILC_ROUTER;
3124
3125             /* We'll need to constantly try to reconnect to the primary
3126                router so that we'll see when it comes back online. */
3127             silc_server_create_connection(server, FALSE, FALSE, ip, port,
3128                                          silc_server_backup_connected,
3129                                          NULL);
3130           }
3131
3132           /* Mark this connection as replaced */
3133           silc_server_backup_replaced_add(server, user_data->id,
3134                                           backup_router);
3135         }
3136       } else if (backup_router) {
3137         SILC_LOG_INFO(("Enabling the use of backup router %s",
3138                        backup_router->server_name));
3139
3140         /* Mark this connection as replaced */
3141         silc_server_backup_replaced_add(server, user_data->id,
3142                                         backup_router);
3143       } else if (server->server_type == SILC_SERVER &&
3144                  idata->conn_type == SILC_CONN_ROUTER) {
3145         /* Reconnect to the router (backup) */
3146         if (!server->no_reconnect)
3147           silc_server_create_connections(server);
3148       }
3149
3150       if (user_data->server_name)
3151         SILC_SERVER_SEND_OPERS(server, FALSE, TRUE, SILC_NOTIFY_TYPE_NONE,
3152                                ("Server %s signoff", user_data->server_name));
3153
3154       if (!backup_router) {
3155         /* Remove all servers that are originated from this server, and
3156            remove the clients of those servers too. */
3157         silc_server_remove_servers_by_server(server, user_data, TRUE);
3158
3159 #if 0
3160         /* Remove the clients that this server owns as they will become
3161            invalid now too.  For backup router the server is actually
3162            coming from the primary router, so mark that as the owner
3163            of this entry. */
3164         if (server->server_type == SILC_BACKUP_ROUTER &&
3165             sock->type == SILC_CONN_SERVER)
3166           silc_server_remove_clients_by_server(server, server->router,
3167                                                user_data, TRUE);
3168         else
3169 #endif
3170           silc_server_remove_clients_by_server(server, user_data,
3171                                                user_data, TRUE);
3172
3173         /* Remove channels owned by this server */
3174         if (server->server_type == SILC_SERVER)
3175           silc_server_remove_channels_by_server(server, user_data);
3176       } else {
3177         /* Enable local server connections that may be disabled */
3178         silc_server_local_servers_toggle_enabled(server, TRUE);
3179
3180         /* Update the client entries of this server to the new backup
3181            router.  If we are the backup router we also resolve the real
3182            servers for the clients.  After updating is over this also
3183            removes the clients that this server explicitly owns. */
3184         silc_server_update_clients_by_server(server, user_data,
3185                                              backup_router, TRUE);
3186
3187         /* If we are router and just lost our primary router (now standlaone)
3188            we remove everything that was behind it, since we don't know
3189            any better. */
3190         if (server->server_type == SILC_ROUTER && server->standalone)
3191           /* Remove all servers that are originated from this server, and
3192              remove the clients of those servers too. */
3193           silc_server_remove_servers_by_server(server, user_data, TRUE);
3194
3195         /* Finally remove the clients that are explicitly owned by this
3196            server.  They go down with the server. */
3197         silc_server_remove_clients_by_server(server, user_data,
3198                                              user_data, TRUE);
3199
3200         /* Update our server cache to use the new backup router too. */
3201         silc_server_update_servers_by_server(server, user_data, backup_router);
3202         if (server->server_type == SILC_SERVER)
3203           silc_server_update_channels_by_server(server, user_data,
3204                                                 backup_router);
3205
3206         /* Send notify about primary router going down to local operators */
3207         if (server->backup_router)
3208           SILC_SERVER_SEND_OPERS(server, FALSE, TRUE,
3209                                  SILC_NOTIFY_TYPE_NONE,
3210                                  ("%s switched to backup router %s "
3211                                   "(we are primary router now)",
3212                                   server->server_name, server->server_name));
3213         else if (server->router)
3214           SILC_SERVER_SEND_OPERS(server, FALSE, TRUE,
3215                                  SILC_NOTIFY_TYPE_NONE,
3216                                  ("%s switched to backup router %s",
3217                                   server->server_name,
3218                                   server->router->server_name));
3219       }
3220       server->backup_noswitch = FALSE;
3221
3222       if (idata->sconn)
3223         silc_server_connection_free(idata->sconn);
3224
3225       /* Statistics */
3226       if (idata->conn_type == SILC_CONN_SERVER) {
3227         server->stat.my_servers--;
3228         server->stat.servers--;
3229         SILC_LOG_DEBUG(("my_servers %d", server->stat.my_servers));
3230       } else if (idata->conn_type == SILC_CONN_ROUTER) {
3231         server->stat.my_routers--;
3232         server->stat.routers--;
3233         SILC_LOG_DEBUG(("my_routers %d", server->stat.my_routers));
3234       }
3235       if (server->server_type == SILC_ROUTER)
3236         server->stat.cell_servers--;
3237
3238       /* Free the server entry */
3239       silc_server_backup_del(server, user_data);
3240       silc_server_backup_replaced_del(server, user_data);
3241       silc_idlist_del_data(user_data);
3242       if (!silc_idlist_del_server(server->local_list, user_data))
3243         silc_idlist_del_server(server->global_list, user_data);
3244
3245       if (backup_router && backup_router != server->id_entry) {
3246         /* Announce all of our stuff that was created about 5 minutes ago.
3247            The backup router knows all the other stuff already. */
3248         if (server->server_type == SILC_ROUTER)
3249           silc_server_announce_servers(server, FALSE, time(0) - 300,
3250                                        backup_router->connection);
3251
3252         /* Announce our clients and channels to the router */
3253         silc_server_announce_clients(server, time(0) - 300,
3254                                      backup_router->connection);
3255         silc_server_announce_channels(server, time(0) - 300,
3256                                       backup_router->connection);
3257       }
3258
3259       silc_packet_set_context(sock, NULL);
3260       break;
3261     }
3262
3263   default:
3264     {
3265       SilcUnknownEntry entry = (SilcUnknownEntry)idata;
3266
3267       SILC_LOG_DEBUG(("Freeing unknown connection data"));
3268
3269       if (idata->sconn)
3270         silc_server_connection_free(idata->sconn);
3271       silc_idlist_del_data(idata);
3272       silc_free(entry);
3273       silc_packet_set_context(sock, NULL);
3274       break;
3275     }
3276   }
3277 }
3278
3279 /* Removes client from all channels it has joined. This is used when client
3280    connection is disconnected. If the client on a channel is last, the
3281    channel is removed as well. This sends the SIGNOFF notify types. */
3282
3283 void silc_server_remove_from_channels(SilcServer server,
3284                                       SilcPacketStream sock,
3285                                       SilcClientEntry client,
3286                                       SilcBool notify,
3287                                       const char *signoff_message,
3288                                       SilcBool keygen,
3289                                       SilcBool killed)
3290 {
3291   SilcChannelEntry channel;
3292   SilcChannelClientEntry chl;
3293   SilcHashTableList htl;
3294   SilcBuffer clidp = NULL;
3295
3296   if (!client)
3297     return;
3298
3299   if (notify && !client->id)
3300     notify = FALSE;
3301
3302   SILC_LOG_DEBUG(("Removing client %s from joined channels",
3303                   notify ? silc_id_render(client->id, SILC_ID_CLIENT) : ""));
3304
3305   if (notify) {
3306     clidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
3307     if (!clidp)
3308       notify = FALSE;
3309   }
3310
3311   /* Remove the client from all channels. The client is removed from
3312      the channels' user list. */
3313   silc_hash_table_list(client->channels, &htl);
3314   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
3315     channel = chl->channel;
3316
3317     /* Remove channel if this is last client leaving the channel, unless
3318        the channel is permanent. */
3319     if (server->server_type != SILC_SERVER &&
3320         silc_hash_table_count(channel->user_list) < 2) {
3321       silc_server_channel_delete(server, channel);
3322       continue;
3323     }
3324
3325     silc_hash_table_del(client->channels, channel);
3326     silc_hash_table_del(channel->user_list, client);
3327     channel->user_count--;
3328
3329     /* If there is no global users on the channel anymore mark the channel
3330        as local channel. Do not check if the removed client is local client. */
3331     if (server->server_type == SILC_SERVER && channel->global_users &&
3332         chl->client->router && !silc_server_channel_has_global(channel))
3333       channel->global_users = FALSE;
3334
3335     memset(chl, 'A', sizeof(*chl));
3336     silc_free(chl);
3337
3338     /* Update statistics */
3339     if (SILC_IS_LOCAL(client))
3340       server->stat.my_chanclients--;
3341     if (server->server_type == SILC_ROUTER) {
3342       server->stat.cell_chanclients--;
3343       server->stat.chanclients--;
3344     }
3345
3346     /* If there is not at least one local user on the channel then we don't
3347        need the channel entry anymore, we can remove it safely, unless the
3348        channel is permanent channel */
3349     if (server->server_type == SILC_SERVER &&
3350         !silc_server_channel_has_local(channel)) {
3351       /* Notify about leaving client if this channel has global users. */
3352       if (notify && channel->global_users)
3353         silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
3354                                            SILC_NOTIFY_TYPE_SIGNOFF,
3355                                            signoff_message ? 2 : 1,
3356                                            clidp->data, silc_buffer_len(clidp),
3357                                            signoff_message, signoff_message ?
3358                                            strlen(signoff_message) : 0);
3359
3360       silc_schedule_task_del_by_context(server->schedule, channel->rekey);
3361       silc_server_channel_delete(server, channel);
3362       continue;
3363     }
3364
3365     /* Send notify to channel about client leaving SILC and channel too */
3366     if (notify)
3367       silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
3368                                          SILC_NOTIFY_TYPE_SIGNOFF,
3369                                          signoff_message ? 2 : 1,
3370                                          clidp->data, silc_buffer_len(clidp),
3371                                          signoff_message, signoff_message ?
3372                                          strlen(signoff_message) : 0);
3373
3374     if (killed && clidp) {
3375       /* Remove the client from channel's invite list */
3376       if (channel->invite_list &&
3377           silc_hash_table_count(channel->invite_list)) {
3378         SilcBuffer ab;
3379         SilcArgumentPayload iargs;
3380         ab = silc_argument_payload_encode_one(NULL, clidp->data,
3381                                               silc_buffer_len(clidp), 3);
3382         iargs = silc_argument_payload_parse(ab->data, silc_buffer_len(ab), 1);
3383         silc_server_inviteban_process(server, channel->invite_list, 1, iargs);
3384         silc_buffer_free(ab);
3385         silc_argument_payload_free(iargs);
3386       }
3387     }
3388
3389     /* Don't create keys if we are shutting down */
3390     if (server->server_shutdown)
3391       continue;
3392
3393     /* Re-generate channel key if needed */
3394     if (keygen && !(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
3395       if (!silc_server_create_channel_key(server, channel, 0))
3396         continue;
3397
3398       /* Send the channel key to the channel. The key of course is not sent
3399          to the client who was removed from the channel. */
3400       silc_server_send_channel_key(server, client->connection, channel,
3401                                    server->server_type == SILC_ROUTER ?
3402                                    FALSE : !server->standalone);
3403     }
3404   }
3405
3406   silc_hash_table_list_reset(&htl);
3407   if (clidp)
3408     silc_buffer_free(clidp);
3409 }
3410
3411 /* Removes client from one channel. This is used for example when client
3412    calls LEAVE command to remove itself from the channel. Returns TRUE
3413    if channel still exists and FALSE if the channel is removed when
3414    last client leaves the channel. If `notify' is FALSE notify messages
3415    are not sent. */
3416
3417 SilcBool silc_server_remove_from_one_channel(SilcServer server,
3418                                          SilcPacketStream sock,
3419                                          SilcChannelEntry channel,
3420                                          SilcClientEntry client,
3421                                          SilcBool notify)
3422 {
3423   SilcChannelClientEntry chl;
3424   SilcBuffer clidp;
3425
3426   SILC_LOG_DEBUG(("Removing %s from channel %s",
3427                   silc_id_render(client->id, SILC_ID_CLIENT),
3428                   channel->channel_name));
3429
3430   /* Get the entry to the channel, if this client is not on the channel
3431      then return Ok. */
3432   if (!silc_hash_table_find(client->channels, channel, NULL, (void *)&chl))
3433     return TRUE;
3434
3435   /* Remove channel if this is last client leaving the channel, unless
3436      the channel is permanent. */
3437   if (server->server_type != SILC_SERVER &&
3438       silc_hash_table_count(channel->user_list) < 2) {
3439     silc_server_channel_delete(server, channel);
3440     return FALSE;
3441   }
3442
3443   silc_hash_table_del(client->channels, channel);
3444   silc_hash_table_del(channel->user_list, client);
3445   channel->user_count--;
3446
3447   /* If there is no global users on the channel anymore mark the channel
3448      as local channel. Do not check if the client is local client. */
3449   if (server->server_type == SILC_SERVER && channel->global_users &&
3450       chl->client->router && !silc_server_channel_has_global(channel))
3451     channel->global_users = FALSE;
3452
3453   memset(chl, 'O', sizeof(*chl));
3454   silc_free(chl);
3455
3456   /* Update statistics */
3457   if (SILC_IS_LOCAL(client))
3458     server->stat.my_chanclients--;
3459   if (server->server_type == SILC_ROUTER) {
3460     server->stat.cell_chanclients--;
3461     server->stat.chanclients--;
3462   }
3463
3464   clidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
3465   if (!clidp)
3466     notify = FALSE;
3467
3468   /* If there is not at least one local user on the channel then we don't
3469      need the channel entry anymore, we can remove it safely, unless the
3470      channel is permanent channel */
3471   if (server->server_type == SILC_SERVER &&
3472       !silc_server_channel_has_local(channel)) {
3473     /* Notify about leaving client if this channel has global users. */
3474     if (notify && channel->global_users)
3475       silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
3476                                          SILC_NOTIFY_TYPE_LEAVE, 1,
3477                                          clidp->data, silc_buffer_len(clidp));
3478
3479     silc_schedule_task_del_by_context(server->schedule, channel->rekey);
3480     silc_server_channel_delete(server, channel);
3481     silc_buffer_free(clidp);
3482     return FALSE;
3483   }
3484
3485   /* Send notify to channel about client leaving the channel */
3486   if (notify)
3487     silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
3488                                        SILC_NOTIFY_TYPE_LEAVE, 1,
3489                                        clidp->data, silc_buffer_len(clidp));
3490
3491   silc_buffer_free(clidp);
3492   return TRUE;
3493 }
3494
3495 /* Creates new channel. Sends NEW_CHANNEL packet to primary route. This
3496    function may be used only by router. In real SILC network all channels
3497    are created by routers thus this function is never used by normal
3498    server. */
3499
3500 SilcChannelEntry silc_server_create_new_channel(SilcServer server,
3501                                                 SilcServerID *router_id,
3502                                                 char *cipher,
3503                                                 char *hmac,
3504                                                 char *channel_name,
3505                                                 int broadcast)
3506 {
3507   SilcChannelID *channel_id;
3508   SilcChannelEntry entry;
3509   SilcCipher send_key, receive_key;
3510   SilcHmac newhmac;
3511
3512   SILC_LOG_DEBUG(("Creating new channel %s", channel_name));
3513
3514   if (!cipher)
3515     cipher = SILC_DEFAULT_CIPHER;
3516   if (!hmac)
3517     hmac = SILC_DEFAULT_HMAC;
3518
3519   /* Allocate cipher */
3520   if (!silc_cipher_alloc(cipher, &send_key))
3521     return NULL;
3522   if (!silc_cipher_alloc(cipher, &receive_key)) {
3523     silc_cipher_free(send_key);
3524     return NULL;
3525   }
3526
3527   /* Allocate hmac */
3528   if (!silc_hmac_alloc(hmac, NULL, &newhmac)) {
3529     silc_cipher_free(send_key);
3530     silc_cipher_free(receive_key);
3531     return NULL;
3532   }
3533
3534   channel_name = strdup(channel_name);
3535
3536   /* Create the channel ID */
3537   if (!silc_id_create_channel_id(server, router_id, server->rng,
3538                                  &channel_id)) {
3539     silc_free(channel_name);
3540     silc_cipher_free(send_key);
3541     silc_cipher_free(receive_key);
3542     silc_hmac_free(newhmac);
3543     return NULL;
3544   }
3545
3546   /* Create the channel */
3547   entry = silc_idlist_add_channel(server->local_list, channel_name,
3548                                   SILC_CHANNEL_MODE_NONE, channel_id,
3549                                   NULL, send_key, receive_key, newhmac);
3550   if (!entry) {
3551     silc_free(channel_name);
3552     silc_cipher_free(send_key);
3553     silc_cipher_free(receive_key);
3554     silc_hmac_free(newhmac);
3555     silc_free(channel_id);
3556     return NULL;
3557   }
3558
3559   entry->cipher = strdup(cipher);
3560   entry->hmac_name = strdup(hmac);
3561
3562   /* Now create the actual key material */
3563   if (!silc_server_create_channel_key(server, entry,
3564                                       silc_cipher_get_key_len(send_key) / 8)) {
3565     silc_idlist_del_channel(server->local_list, entry);
3566     return NULL;
3567   }
3568
3569   /* Notify other routers about the new channel. We send the packet
3570      to our primary route. */
3571   if (broadcast)
3572     silc_server_send_new_channel(server, SILC_PRIMARY_ROUTE(server), TRUE,
3573                                  channel_name, entry->id,
3574                                  silc_id_get_len(entry->id, SILC_ID_CHANNEL),
3575                                  entry->mode);
3576
3577   /* Distribute to backup routers */
3578   if (broadcast && server->server_type == SILC_ROUTER) {
3579     SilcBuffer packet;
3580     unsigned char cid[32];
3581     SilcUInt32 name_len = strlen(channel_name);
3582     SilcUInt32 id_len;
3583
3584     silc_id_id2str(entry->id, SILC_ID_CHANNEL, cid, sizeof(cid), &id_len);
3585     packet = silc_channel_payload_encode(channel_name, name_len,
3586                                          cid, id_len, entry->mode);
3587     silc_server_backup_send(server, NULL, SILC_PACKET_NEW_CHANNEL, 0,
3588                             packet->data, silc_buffer_len(packet), FALSE,
3589                             TRUE);
3590     silc_buffer_free(packet);
3591   }
3592
3593   server->stat.my_channels++;
3594   if (server->server_type == SILC_ROUTER) {
3595     server->stat.channels++;
3596     server->stat.cell_channels++;
3597     entry->users_resolved = TRUE;
3598   }
3599
3600   return entry;
3601 }
3602
3603 /* Same as above but creates the channel with Channel ID `channel_id. */
3604
3605 SilcChannelEntry
3606 silc_server_create_new_channel_with_id(SilcServer server,
3607                                        char *cipher,
3608                                        char *hmac,
3609                                        char *channel_name,
3610                                        SilcChannelID *channel_id,
3611                                        int broadcast)
3612 {
3613   SilcChannelEntry entry;
3614   SilcCipher send_key, receive_key;
3615   SilcHmac newhmac;
3616
3617   SILC_LOG_DEBUG(("Creating new channel %s", channel_name));
3618
3619   if (!cipher)
3620     cipher = SILC_DEFAULT_CIPHER;
3621   if (!hmac)
3622     hmac = SILC_DEFAULT_HMAC;
3623
3624   /* Allocate cipher */
3625   if (!silc_cipher_alloc(cipher, &send_key))
3626     return NULL;
3627   if (!silc_cipher_alloc(cipher, &receive_key)) {
3628     silc_cipher_free(send_key);
3629     return NULL;
3630   }
3631
3632   /* Allocate hmac */
3633   if (!silc_hmac_alloc(hmac, NULL, &newhmac)) {
3634     silc_cipher_free(send_key);
3635     silc_cipher_free(receive_key);
3636     return NULL;
3637   }
3638
3639   channel_name = strdup(channel_name);
3640
3641   /* Create the channel */
3642   entry = silc_idlist_add_channel(server->local_list, channel_name,
3643                                   SILC_CHANNEL_MODE_NONE, channel_id,
3644                                   NULL, send_key, receive_key, newhmac);
3645   if (!entry) {
3646     silc_cipher_free(send_key);
3647     silc_cipher_free(receive_key);
3648     silc_hmac_free(newhmac);
3649     silc_free(channel_name);
3650     return NULL;
3651   }
3652
3653   /* Now create the actual key material */
3654   if (!silc_server_create_channel_key(server, entry,
3655                                       silc_cipher_get_key_len(send_key) / 8)) {
3656     silc_idlist_del_channel(server->local_list, entry);
3657     return NULL;
3658   }
3659
3660   /* Notify other routers about the new channel. We send the packet
3661      to our primary route. */
3662   if (broadcast)
3663     silc_server_send_new_channel(server, SILC_PRIMARY_ROUTE(server), TRUE,
3664                                  channel_name, entry->id,
3665                                  silc_id_get_len(entry->id, SILC_ID_CHANNEL),
3666                                  entry->mode);
3667
3668   /* Distribute to backup routers */
3669   if (broadcast && server->server_type == SILC_ROUTER) {
3670     SilcBuffer packet;
3671     unsigned char cid[32];
3672     SilcUInt32 name_len = strlen(channel_name);
3673     SilcUInt32 id_len;
3674
3675     silc_id_id2str(entry->id, SILC_ID_CHANNEL, cid, sizeof(cid), &id_len);
3676     packet = silc_channel_payload_encode(channel_name, name_len,
3677                                          cid, id_len, entry->mode);
3678     silc_server_backup_send(server, NULL, SILC_PACKET_NEW_CHANNEL, 0,
3679                             packet->data, silc_buffer_len(packet), FALSE,
3680                             TRUE);
3681     silc_buffer_free(packet);
3682   }
3683
3684   server->stat.my_channels++;
3685   if (server->server_type == SILC_ROUTER) {
3686     server->stat.channels++;
3687     server->stat.cell_channels++;
3688     entry->users_resolved = TRUE;
3689   }
3690
3691   return entry;
3692 }
3693
3694 /* Channel's key re-key timeout callback. */
3695
3696 SILC_TASK_CALLBACK(silc_server_channel_key_rekey)
3697 {
3698   SilcServer server = app_context;
3699   SilcServerChannelRekey rekey = (SilcServerChannelRekey)context;
3700
3701   rekey->task = NULL;
3702
3703   /* Return now if we are shutting down */
3704   if (server->server_shutdown)
3705     return;
3706
3707   if (!silc_server_create_channel_key(server, rekey->channel, rekey->key_len))
3708     return;
3709
3710   silc_server_send_channel_key(server, NULL, rekey->channel, FALSE);
3711 }
3712
3713 /* Generates new channel key. This is used to create the initial channel key
3714    but also to re-generate new key for channel. If `key_len' is provided
3715    it is the bytes of the key length. */
3716
3717 SilcBool silc_server_create_channel_key(SilcServer server,
3718                                         SilcChannelEntry channel,
3719                                         SilcUInt32 key_len)
3720 {
3721   int i;
3722   unsigned char channel_key[32], hash[SILC_HASH_MAXLEN];
3723   SilcUInt32 len;
3724
3725   if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY) {
3726     SILC_LOG_DEBUG(("Channel has private keys, will not generate new key"));
3727     return TRUE;
3728   }
3729
3730   SILC_LOG_DEBUG(("Generating channel %s key", channel->channel_name));
3731
3732   if (!channel->send_key)
3733     if (!silc_cipher_alloc(SILC_DEFAULT_CIPHER, &channel->send_key)) {
3734       channel->send_key = NULL;
3735       return FALSE;
3736     }
3737   if (!channel->receive_key)
3738     if (!silc_cipher_alloc(SILC_DEFAULT_CIPHER, &channel->receive_key)) {
3739       silc_cipher_free(channel->send_key);
3740       channel->send_key = channel->receive_key = NULL;
3741       return FALSE;
3742     }
3743
3744   if (key_len)
3745     len = key_len;
3746   else if (channel->key_len)
3747     len = channel->key_len / 8;
3748   else
3749     len = silc_cipher_get_key_len(channel->send_key) / 8;
3750
3751   /* Create channel key */
3752   for (i = 0; i < len; i++) channel_key[i] = silc_rng_get_byte(server->rng);
3753
3754   /* Set the key */
3755   silc_cipher_set_key(channel->send_key, channel_key, len * 8, TRUE);
3756   silc_cipher_set_key(channel->receive_key, channel_key, len * 8, FALSE);
3757
3758   /* Remove old key if exists */
3759   if (channel->key) {
3760     memset(channel->key, 0, channel->key_len / 8);
3761     silc_free(channel->key);
3762   }
3763
3764   /* Save the key */
3765   channel->key_len = len * 8;
3766   channel->key = silc_memdup(channel_key, len);
3767   memset(channel_key, 0, sizeof(channel_key));
3768
3769   /* Generate HMAC key from the channel key data and set it */
3770   if (!channel->hmac)
3771     if (!silc_hmac_alloc(SILC_DEFAULT_HMAC, NULL, &channel->hmac)) {
3772       memset(channel->key, 0, channel->key_len / 8);
3773       silc_free(channel->key);
3774       silc_cipher_free(channel->send_key);
3775       silc_cipher_free(channel->receive_key);
3776       channel->send_key = channel->receive_key = NULL;
3777       return FALSE;
3778     }
3779   silc_hash_make(silc_hmac_get_hash(channel->hmac), channel->key, len, hash);
3780   silc_hmac_set_key(channel->hmac, hash,
3781                     silc_hash_len(silc_hmac_get_hash(channel->hmac)));
3782   memset(hash, 0, sizeof(hash));
3783
3784   if (server->server_type == SILC_ROUTER) {
3785     if (!channel->rekey)
3786       channel->rekey = silc_calloc(1, sizeof(*channel->rekey));
3787     channel->rekey->channel = channel;
3788     channel->rekey->key_len = key_len;
3789     if (channel->rekey->task)
3790       silc_schedule_task_del(server->schedule, channel->rekey->task);
3791
3792     channel->rekey->task =
3793       silc_schedule_task_add_timeout(server->schedule,
3794                                      silc_server_channel_key_rekey,
3795                                      (void *)channel->rekey,
3796                                      server->config->channel_rekey_secs, 0);
3797   }
3798
3799   return TRUE;
3800 }
3801
3802 /* Saves the channel key found in the encoded `key_payload' buffer. This
3803    function is used when we receive Channel Key Payload and also when we're
3804    processing JOIN command reply. Returns entry to the channel. */
3805
3806 SilcChannelEntry silc_server_save_channel_key(SilcServer server,
3807                                               SilcBuffer key_payload,
3808                                               SilcChannelEntry channel)
3809 {
3810   SilcChannelKeyPayload payload = NULL;
3811   SilcChannelID id;
3812   unsigned char *tmp, hash[SILC_HASH_MAXLEN];
3813   SilcUInt32 tmp_len;
3814   char *cipher;
3815
3816   /* Decode channel key payload */
3817   payload = silc_channel_key_payload_parse(key_payload->data,
3818                                            silc_buffer_len(key_payload));
3819   if (!payload) {
3820     SILC_LOG_ERROR(("Bad channel key payload received, dropped"));
3821     channel = NULL;
3822     goto out;
3823   }
3824
3825   /* Get the channel entry */
3826   if (!channel) {
3827
3828     /* Get channel ID */
3829     tmp = silc_channel_key_get_id(payload, &tmp_len);
3830     if (!silc_id_str2id(tmp, tmp_len, SILC_ID_CHANNEL, &id, sizeof(id))) {
3831       channel = NULL;
3832       goto out;
3833     }
3834
3835     channel = silc_idlist_find_channel_by_id(server->local_list, &id, NULL);
3836     if (!channel) {
3837       channel = silc_idlist_find_channel_by_id(server->global_list, &id, NULL);
3838       if (!channel) {
3839         if (server->server_type == SILC_ROUTER)
3840           SILC_LOG_ERROR(("Received key for non-existent channel %s",
3841                           silc_id_render(&id, SILC_ID_CHANNEL)));
3842         goto out;
3843       }
3844     }
3845   }
3846
3847   SILC_LOG_DEBUG(("Saving new channel %s key", channel->channel_name));
3848
3849   tmp = silc_channel_key_get_key(payload, &tmp_len);
3850   if (!tmp) {
3851     channel = NULL;
3852     goto out;
3853   }
3854
3855   cipher = silc_channel_key_get_cipher(payload, NULL);
3856   if (!cipher) {
3857     channel = NULL;
3858     goto out;
3859   }
3860
3861   /* Remove old key if exists */
3862   if (channel->key) {
3863     memset(channel->key, 0, channel->key_len / 8);
3864     silc_free(channel->key);
3865     silc_cipher_free(channel->send_key);
3866     silc_cipher_free(channel->receive_key);
3867   }
3868
3869   /* Create new cipher */
3870   if (!silc_cipher_alloc(cipher, &channel->send_key)) {
3871     channel->send_key = NULL;
3872     channel = NULL;
3873     goto out;
3874   }
3875   if (!silc_cipher_alloc(cipher, &channel->receive_key)) {
3876     silc_cipher_free(channel->send_key);
3877     channel->send_key = channel->receive_key = NULL;
3878     channel = NULL;
3879     goto out;
3880   }
3881
3882   if (channel->cipher)
3883     silc_free(channel->cipher);
3884   channel->cipher = strdup(cipher);
3885
3886   /* Save the key */
3887   channel->key_len = tmp_len * 8;
3888   channel->key = silc_memdup(tmp, tmp_len);
3889   silc_cipher_set_key(channel->send_key, tmp, channel->key_len, TRUE);
3890   silc_cipher_set_key(channel->receive_key, tmp, channel->key_len, FALSE);
3891
3892   /* Generate HMAC key from the channel key data and set it */
3893   if (!channel->hmac)
3894     if (!silc_hmac_alloc(SILC_DEFAULT_HMAC, NULL, &channel->hmac)) {
3895       memset(channel->key, 0, channel->key_len / 8);
3896       silc_free(channel->key);
3897       silc_cipher_free(channel->send_key);
3898       silc_cipher_free(channel->receive_key);
3899       channel->send_key = channel->receive_key = NULL;
3900       return FALSE;
3901     }
3902   silc_hash_make(silc_hmac_get_hash(channel->hmac), tmp, tmp_len, hash);
3903   silc_hmac_set_key(channel->hmac, hash,
3904                     silc_hash_len(silc_hmac_get_hash(channel->hmac)));
3905
3906   memset(hash, 0, sizeof(hash));
3907   memset(tmp, 0, tmp_len);
3908
3909   if (server->server_type == SILC_ROUTER) {
3910     if (!channel->rekey)
3911       channel->rekey = silc_calloc(1, sizeof(*channel->rekey));
3912     channel->rekey->channel = channel;
3913     if (channel->rekey->task)
3914       silc_schedule_task_del(server->schedule, channel->rekey->task);
3915
3916     channel->rekey->task =
3917       silc_schedule_task_add_timeout(server->schedule,
3918                                      silc_server_channel_key_rekey,
3919                                      (void *)channel->rekey,
3920                                      server->config->channel_rekey_secs, 0);
3921   }
3922
3923  out:
3924   if (payload)
3925     silc_channel_key_payload_free(payload);
3926
3927   return channel;
3928 }
3929
3930 /* Returns assembled of all servers in the given ID list. The packet's
3931    form is dictated by the New ID payload. */
3932
3933 static void silc_server_announce_get_servers(SilcServer server,
3934                                              SilcServerEntry remote,
3935                                              SilcIDList id_list,
3936                                              SilcBuffer *servers,
3937                                              unsigned long creation_time)
3938 {
3939   SilcList list;
3940   SilcIDCacheEntry id_cache;
3941   SilcServerEntry entry;
3942   SilcBuffer idp;
3943
3944   /* Go through all clients in the list */
3945   if (silc_idcache_get_all(id_list->servers, &list)) {
3946     silc_list_start(list);
3947     while ((id_cache = silc_list_get(list))) {
3948       entry = (SilcServerEntry)id_cache->context;
3949
3950       /* Do not announce the one we've sending our announcements and
3951          do not announce ourself. Also check the creation time if it's
3952          provided. */
3953       if ((entry == remote) || (entry == server->id_entry) ||
3954           (creation_time && entry->data.created < creation_time))
3955         continue;
3956
3957       idp = silc_id_payload_encode(entry->id, SILC_ID_SERVER);
3958
3959       *servers = silc_buffer_realloc(*servers,
3960                                      (*servers ?
3961                                       silc_buffer_truelen((*servers)) +
3962                                       silc_buffer_len(idp) :
3963                                       silc_buffer_len(idp)));
3964       silc_buffer_pull_tail(*servers, ((*servers)->end - (*servers)->data));
3965       silc_buffer_put(*servers, idp->data, silc_buffer_len(idp));
3966       silc_buffer_pull(*servers, silc_buffer_len(idp));
3967       silc_buffer_free(idp);
3968     }
3969   }
3970 }
3971
3972 static SilcBuffer
3973 silc_server_announce_encode_notify(SilcNotifyType notify, SilcUInt32 argc, ...)
3974 {
3975   va_list ap;
3976   SilcBuffer p;
3977
3978   va_start(ap, argc);
3979   p = silc_notify_payload_encode(notify, argc, ap);
3980   va_end(ap);
3981
3982   return p;
3983 }
3984
3985 /* This function is used by router to announce existing servers to our
3986    primary router when we've connected to it. If `creation_time' is non-zero
3987    then only the servers that has been created after the `creation_time'
3988    will be announced. */
3989
3990 void silc_server_announce_servers(SilcServer server, SilcBool global,
3991                                   unsigned long creation_time,
3992                                   SilcPacketStream remote)
3993 {
3994   SilcBuffer servers = NULL;
3995
3996   SILC_LOG_DEBUG(("Announcing servers"));
3997
3998   /* Get servers in local list */
3999   silc_server_announce_get_servers(server, silc_packet_get_context(remote),
4000                                    server->local_list, &servers,
4001                                    creation_time);
4002
4003   if (global)
4004     /* Get servers in global list */
4005     silc_server_announce_get_servers(server, silc_packet_get_context(remote),
4006                                      server->global_list, &servers,
4007                                      creation_time);
4008
4009   if (servers) {
4010     silc_buffer_push(servers, servers->data - servers->head);
4011     SILC_LOG_HEXDUMP(("servers"), servers->data, silc_buffer_len(servers));
4012
4013     /* Send the packet */
4014     silc_server_packet_send(server, remote,
4015                             SILC_PACKET_NEW_ID, SILC_PACKET_FLAG_LIST,
4016                             servers->data, silc_buffer_len(servers));
4017
4018     silc_buffer_free(servers);
4019   }
4020 }
4021
4022 /* Returns assembled packet of all clients in the given ID list. The
4023    packet's form is dictated by the New ID Payload. */
4024
4025 static void silc_server_announce_get_clients(SilcServer server,
4026                                              SilcIDList id_list,
4027                                              SilcBuffer *clients,
4028                                              SilcBuffer *umodes,
4029                                              unsigned long creation_time)
4030 {
4031   SilcList list;
4032   SilcIDCacheEntry id_cache;
4033   SilcClientEntry client;
4034   SilcBuffer idp;
4035   SilcBuffer tmp;
4036   unsigned char mode[4];
4037
4038   /* Go through all clients in the list */
4039   if (silc_idcache_get_all(id_list->clients, &list)) {
4040     silc_list_start(list);
4041     while ((id_cache = silc_list_get(list))) {
4042       client = (SilcClientEntry)id_cache->context;
4043
4044       if (creation_time && client->data.created < creation_time)
4045         continue;
4046       if (!(client->data.status & SILC_IDLIST_STATUS_REGISTERED))
4047         continue;
4048       if (!client->connection && !client->router)
4049         continue;
4050
4051       SILC_LOG_DEBUG(("Announce Client ID %s",
4052                       silc_id_render(client->id, SILC_ID_CLIENT)));
4053
4054       idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
4055
4056       *clients = silc_buffer_realloc(*clients,
4057                                      (*clients ?
4058                                       silc_buffer_truelen((*clients)) +
4059                                       silc_buffer_len(idp) :
4060                                       silc_buffer_len(idp)));
4061       silc_buffer_pull_tail(*clients, ((*clients)->end - (*clients)->data));
4062       silc_buffer_put(*clients, idp->data, silc_buffer_len(idp));
4063       silc_buffer_pull(*clients, silc_buffer_len(idp));
4064
4065       SILC_PUT32_MSB(client->mode, mode);
4066       tmp =
4067         silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_UMODE_CHANGE,
4068                                            2, idp->data, silc_buffer_len(idp),
4069                                            mode, 4);
4070       *umodes = silc_buffer_realloc(*umodes,
4071                                     (*umodes ?
4072                                      silc_buffer_truelen((*umodes)) +
4073                                      silc_buffer_len(tmp) :
4074                                      silc_buffer_len(tmp)));
4075       silc_buffer_pull_tail(*umodes, ((*umodes)->end - (*umodes)->data));
4076       silc_buffer_put(*umodes, tmp->data, silc_buffer_len(tmp));
4077       silc_buffer_pull(*umodes, silc_buffer_len(tmp));
4078       silc_buffer_free(tmp);
4079
4080       silc_buffer_free(idp);
4081     }
4082   }
4083 }
4084
4085 /* This function is used to announce our existing clients to our router
4086    when we've connected to it. If `creation_time' is non-zero then only
4087    the clients that has been created after the `creation_time' will be
4088    announced. */
4089
4090 void silc_server_announce_clients(SilcServer server,
4091                                   unsigned long creation_time,
4092                                   SilcPacketStream remote)
4093 {
4094   SilcBuffer clients = NULL;
4095   SilcBuffer umodes = NULL;
4096
4097   SILC_LOG_DEBUG(("Announcing clients"));
4098
4099   /* Get clients in local list */
4100   silc_server_announce_get_clients(server, server->local_list,
4101                                    &clients, &umodes, creation_time);
4102
4103   /* As router we announce our global list as well */
4104   if (server->server_type == SILC_ROUTER)
4105     silc_server_announce_get_clients(server, server->global_list,
4106                                      &clients, &umodes, creation_time);
4107
4108   if (clients) {
4109     silc_buffer_push(clients, clients->data - clients->head);
4110     SILC_LOG_HEXDUMP(("clients"), clients->data, silc_buffer_len(clients));
4111
4112     /* Send the packet */
4113     silc_server_packet_send(server, remote,
4114                             SILC_PACKET_NEW_ID, SILC_PACKET_FLAG_LIST,
4115                             clients->data, silc_buffer_len(clients));
4116
4117     silc_buffer_free(clients);
4118   }
4119
4120   if (umodes) {
4121     silc_buffer_push(umodes, umodes->data - umodes->head);
4122     SILC_LOG_HEXDUMP(("umodes"), umodes->data, silc_buffer_len(umodes));
4123
4124     /* Send the packet */
4125     silc_server_packet_send(server, remote,
4126                             SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4127                             umodes->data, silc_buffer_len(umodes));
4128
4129     silc_buffer_free(umodes);
4130   }
4131 }
4132
4133 /* Returns channel's topic for announcing it */
4134
4135 void silc_server_announce_get_channel_topic(SilcServer server,
4136                                             SilcChannelEntry channel,
4137                                             SilcBuffer *topic)
4138 {
4139   SilcBuffer chidp;
4140
4141   if (channel->topic) {
4142     chidp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL);
4143     *topic = silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_TOPIC_SET, 2,
4144                                                 chidp->data,
4145                                                 silc_buffer_len(chidp),
4146                                                 channel->topic,
4147                                                 strlen(channel->topic));
4148     silc_buffer_free(chidp);
4149   }
4150 }
4151
4152 /* Returns channel's invite and ban lists */
4153
4154 void silc_server_announce_get_inviteban(SilcServer server,
4155                                         SilcChannelEntry channel,
4156                                         SilcBuffer *invite,
4157                                         SilcBuffer *ban)
4158 {
4159   SilcBuffer list, idp, idp2, tmp2;
4160   SilcUInt32 type;
4161   void *ptype;
4162   SilcHashTableList htl;
4163   const unsigned char a[1] = { 0x03 };
4164
4165   idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
4166
4167   /* Encode invite list */
4168   if (channel->invite_list && silc_hash_table_count(channel->invite_list)) {
4169     list = silc_buffer_alloc_size(2);
4170     type = silc_hash_table_count(channel->invite_list);
4171     SILC_PUT16_MSB(type, list->data);
4172     silc_hash_table_list(channel->invite_list, &htl);
4173     while (silc_hash_table_get(&htl, (void *)&ptype, (void *)&tmp2))
4174       list = silc_argument_payload_encode_one(list, tmp2->data,
4175                                               silc_buffer_len(tmp2),
4176                                               SILC_PTR_TO_32(ptype));
4177     silc_hash_table_list_reset(&htl);
4178
4179     idp2 = silc_id_payload_encode(server->id, SILC_ID_SERVER);
4180     *invite =
4181       silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_INVITE, 5,
4182                                          idp->data, silc_buffer_len(idp),
4183                                          channel->channel_name,
4184                                          strlen(channel->channel_name),
4185                                          idp2->data, silc_buffer_len(idp2),
4186                                          a, 1,
4187                                          list->data, silc_buffer_len(list));
4188     silc_buffer_free(idp2);
4189     silc_buffer_free(list);
4190   }
4191
4192   /* Encode ban list */
4193   if (channel->ban_list && silc_hash_table_count(channel->ban_list)) {
4194     list = silc_buffer_alloc_size(2);
4195     type = silc_hash_table_count(channel->ban_list);
4196     SILC_PUT16_MSB(type, list->data);
4197     silc_hash_table_list(channel->ban_list, &htl);
4198     while (silc_hash_table_get(&htl, (void *)&ptype, (void *)&tmp2))
4199       list = silc_argument_payload_encode_one(list, tmp2->data,
4200                                               silc_buffer_len(tmp2),
4201                                               SILC_PTR_TO_32(ptype));
4202     silc_hash_table_list_reset(&htl);
4203
4204     *ban =
4205       silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_BAN, 3,
4206                                          idp->data, silc_buffer_len(idp),
4207                                          a, 1,
4208                                          list->data, silc_buffer_len(list));
4209     silc_buffer_free(list);
4210   }
4211
4212   silc_buffer_free(idp);
4213 }
4214
4215 /* Returns assembled packets for channel users of the `channel'. */
4216
4217 void silc_server_announce_get_channel_users(SilcServer server,
4218                                             SilcChannelEntry channel,
4219                                             SilcBuffer *channel_modes,
4220                                             SilcBuffer *channel_users,
4221                                             SilcBuffer *channel_users_modes)
4222 {
4223   SilcChannelClientEntry chl;
4224   SilcHashTableList htl;
4225   SilcBuffer chidp, clidp, csidp;
4226   SilcBuffer tmp, fkey = NULL, chpklist;
4227   int len;
4228   unsigned char mode[4], ulimit[4];
4229   char *hmac;
4230
4231   SILC_LOG_DEBUG(("Start"));
4232
4233   chidp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL);
4234   csidp = silc_id_payload_encode(server->id, SILC_ID_SERVER);
4235   chpklist = silc_server_get_channel_pk_list(server, channel, TRUE, FALSE);
4236
4237   /* CMODE notify */
4238   SILC_PUT32_MSB(channel->mode, mode);
4239   if (channel->mode & SILC_CHANNEL_MODE_ULIMIT)
4240     SILC_PUT32_MSB(channel->user_limit, ulimit);
4241   hmac = channel->hmac ? (char *)silc_hmac_get_name(channel->hmac) : NULL;
4242   if (channel->founder_key)
4243     fkey = silc_public_key_payload_encode(channel->founder_key);
4244   tmp =
4245     silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_CMODE_CHANGE,
4246                                        8, csidp->data,
4247                                        silc_buffer_len(csidp),
4248                                        mode, sizeof(mode),
4249                                        NULL, 0,
4250                                        hmac, hmac ? strlen(hmac) : 0,
4251                                        channel->passphrase,
4252                                        channel->passphrase ?
4253                                        strlen(channel->passphrase) : 0,
4254                                        fkey ? fkey->data : NULL,
4255                                        fkey ? silc_buffer_len(fkey) : 0,
4256                                        chpklist ? chpklist->data : NULL,
4257                                        chpklist ?
4258                                        silc_buffer_len(chpklist) : 0,
4259                                        (channel->mode &
4260                                         SILC_CHANNEL_MODE_ULIMIT ?
4261                                         ulimit : NULL),
4262                                        (channel->mode &
4263                                         SILC_CHANNEL_MODE_ULIMIT ?
4264                                         sizeof(ulimit) : 0));
4265   len = silc_buffer_len(tmp);
4266   *channel_modes =
4267     silc_buffer_realloc(*channel_modes,
4268                         (*channel_modes ?
4269                          silc_buffer_truelen((*channel_modes)) + len : len));
4270   silc_buffer_pull_tail(*channel_modes,
4271                         ((*channel_modes)->end -
4272                          (*channel_modes)->data));
4273   silc_buffer_put(*channel_modes, tmp->data, silc_buffer_len(tmp));
4274   silc_buffer_pull(*channel_modes, len);
4275   silc_buffer_free(tmp);
4276   silc_buffer_free(fkey);
4277   fkey = NULL;
4278
4279   /* Now find all users on the channel */
4280   silc_hash_table_list(channel->user_list, &htl);
4281   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
4282     clidp = silc_id_payload_encode(chl->client->id, SILC_ID_CLIENT);
4283
4284     SILC_LOG_DEBUG(("JOIN Client %s", silc_id_render(chl->client->id,
4285                                                      SILC_ID_CLIENT)));
4286
4287     /* JOIN Notify */
4288     tmp = silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_JOIN, 2,
4289                                              clidp->data,
4290                                              silc_buffer_len(clidp),
4291                                              chidp->data,
4292                                              silc_buffer_len(chidp));
4293     len = silc_buffer_len(tmp);
4294     *channel_users =
4295       silc_buffer_realloc(*channel_users,
4296                           (*channel_users ?
4297                            silc_buffer_truelen((*channel_users)) + len : len));
4298     silc_buffer_pull_tail(*channel_users,
4299                           ((*channel_users)->end -
4300                            (*channel_users)->data));
4301
4302     silc_buffer_put(*channel_users, tmp->data, silc_buffer_len(tmp));
4303     silc_buffer_pull(*channel_users, len);
4304     silc_buffer_free(tmp);
4305
4306     /* CUMODE notify for mode change on the channel */
4307     SILC_PUT32_MSB(chl->mode, mode);
4308     if (chl->mode & SILC_CHANNEL_UMODE_CHANFO && channel->founder_key)
4309       fkey = silc_public_key_payload_encode(channel->founder_key);
4310     tmp = silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_CUMODE_CHANGE,
4311                                              4, csidp->data,
4312                                              silc_buffer_len(csidp),
4313                                              mode, sizeof(mode),
4314                                              clidp->data,
4315                                              silc_buffer_len(clidp),
4316                                              fkey ? fkey->data : NULL,
4317                                              fkey ? silc_buffer_len(fkey) : 0);
4318     len = silc_buffer_len(tmp);
4319     *channel_users_modes =
4320       silc_buffer_realloc(*channel_users_modes,
4321                           (*channel_users_modes ?
4322                            silc_buffer_truelen((*channel_users_modes)) +
4323                            len : len));
4324     silc_buffer_pull_tail(*channel_users_modes,
4325                           ((*channel_users_modes)->end -
4326                            (*channel_users_modes)->data));
4327
4328     silc_buffer_put(*channel_users_modes, tmp->data, silc_buffer_len(tmp));
4329     silc_buffer_pull(*channel_users_modes, len);
4330     silc_buffer_free(tmp);
4331     silc_buffer_free(fkey);
4332     fkey = NULL;
4333     silc_buffer_free(clidp);
4334   }
4335   silc_hash_table_list_reset(&htl);
4336   silc_buffer_free(chidp);
4337   silc_buffer_free(csidp);
4338 }
4339
4340 /* Returns assembled packets for all channels and users on those channels
4341    from the given ID List. The packets are in the form dictated by the
4342    New Channel and New Channel User payloads. */
4343
4344 void silc_server_announce_get_channels(SilcServer server,
4345                                        SilcIDList id_list,
4346                                        SilcBuffer *channels,
4347                                        SilcBuffer **channel_modes,
4348                                        SilcBuffer *channel_users,
4349                                        SilcBuffer **channel_users_modes,
4350                                        SilcUInt32 *channel_users_modes_c,
4351                                        SilcBuffer **channel_topics,
4352                                        SilcBuffer **channel_invites,
4353                                        SilcBuffer **channel_bans,
4354                                        SilcChannelID ***channel_ids,
4355                                        unsigned long creation_time)
4356 {
4357   SilcList list;
4358   SilcIDCacheEntry id_cache;
4359   SilcChannelEntry channel;
4360   unsigned char cid[32];
4361   SilcUInt32 id_len;
4362   SilcUInt16 name_len;
4363   int len;
4364   int i = *channel_users_modes_c;
4365   SilcBool announce;
4366
4367   SILC_LOG_DEBUG(("Start"));
4368
4369   /* Go through all channels in the list */
4370   if (silc_idcache_get_all(id_list->channels, &list)) {
4371     silc_list_start(list);
4372     while ((id_cache = silc_list_get(list))) {
4373       channel = (SilcChannelEntry)id_cache->context;
4374
4375       if (creation_time && channel->created < creation_time)
4376         announce = FALSE;
4377       else
4378         announce = TRUE;
4379
4380       SILC_LOG_DEBUG(("Announce Channel ID %s",
4381                       silc_id_render(channel->id, SILC_ID_CHANNEL)));
4382
4383       silc_id_id2str(channel->id, SILC_ID_CHANNEL, cid, sizeof(cid), &id_len);
4384       name_len = strlen(channel->channel_name);
4385
4386       if (announce) {
4387         len = 4 + name_len + id_len + 4;
4388         *channels =
4389           silc_buffer_realloc(*channels,
4390                               (*channels ?
4391                                silc_buffer_truelen((*channels)) +
4392                                len : len));
4393         silc_buffer_pull_tail(*channels,
4394                               ((*channels)->end - (*channels)->data));
4395         silc_buffer_format(*channels,
4396                            SILC_STR_UI_SHORT(name_len),
4397                            SILC_STR_UI_XNSTRING(channel->channel_name,
4398                                                 name_len),
4399                            SILC_STR_UI_SHORT(id_len),
4400                              SILC_STR_UI_XNSTRING(cid, id_len),
4401                            SILC_STR_UI_INT(channel->mode),
4402                            SILC_STR_END);
4403         silc_buffer_pull(*channels, len);
4404       }
4405
4406       if (creation_time && channel->updated < creation_time)
4407         announce = FALSE;
4408       else
4409         announce = TRUE;
4410
4411       if (announce) {
4412         /* Channel user modes */
4413         *channel_users_modes = silc_realloc(*channel_users_modes,
4414                                             sizeof(**channel_users_modes) *
4415                                             (i + 1));
4416         (*channel_users_modes)[i] = NULL;
4417         *channel_modes = silc_realloc(*channel_modes,
4418                                       sizeof(**channel_modes) * (i + 1));
4419         (*channel_modes)[i] = NULL;
4420         *channel_ids = silc_realloc(*channel_ids,
4421                                       sizeof(**channel_ids) * (i + 1));
4422         (*channel_ids)[i] = NULL;
4423         silc_server_announce_get_channel_users(server, channel,
4424                                                &(*channel_modes)[i],
4425                                                channel_users,
4426                                                &(*channel_users_modes)[i]);
4427         (*channel_ids)[i] = channel->id;
4428
4429         /* Channel's topic */
4430         *channel_topics = silc_realloc(*channel_topics,
4431                                        sizeof(**channel_topics) * (i + 1));
4432         (*channel_topics)[i] = NULL;
4433         silc_server_announce_get_channel_topic(server, channel,
4434                                                &(*channel_topics)[i]);
4435
4436         /* Channel's invite and ban list */
4437         *channel_invites = silc_realloc(*channel_invites,
4438                                         sizeof(**channel_invites) * (i + 1));
4439         (*channel_invites)[i] = NULL;
4440         *channel_bans = silc_realloc(*channel_bans,
4441                                      sizeof(**channel_bans) * (i + 1));
4442         (*channel_bans)[i] = NULL;
4443         silc_server_announce_get_inviteban(server, channel,
4444                                            &(*channel_invites)[i],
4445                                            &(*channel_bans)[i]);
4446
4447         (*channel_users_modes_c)++;
4448
4449         i++;
4450       }
4451     }
4452   }
4453 }
4454
4455 /* This function is used to announce our existing channels to our router
4456    when we've connected to it. This also announces the users on the
4457    channels to the router. If the `creation_time' is non-zero only the
4458    channels that was created after the `creation_time' are announced.
4459    Note that the channel users are still announced even if the `creation_time'
4460    was provided. */
4461
4462 void silc_server_announce_channels(SilcServer server,
4463                                    unsigned long creation_time,
4464                                    SilcPacketStream remote)
4465 {
4466   SilcBuffer channels = NULL, *channel_modes = NULL, channel_users = NULL;
4467   SilcBuffer *channel_users_modes = NULL;
4468   SilcBuffer *channel_topics = NULL;
4469   SilcBuffer *channel_invites = NULL;
4470   SilcBuffer *channel_bans = NULL;
4471   SilcUInt32 channel_users_modes_c = 0;
4472   SilcChannelID **channel_ids = NULL;
4473
4474   SILC_LOG_DEBUG(("Announcing channels and channel users"));
4475
4476   /* Get channels and channel users in local list */
4477   silc_server_announce_get_channels(server, server->local_list,
4478                                     &channels, &channel_modes,
4479                                     &channel_users,
4480                                     &channel_users_modes,
4481                                     &channel_users_modes_c,
4482                                     &channel_topics,
4483                                     &channel_invites,
4484                                     &channel_bans,
4485                                     &channel_ids, creation_time);
4486
4487   /* Get channels and channel users in global list */
4488   if (server->server_type != SILC_SERVER)
4489     silc_server_announce_get_channels(server, server->global_list,
4490                                       &channels, &channel_modes,
4491                                       &channel_users,
4492                                       &channel_users_modes,
4493                                       &channel_users_modes_c,
4494                                       &channel_topics,
4495                                       &channel_invites,
4496                                       &channel_bans,
4497                                       &channel_ids, creation_time);
4498
4499   if (channels) {
4500     silc_buffer_push(channels, channels->data - channels->head);
4501     SILC_LOG_HEXDUMP(("channels"), channels->data, silc_buffer_len(channels));
4502
4503     /* Send the packet */
4504     silc_server_packet_send(server, remote,
4505                             SILC_PACKET_NEW_CHANNEL, SILC_PACKET_FLAG_LIST,
4506                             channels->data, silc_buffer_len(channels));
4507
4508     silc_buffer_free(channels);
4509   }
4510
4511   if (channel_users) {
4512     silc_buffer_push(channel_users, channel_users->data - channel_users->head);
4513     SILC_LOG_HEXDUMP(("channel users"), channel_users->data,
4514                      silc_buffer_len(channel_users));
4515
4516     /* Send the packet */
4517     silc_server_packet_send(server, remote,
4518                             SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4519                             channel_users->data, silc_buffer_len(channel_users));
4520
4521     silc_buffer_free(channel_users);
4522   }
4523
4524   if (channel_modes) {
4525     int i;
4526
4527     for (i = 0; i < channel_users_modes_c; i++) {
4528       if (!channel_modes[i])
4529         continue;
4530       silc_buffer_push(channel_modes[i],
4531                        channel_modes[i]->data -
4532                        channel_modes[i]->head);
4533       SILC_LOG_HEXDUMP(("channel modes"), channel_modes[i]->data,
4534                        silc_buffer_len(channel_modes[i]));
4535       silc_server_packet_send_dest(server, remote,
4536                                    SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4537                                    channel_ids[i], SILC_ID_CHANNEL,
4538                                    channel_modes[i]->data,
4539                                    silc_buffer_len(channel_modes[i]));
4540       silc_buffer_free(channel_modes[i]);
4541     }
4542     silc_free(channel_modes);
4543   }
4544
4545   if (channel_users_modes) {
4546     int i;
4547
4548     for (i = 0; i < channel_users_modes_c; i++) {
4549       if (!channel_users_modes[i])
4550         continue;
4551       silc_buffer_push(channel_users_modes[i],
4552                        channel_users_modes[i]->data -
4553                        channel_users_modes[i]->head);
4554       SILC_LOG_HEXDUMP(("channel users modes"), channel_users_modes[i]->data,
4555                        silc_buffer_len(channel_users_modes[i]));
4556       silc_server_packet_send_dest(server, remote,
4557                                    SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4558                                    channel_ids[i], SILC_ID_CHANNEL,
4559                                    channel_users_modes[i]->data,
4560                                    silc_buffer_len(channel_users_modes[i]));
4561       silc_buffer_free(channel_users_modes[i]);
4562     }
4563     silc_free(channel_users_modes);
4564   }
4565
4566   if (channel_topics) {
4567     int i;
4568
4569     for (i = 0; i < channel_users_modes_c; i++) {
4570       if (!channel_topics[i])
4571         continue;
4572
4573       silc_buffer_push(channel_topics[i],
4574                        channel_topics[i]->data -
4575                        channel_topics[i]->head);
4576       SILC_LOG_HEXDUMP(("channel topic"), channel_topics[i]->data,
4577                        silc_buffer_len(channel_topics[i]));
4578       silc_server_packet_send_dest(server, remote,
4579                                    SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4580                                    channel_ids[i], SILC_ID_CHANNEL,
4581                                    channel_topics[i]->data,
4582                                    silc_buffer_len(channel_topics[i]));
4583       silc_buffer_free(channel_topics[i]);
4584     }
4585     silc_free(channel_topics);
4586   }
4587
4588   if (channel_invites) {
4589     int i;
4590
4591     for (i = 0; i < channel_users_modes_c; i++) {
4592       if (!channel_invites[i])
4593         continue;
4594
4595       silc_buffer_push(channel_invites[i],
4596                        channel_invites[i]->data -
4597                        channel_invites[i]->head);
4598       SILC_LOG_HEXDUMP(("channel invite list"), channel_invites[i]->data,
4599                        silc_buffer_len(channel_invites[i]));
4600       silc_server_packet_send_dest(server, remote,
4601                                    SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4602                                    channel_ids[i], SILC_ID_CHANNEL,
4603                                    channel_invites[i]->data,
4604                                    silc_buffer_len(channel_invites[i]));
4605       silc_buffer_free(channel_invites[i]);
4606     }
4607     silc_free(channel_invites);
4608   }
4609
4610   if (channel_bans) {
4611     int i;
4612
4613     for (i = 0; i < channel_users_modes_c; i++) {
4614       if (!channel_bans[i])
4615         continue;
4616
4617       silc_buffer_push(channel_bans[i],
4618                        channel_bans[i]->data -
4619                        channel_bans[i]->head);
4620       SILC_LOG_HEXDUMP(("channel ban list"), channel_bans[i]->data,
4621                        silc_buffer_len(channel_bans[i]));
4622       silc_server_packet_send_dest(server, remote,
4623                                    SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4624                                    channel_ids[i], SILC_ID_CHANNEL,
4625                                    channel_bans[i]->data,
4626                                    silc_buffer_len(channel_bans[i]));
4627       silc_buffer_free(channel_bans[i]);
4628     }
4629     silc_free(channel_bans);
4630   }
4631
4632   silc_free(channel_ids);
4633 }
4634
4635 /* Announces WATCH list. */
4636
4637 void silc_server_announce_watches(SilcServer server,
4638                                   SilcPacketStream remote)
4639 {
4640   SilcHashTableList htl;
4641   SilcBuffer buffer, idp, args, pkp;
4642   SilcClientEntry client;
4643   void *key;
4644
4645   SILC_LOG_DEBUG(("Announcing watch list"));
4646
4647   /* XXX because way we save the nicks (hash) we cannot announce them. */
4648
4649   /* XXX we should send all public keys in one command if client is
4650      watching more than one key */
4651   silc_hash_table_list(server->watcher_list_pk, &htl);
4652   while (silc_hash_table_get(&htl, &key, (void *)&client)) {
4653     if (!client || !client->id)
4654       continue;
4655
4656     server->stat.commands_sent++;
4657
4658     idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
4659     args = silc_buffer_alloc_size(2);
4660     silc_buffer_format(args,
4661                        SILC_STR_UI_SHORT(1),
4662                        SILC_STR_END);
4663     pkp = silc_public_key_payload_encode(key);
4664     args = silc_argument_payload_encode_one(args, pkp->data,
4665                                             silc_buffer_len(pkp), 0x00);
4666     buffer = silc_command_payload_encode_va(SILC_COMMAND_WATCH,
4667                                             ++server->cmd_ident, 2,
4668                                             1, idp->data, silc_buffer_len(idp),
4669                                             4, args->data,
4670                                             silc_buffer_len(args));
4671
4672     /* Send command */
4673     silc_server_packet_send(server, remote, SILC_PACKET_COMMAND, 0,
4674                             buffer->data, silc_buffer_len(buffer));
4675
4676     silc_buffer_free(pkp);
4677     silc_buffer_free(args);
4678     silc_buffer_free(idp);
4679     silc_buffer_free(buffer);
4680   }
4681   silc_hash_table_list_reset(&htl);
4682 }
4683
4684 /* Assembles user list and users mode list from the `channel'. */
4685
4686 SilcBool silc_server_get_users_on_channel(SilcServer server,
4687                                           SilcChannelEntry channel,
4688                                           SilcBuffer *user_list,
4689                                           SilcBuffer *mode_list,
4690                                           SilcUInt32 *user_count)
4691 {
4692   SilcChannelClientEntry chl;
4693   SilcHashTableList htl;
4694   SilcBuffer client_id_list;
4695   SilcBuffer client_mode_list;
4696   SilcBuffer idp;
4697   SilcUInt32 list_count = 0, len = 0;
4698
4699   if (!silc_hash_table_count(channel->user_list))
4700     return FALSE;
4701
4702   silc_hash_table_list(channel->user_list, &htl);
4703   while (silc_hash_table_get(&htl, NULL, (void *)&chl))
4704     len += (silc_id_get_len(chl->client->id, SILC_ID_CLIENT) + 4);
4705   silc_hash_table_list_reset(&htl);
4706
4707   client_id_list = silc_buffer_alloc(len);
4708   client_mode_list =
4709     silc_buffer_alloc(4 * silc_hash_table_count(channel->user_list));
4710   silc_buffer_pull_tail(client_id_list, silc_buffer_truelen(client_id_list));
4711   silc_buffer_pull_tail(client_mode_list,
4712                         silc_buffer_truelen(client_mode_list));
4713
4714   silc_hash_table_list(channel->user_list, &htl);
4715   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
4716     /* Client ID */
4717     idp = silc_id_payload_encode(chl->client->id, SILC_ID_CLIENT);
4718     silc_buffer_put(client_id_list, idp->data, silc_buffer_len(idp));
4719     silc_buffer_pull(client_id_list, silc_buffer_len(idp));
4720     silc_buffer_free(idp);
4721
4722     /* Client's mode on channel */
4723     SILC_PUT32_MSB(chl->mode, client_mode_list->data);
4724     silc_buffer_pull(client_mode_list, 4);
4725
4726     list_count++;
4727   }
4728   silc_hash_table_list_reset(&htl);
4729   silc_buffer_push(client_id_list,
4730                    client_id_list->data - client_id_list->head);
4731   silc_buffer_push(client_mode_list,
4732                    client_mode_list->data - client_mode_list->head);
4733
4734   *user_list = client_id_list;
4735   *mode_list = client_mode_list;
4736   *user_count = list_count;
4737   return TRUE;
4738 }
4739
4740 /* Saves users and their modes to the `channel'. */
4741
4742 void silc_server_save_users_on_channel(SilcServer server,
4743                                        SilcPacketStream sock,
4744                                        SilcChannelEntry channel,
4745                                        SilcClientID *noadd,
4746                                        SilcBuffer user_list,
4747                                        SilcBuffer mode_list,
4748                                        SilcUInt32 user_count)
4749 {
4750   int i;
4751   SilcUInt16 idp_len;
4752   SilcUInt32 mode;
4753   SilcID id;
4754   SilcClientEntry client;
4755   SilcIDCacheEntry cache;
4756   SilcChannelClientEntry chl;
4757
4758   SILC_LOG_DEBUG(("Saving %d users on %s channel", user_count,
4759                   channel->channel_name));
4760
4761   for (i = 0; i < user_count; i++) {
4762     /* Client ID */
4763     SILC_GET16_MSB(idp_len, user_list->data + 2);
4764     idp_len += 4;
4765     if (!silc_id_payload_parse_id(user_list->data, idp_len, &id))
4766       continue;
4767     silc_buffer_pull(user_list, idp_len);
4768
4769     /* Mode */
4770     SILC_GET32_MSB(mode, mode_list->data);
4771     silc_buffer_pull(mode_list, 4);
4772
4773     if (noadd && SILC_ID_CLIENT_COMPARE(&id.u.client_id, noadd))
4774       continue;
4775
4776     cache = NULL;
4777
4778     /* Check if we have this client cached already. */
4779     client = silc_idlist_find_client_by_id(server->local_list,
4780                                            &id.u.client_id,
4781                                            server->server_type, &cache);
4782     if (!client)
4783       client = silc_idlist_find_client_by_id(server->global_list,
4784                                              &id.u.client_id,
4785                                              server->server_type, &cache);
4786     if (!client) {
4787       /* If router did not find such Client ID in its lists then this must
4788          be bogus client or some router in the net is buggy. */
4789       if (server->server_type != SILC_SERVER)
4790         continue;
4791
4792       /* We don't have that client anywhere, add it. The client is added
4793          to global list since server didn't have it in the lists so it must be
4794          global. */
4795       client = silc_idlist_add_client(server->global_list, NULL, NULL, NULL,
4796                                       silc_id_dup(&id.u.client_id,
4797                                                   SILC_ID_CLIENT),
4798                                       silc_packet_get_context(sock),
4799                                       NULL);
4800       if (!client) {
4801         SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
4802         continue;
4803       }
4804
4805       client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
4806     }
4807
4808     if (!(client->data.status & SILC_IDLIST_STATUS_REGISTERED)) {
4809       SILC_LOG_ERROR(("Attempting to add unregistered client to channel ",
4810                       "%s", channel->channel_name));
4811       continue;
4812     }
4813
4814     if (!silc_server_client_on_channel(client, channel, &chl)) {
4815       /* Client was not on the channel, add it. */
4816       chl = silc_calloc(1, sizeof(*chl));
4817       chl->client = client;
4818       chl->mode = mode;
4819       chl->channel = channel;
4820       silc_hash_table_add(channel->user_list, chl->client, chl);
4821       silc_hash_table_add(client->channels, chl->channel, chl);
4822       channel->user_count++;
4823     } else {
4824       /* Update mode */
4825       chl->mode = mode;
4826     }
4827   }
4828 }
4829
4830 /* Saves channels and channels user modes to the `client'.  Removes
4831    the client from those channels that are not sent in the list but
4832    it has joined. */
4833
4834 void silc_server_save_user_channels(SilcServer server,
4835                                     SilcPacketStream sock,
4836                                     SilcClientEntry client,
4837                                     SilcBuffer channels,
4838                                     SilcBuffer channels_user_modes)
4839 {
4840   SilcDList ch;
4841   SilcUInt32 *chumodes;
4842   SilcChannelPayload entry;
4843   SilcChannelEntry channel;
4844   SilcChannelID channel_id;
4845   SilcChannelClientEntry chl;
4846   SilcHashTable ht = NULL;
4847   SilcHashTableList htl;
4848   char *name;
4849   int i = 0;
4850
4851   if (!channels || !channels_user_modes ||
4852       !(client->data.status & SILC_IDLIST_STATUS_REGISTERED))
4853     goto out;
4854
4855   ch = silc_channel_payload_parse_list(channels->data,
4856                                        silc_buffer_len(channels));
4857   if (ch && silc_get_mode_list(channels_user_modes, silc_dlist_count(ch),
4858                                &chumodes)) {
4859     ht = silc_hash_table_alloc(0, silc_hash_ptr, NULL, NULL,
4860                                NULL, NULL, NULL, TRUE);
4861     silc_dlist_start(ch);
4862     while ((entry = silc_dlist_get(ch)) != SILC_LIST_END) {
4863       /* Check if we have this channel, and add it if we don't have it.
4864          Also add the client on the channel unless it is there already. */
4865       if (!silc_channel_get_id_parse(entry, &channel_id))
4866         continue;
4867       channel = silc_idlist_find_channel_by_id(server->local_list,
4868                                                &channel_id, NULL);
4869       if (!channel)
4870         channel = silc_idlist_find_channel_by_id(server->global_list,
4871                                                  &channel_id, NULL);
4872       if (!channel) {
4873         if (server->server_type != SILC_SERVER) {
4874           i++;
4875           continue;
4876         }
4877
4878         /* We don't have that channel anywhere, add it. */
4879         name = silc_channel_get_name(entry, NULL);
4880         channel = silc_idlist_add_channel(server->global_list, strdup(name), 0,
4881                                           silc_id_dup(&channel_id,
4882                                                       SILC_ID_CHANNEL),
4883                                           server->router, NULL, NULL, 0);
4884         if (!channel) {
4885           i++;
4886           continue;
4887         }
4888       }
4889
4890       channel->mode = silc_channel_get_mode(entry);
4891
4892       /* Add the client on the channel */
4893       if (!silc_server_client_on_channel(client, channel, &chl)) {
4894         chl = silc_calloc(1, sizeof(*chl));
4895         chl->client = client;
4896         chl->mode = chumodes[i++];
4897         chl->channel = channel;
4898         silc_hash_table_add(channel->user_list, chl->client, chl);
4899         silc_hash_table_add(client->channels, chl->channel, chl);
4900         channel->user_count++;
4901       } else {
4902         /* Update mode */
4903         chl->mode = chumodes[i++];
4904       }
4905
4906       silc_hash_table_add(ht, channel, channel);
4907     }
4908     silc_channel_payload_list_free(ch);
4909     silc_free(chumodes);
4910   }
4911
4912  out:
4913   /* Go through the list again and remove client from channels that
4914      are no part of the list. */
4915   if (ht) {
4916     silc_hash_table_list(client->channels, &htl);
4917     while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
4918       if (!silc_hash_table_find(ht, chl->channel, NULL, NULL)) {
4919         silc_hash_table_del(chl->channel->user_list, chl->client);
4920         silc_hash_table_del(chl->client->channels, chl->channel);
4921         silc_free(chl);
4922       }
4923     }
4924     silc_hash_table_list_reset(&htl);
4925     silc_hash_table_free(ht);
4926   } else {
4927     silc_hash_table_list(client->channels, &htl);
4928     while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
4929       silc_hash_table_del(chl->channel->user_list, chl->client);
4930       silc_hash_table_del(chl->client->channels, chl->channel);
4931       silc_free(chl);
4932     }
4933     silc_hash_table_list_reset(&htl);
4934   }
4935 }
4936
4937 /* Lookups route to the client indicated by the `id_data'. The connection
4938    object and internal data object is returned. Returns NULL if route
4939    could not be found to the client. If the `client_id' is specified then
4940    it is used and the `id_data' is ignored. */
4941
4942 SilcPacketStream
4943 silc_server_get_client_route(SilcServer server,
4944                              unsigned char *id_data,
4945                              SilcUInt32 id_len,
4946                              SilcClientID *client_id,
4947                              SilcIDListData *idata,
4948                              SilcClientEntry *client_entry)
4949 {
4950   SilcClientID *id, clid;
4951   SilcClientEntry client;
4952
4953   SILC_LOG_DEBUG(("Start"));
4954
4955   if (client_entry)
4956     *client_entry = NULL;
4957
4958   /* Decode destination Client ID */
4959   if (!client_id) {
4960     if (!silc_id_str2id(id_data, id_len, SILC_ID_CLIENT, &clid, sizeof(clid)))
4961       return NULL;
4962     id = silc_id_dup(&clid, SILC_ID_CLIENT);
4963   } else {
4964     id = silc_id_dup(client_id, SILC_ID_CLIENT);
4965   }
4966
4967   /* If the destination belongs to our server we don't have to route
4968      the packet anywhere but to send it to the local destination. */
4969   client = silc_idlist_find_client_by_id(server->local_list, id, TRUE, NULL);
4970   if (client) {
4971     silc_free(id);
4972
4973     /* If we are router and the client has router then the client is in
4974        our cell but not directly connected to us. */
4975     if (server->server_type == SILC_ROUTER && client->router) {
4976       /* We are of course in this case the client's router thus the route
4977          to the client is the server who owns the client. So, we will send
4978          the packet to that server. */
4979       if (idata)
4980         *idata = (SilcIDListData)client->router;
4981       return client->router->connection;
4982     }
4983
4984     /* Seems that client really is directly connected to us */
4985     if (idata)
4986       *idata = (SilcIDListData)client;
4987     if (client_entry)
4988       *client_entry = client;
4989     return client->connection;
4990   }
4991
4992   /* Destination belongs to someone not in this server. If we are normal
4993      server our action is to send the packet to our router. */
4994   if (server->server_type != SILC_ROUTER && !server->standalone) {
4995     silc_free(id);
4996     if (idata)
4997       *idata = (SilcIDListData)server->router;
4998     return SILC_PRIMARY_ROUTE(server);
4999   }
5000
5001   /* We are router and we will perform route lookup for the destination
5002      and send the packet to fastest route. */
5003   if (server->server_type == SILC_ROUTER && !server->standalone) {
5004     /* Check first that the ID is valid */
5005     client = silc_idlist_find_client_by_id(server->global_list, id,
5006                                            TRUE, NULL);
5007     if (client) {
5008       SilcPacketStream dst_sock;
5009
5010       dst_sock = silc_server_route_get(server, id, SILC_ID_CLIENT);
5011
5012       silc_free(id);
5013       if (idata && dst_sock)
5014         *idata = silc_packet_get_context(dst_sock);
5015       return dst_sock;
5016     }
5017   }
5018
5019   silc_free(id);
5020   return NULL;
5021 }
5022
5023 /* Encodes and returns channel list of channels the `client' has joined.
5024    Secret channels are not put to the list. */
5025
5026 SilcBuffer silc_server_get_client_channel_list(SilcServer server,
5027                                                SilcClientEntry client,
5028                                                SilcBool get_private,
5029                                                SilcBool get_secret,
5030                                                SilcBuffer *user_mode_list)
5031 {
5032   SilcBuffer buffer = NULL;
5033   SilcChannelEntry channel;
5034   SilcChannelClientEntry chl;
5035   SilcHashTableList htl;
5036   unsigned char cid[32];
5037   SilcUInt32 id_len;
5038   SilcUInt16 name_len;
5039   int len;
5040
5041   if (user_mode_list)
5042     *user_mode_list = NULL;
5043
5044   silc_hash_table_list(client->channels, &htl);
5045   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
5046     channel = chl->channel;
5047
5048     if (channel->mode & SILC_CHANNEL_MODE_SECRET && !get_secret)
5049       continue;
5050     if (channel->mode & SILC_CHANNEL_MODE_PRIVATE && !get_private)
5051       continue;
5052
5053     silc_id_id2str(channel->id, SILC_ID_CHANNEL, cid, sizeof(cid), &id_len);
5054     name_len = strlen(channel->channel_name);
5055
5056     len = 4 + name_len + id_len + 4;
5057     buffer = silc_buffer_realloc(buffer,
5058                                  (buffer ?
5059                                   silc_buffer_truelen(buffer) + len : len));
5060     silc_buffer_pull_tail(buffer, (buffer->end - buffer->data));
5061     silc_buffer_format(buffer,
5062                        SILC_STR_UI_SHORT(name_len),
5063                        SILC_STR_DATA(channel->channel_name, name_len),
5064                        SILC_STR_UI_SHORT(id_len),
5065                        SILC_STR_DATA(cid, id_len),
5066                        SILC_STR_UI_INT(chl->channel->mode),
5067                        SILC_STR_END);
5068     silc_buffer_pull(buffer, len);
5069
5070     if (user_mode_list) {
5071       *user_mode_list =
5072         silc_buffer_realloc(*user_mode_list,
5073                             (*user_mode_list ?
5074                              silc_buffer_truelen((*user_mode_list)) + 4 : 4));
5075       silc_buffer_pull_tail(*user_mode_list, ((*user_mode_list)->end -
5076                                               (*user_mode_list)->data));
5077       SILC_PUT32_MSB(chl->mode, (*user_mode_list)->data);
5078       silc_buffer_pull(*user_mode_list, 4);
5079     }
5080   }
5081   silc_hash_table_list_reset(&htl);
5082
5083   if (buffer)
5084     silc_buffer_push(buffer, buffer->data - buffer->head);
5085   if (user_mode_list && *user_mode_list)
5086     silc_buffer_push(*user_mode_list, ((*user_mode_list)->data -
5087                                        (*user_mode_list)->head));
5088
5089   return buffer;
5090 }
5091
5092 /* Task callback used to retrieve network statistical information from
5093    router server once in a while. */
5094
5095 SILC_TASK_CALLBACK(silc_server_get_stats)
5096 {
5097   SilcServer server = (SilcServer)context;
5098   SilcBuffer idp, packet;
5099
5100   if (!server->standalone) {
5101     SILC_LOG_DEBUG(("Retrieving stats from router"));
5102     server->stat.commands_sent++;
5103     idp = silc_id_payload_encode(server->router->id, SILC_ID_SERVER);
5104     if (idp) {
5105       packet = silc_command_payload_encode_va(SILC_COMMAND_STATS,
5106                                               ++server->cmd_ident, 1,
5107                                               1, idp->data,
5108                                               silc_buffer_len(idp));
5109       silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
5110                               SILC_PACKET_COMMAND, 0, packet->data,
5111                               silc_buffer_len(packet));
5112       silc_buffer_free(packet);
5113       silc_buffer_free(idp);
5114     }
5115   }
5116
5117   silc_schedule_task_add_timeout(server->schedule, silc_server_get_stats,
5118                                  server, 120, 0);
5119 }