apps/silcd/server.c

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