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