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