apps/silcd/server.c

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