apps/silcd/server.c

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