apps/silcd/server.c

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