apps/silcd/server.c

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