apps/silcd/server.c

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