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