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