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