apps/silcd/server.c

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