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       }
1510 #if 0
1511           else {
1512         /* We already have primary router.  Disconnect this connection */
1513         SILC_LOG_DEBUG(("We already have primary router, disconnect"));
1514         silc_idlist_del_server(server->global_list, id_entry);
1515         if (sconn->callback)
1516           (*sconn->callback)(server, NULL, sconn->callback_context);
1517         silc_server_free_sock_user_data(server, sconn->sock, NULL);
1518         silc_server_disconnect_remote(server, sconn->sock,
1519                                       SILC_STATUS_ERR_RESOURCE_LIMIT, NULL);
1520         return;
1521       }
1522 #endif /* 0 */
1523     } else {
1524       /* Add this server to be our backup router */
1525       id_entry->server_type = SILC_BACKUP_ROUTER;
1526       silc_server_backup_add(server, id_entry, sconn->backup_replace_ip,
1527                              sconn->backup_replace_port, FALSE);
1528     }
1529
1530     break;
1531
1532   default:
1533     if (sconn->callback)
1534       (*sconn->callback)(server, NULL, sconn->callback_context);
1535     silc_server_free_sock_user_data(server, sconn->sock, NULL);
1536     silc_server_disconnect_remote(server, sconn->sock,
1537                                   SILC_STATUS_ERR_AUTH_FAILED, NULL);
1538     return;
1539   }
1540
1541   SILC_LOG_DEBUG(("Connection established, sock %p", sconn->sock));
1542
1543   conn = sconn->conn.ref_ptr;
1544   param = &server->config->param;
1545   if (conn && conn->param)
1546     param = conn->param;
1547
1548   /* Register rekey timeout */
1549   sconn->rekey_timeout = param->key_exchange_rekey;
1550   silc_schedule_task_add_timeout(server->schedule, silc_server_do_rekey,
1551                                  sconn->sock, sconn->rekey_timeout, 0);
1552
1553   /* Set the entry as packet stream context */
1554   silc_packet_set_context(sconn->sock, id_entry);
1555
1556   /* Call the completion callback to indicate that we've connected to
1557      the router */
1558   if (sconn && sconn->callback)
1559     (*sconn->callback)(server, id_entry, sconn->callback_context);
1560
1561   if (sconn == server->router_conn)
1562     server->router_conn = NULL;
1563
1564   silc_free(entry);
1565 }
1566
1567 /* SKE completion callback */
1568
1569 static void silc_server_ke_completed(SilcSKE ske, SilcSKEStatus status,
1570                                      SilcSKESecurityProperties prop,
1571                                      SilcSKEKeyMaterial keymat,
1572                                      SilcSKERekeyMaterial rekey,
1573                                      void *context)
1574 {
1575   SilcPacketStream sock = context;
1576   SilcUnknownEntry entry = silc_packet_get_context(sock);
1577   SilcServerConnection sconn = entry->data.sconn;
1578   SilcServer server = entry->server;
1579   SilcServerConfigRouter *conn = sconn->conn.ref_ptr;
1580   SilcAuthMethod auth_meth = SILC_AUTH_NONE;
1581   void *auth_data = NULL;
1582   SilcUInt32 auth_data_len = 0;
1583   SilcConnAuth connauth;
1584   SilcCipher send_key, receive_key;
1585   SilcHmac hmac_send, hmac_receive;
1586   SilcHash hash;
1587
1588   SILC_LOG_DEBUG(("Connection %p, SKE completed, entry %p", sconn, entry));
1589
1590   entry->op = NULL;
1591
1592   if (status != SILC_SKE_STATUS_OK) {
1593     /* SKE failed */
1594     SILC_LOG_ERROR(("Error (%s) during Key Exchange protocol with %s (%s)",
1595                     silc_ske_map_status(status), entry->hostname, entry->ip));
1596
1597     /* XXX retry connecting */
1598     silc_ske_free(ske);
1599     if (sconn->callback)
1600       (*sconn->callback)(server, NULL, sconn->callback_context);
1601     silc_server_free_sock_user_data(server, sconn->sock, NULL);
1602     silc_server_disconnect_remote(server, sconn->sock,
1603                                   SILC_STATUS_ERR_KEY_EXCHANGE_FAILED, NULL);
1604     return;
1605   }
1606
1607   SILC_LOG_DEBUG(("Setting keys into use"));
1608
1609   /* Set the keys into use.  The data will be encrypted after this. */
1610   if (!silc_ske_set_keys(ske, keymat, prop, &send_key, &receive_key,
1611                          &hmac_send, &hmac_receive, &hash)) {
1612
1613     /* XXX retry connecting */
1614
1615     /* Error setting keys */
1616     silc_ske_free(ske);
1617     if (sconn->callback)
1618       (*sconn->callback)(server, NULL, sconn->callback_context);
1619     silc_server_free_sock_user_data(server, sconn->sock, NULL);
1620     silc_server_disconnect_remote(server, sconn->sock,
1621                                   SILC_STATUS_ERR_KEY_EXCHANGE_FAILED, NULL);
1622     return;
1623   }
1624   silc_packet_set_keys(sconn->sock, send_key, receive_key, hmac_send,
1625                        hmac_receive, FALSE);
1626
1627   SILC_LOG_DEBUG(("Starting connection authentication"));
1628
1629   connauth = silc_connauth_alloc(server->schedule, ske,
1630                                  server->config->conn_auth_timeout);
1631   if (!connauth) {
1632     /* XXX retry connecting */
1633
1634     /** Error allocating auth protocol */
1635     silc_ske_free(ske);
1636     if (sconn->callback)
1637       (*sconn->callback)(server, NULL, sconn->callback_context);
1638     silc_server_free_sock_user_data(server, sconn->sock, NULL);
1639     silc_server_disconnect_remote(server, sconn->sock,
1640                                   SILC_STATUS_ERR_RESOURCE_LIMIT, NULL);
1641     return;
1642   }
1643
1644   /* Get authentication method */
1645   if (conn) {
1646     if (conn->passphrase) {
1647       if (conn->publickeys && !server->config->prefer_passphrase_auth) {
1648         auth_meth = SILC_AUTH_PUBLIC_KEY;
1649         auth_data = server->private_key;
1650       } else {
1651         auth_meth = SILC_AUTH_PASSWORD;
1652         auth_data = conn->passphrase;
1653         auth_data_len = conn->passphrase_len;
1654       }
1655     } else {
1656       auth_meth = SILC_AUTH_PUBLIC_KEY;
1657       auth_data = server->private_key;
1658     }
1659   }
1660
1661   entry->data.rekey = rekey;
1662
1663   /* Start connection authentication */
1664   entry->op =
1665     silc_connauth_initiator(connauth, server->server_type == SILC_SERVER ?
1666                             SILC_CONN_SERVER : SILC_CONN_ROUTER, auth_meth,
1667                             auth_data, auth_data_len,
1668                             silc_server_ke_auth_compl, sconn);
1669 }
1670
1671 /* Function that is called when the network connection to a router has
1672    been established.  This will continue with the key exchange protocol
1673    with the remote router. */
1674
1675 void silc_server_start_key_exchange(SilcServerConnection sconn)
1676 {
1677   SilcServer server = sconn->server;
1678   SilcServerConfigRouter *conn = sconn->conn.ref_ptr;
1679   SilcUnknownEntry entry;
1680   SilcSKEParamsStruct params;
1681   SilcSKE ske;
1682
1683   /* Cancel any possible retry timeouts */
1684   silc_schedule_task_del_by_context(server->schedule, sconn);
1685
1686   /* Create packet stream */
1687   sconn->sock = silc_packet_stream_create(server->packet_engine,
1688                                           server->schedule, sconn->stream);
1689   if (!sconn->sock) {
1690     SILC_LOG_ERROR(("Cannot connect: cannot create packet stream"));
1691     silc_stream_destroy(sconn->stream);
1692     if (sconn->callback)
1693       (*sconn->callback)(server, NULL, sconn->callback_context);
1694     silc_server_connection_free(sconn);
1695     return;
1696   }
1697   server->stat.conn_num++;
1698
1699   /* Set source ID to packet stream */
1700   if (!silc_packet_set_ids(sconn->sock, SILC_ID_SERVER, server->id,
1701                            0, NULL)) {
1702     if (sconn->callback)
1703       (*sconn->callback)(server, NULL, sconn->callback_context);
1704     silc_packet_stream_destroy(sconn->sock);
1705     silc_server_connection_free(sconn);
1706     return;
1707   }
1708
1709   /* Create entry for remote entity */
1710   entry = silc_calloc(1, sizeof(*entry));
1711   if (!entry) {
1712     silc_packet_stream_destroy(sconn->sock);
1713     silc_server_connection_free(sconn);
1714     return;
1715   }
1716   entry->server = server;
1717   entry->data.sconn = sconn;
1718   silc_packet_set_context(sconn->sock, entry);
1719
1720   SILC_LOG_DEBUG(("Created unknown connection %p", entry));
1721
1722   /* Set Key Exchange flags from configuration, but fall back to global
1723      settings too. */
1724   memset(&params, 0, sizeof(params));
1725   SILC_GET_SKE_FLAGS(conn, params.flags);
1726   if (server->config->param.key_exchange_pfs)
1727     params.flags |= SILC_SKE_SP_FLAG_PFS;
1728
1729   /* Start SILC Key Exchange protocol */
1730   SILC_LOG_DEBUG(("Starting key exchange protocol, connection %p", sconn));
1731   ske = silc_ske_alloc(server->rng, server->schedule, server->repository,
1732                        server->public_key, server->private_key, sconn);
1733   if (!ske) {
1734     silc_free(entry);
1735     if (sconn->callback)
1736       (*sconn->callback)(server, NULL, sconn->callback_context);
1737     silc_packet_stream_destroy(sconn->sock);
1738     silc_server_connection_free(sconn);
1739     return;
1740   }
1741   silc_ske_set_callbacks(ske, silc_server_verify_key,
1742                          silc_server_ke_completed, sconn->sock);
1743
1744   /* Start key exchange protocol */
1745   params.version = silc_version_string;
1746   params.timeout_secs = server->config->key_exchange_timeout;
1747   entry->op = silc_ske_initiator(ske, sconn->sock, &params, NULL);
1748 }
1749
1750 /* Timeout callback that will be called to retry connecting to remote
1751    router. This is used by both normal and router server. This will wait
1752    before retrying the connecting. The timeout is generated by exponential
1753    backoff algorithm. */
1754
1755 SILC_TASK_CALLBACK(silc_server_connect_to_router_retry)
1756 {
1757   SilcServerConnection sconn = context;
1758   SilcServer server = sconn->server;
1759   SilcServerConfigRouter *conn = sconn->conn.ref_ptr;
1760   SilcServerConfigConnParams *param =
1761                 (conn->param ? conn->param : &server->config->param);
1762
1763   SILC_LOG_INFO(("Retrying connecting to %s:%d", sconn->remote_host,
1764                  sconn->remote_port));
1765
1766   /* Calculate next timeout */
1767   if (sconn->retry_count >= 1) {
1768     sconn->retry_timeout = sconn->retry_timeout * SILC_SERVER_RETRY_MULTIPLIER;
1769     if (sconn->retry_timeout > param->reconnect_interval_max)
1770       sconn->retry_timeout = param->reconnect_interval_max;
1771   } else {
1772     sconn->retry_timeout = param->reconnect_interval;
1773   }
1774   sconn->retry_count++;
1775   sconn->retry_timeout = sconn->retry_timeout +
1776     (silc_rng_get_rn32(server->rng) % SILC_SERVER_RETRY_RANDOMIZER);
1777
1778   /* If we've reached max retry count, give up. */
1779   if ((sconn->retry_count > param->reconnect_count) &&
1780       !param->reconnect_keep_trying) {
1781     SILC_LOG_ERROR(("Could not connect, giving up"));
1782
1783     if (sconn->callback)
1784       (*sconn->callback)(server, NULL, sconn->callback_context);
1785     silc_server_connection_free(sconn);
1786     return;
1787   }
1788
1789   SILC_LOG_DEBUG(("Retrying connecting %d seconds", sconn->retry_timeout));
1790
1791   /* We will lookup a fresh pointer later */
1792   silc_server_config_unref(&sconn->conn);
1793
1794   /* Wait before retrying */
1795   silc_schedule_task_del_by_context(server->schedule, sconn);
1796   silc_schedule_task_add_timeout(server->schedule, silc_server_connect_router,
1797                                  sconn, sconn->retry_timeout, 0);
1798 }
1799
1800 /* Callback for async connection to remote router */
1801
1802 static void silc_server_connection_established(SilcNetStatus status,
1803                                                SilcStream stream,
1804                                                void *context)
1805 {
1806   SilcServerConnection sconn = context;
1807   SilcServer server = sconn->server;
1808
1809   silc_schedule_task_del_by_context(server->schedule, sconn);
1810   sconn->op = NULL;
1811
1812   switch (status) {
1813   case SILC_NET_OK:
1814     SILC_LOG_DEBUG(("Connection %p to %s:%d established", sconn,
1815                     sconn->remote_host, sconn->remote_port));
1816
1817     /* Continue with key exchange protocol */
1818     sconn->stream = stream;
1819     silc_server_start_key_exchange(sconn);
1820     break;
1821
1822   case SILC_NET_UNKNOWN_IP:
1823   case SILC_NET_UNKNOWN_HOST:
1824     SILC_LOG_ERROR(("Could not connect to %s:%d: %s",
1825                     sconn->remote_host, sconn->remote_port,
1826                     silc_net_get_error_string(status)));
1827
1828     if (sconn->callback)
1829       (*sconn->callback)(server, NULL, sconn->callback_context);
1830     silc_server_connection_free(sconn);
1831     break;
1832
1833   default:
1834     SILC_LOG_ERROR(("Could not connect to %s:%d: %s",
1835                     sconn->remote_host, sconn->remote_port,
1836                     silc_net_get_error_string(status)));
1837     if (!sconn->no_reconnect) {
1838       silc_schedule_task_add_timeout(sconn->server->schedule,
1839                                      silc_server_connect_to_router_retry,
1840                                      sconn, 1, 0);
1841       silc_dlist_del(server->conns, sconn);
1842     } else {
1843       if (sconn->callback)
1844         (*sconn->callback)(server, NULL, sconn->callback_context);
1845       silc_server_connection_free(sconn);
1846     }
1847     break;
1848   }
1849 }
1850
1851 /* Generic routine to use connect to a router. */
1852
1853 SILC_TASK_CALLBACK(silc_server_connect_router)
1854 {
1855   SilcServerConnection sconn = context;
1856   SilcServer server = sconn->server;
1857   SilcServerConfigRouter *rconn;
1858
1859   silc_schedule_task_del_by_context(server->schedule, sconn);
1860
1861   /* Don't connect if we are shutting down. */
1862   if (server->server_shutdown) {
1863     if (sconn->callback)
1864       (*sconn->callback)(server, NULL, sconn->callback_context);
1865     silc_server_connection_free(sconn);
1866     return;
1867   }
1868
1869   SILC_LOG_INFO(("Connecting to the %s %s on port %d",
1870                  (sconn->backup ? "backup router" : "router"),
1871                  sconn->remote_host, sconn->remote_port));
1872
1873   if (!sconn->no_conf) {
1874     /* Find connection configuration */
1875     rconn = silc_server_config_find_router_conn(server, sconn->remote_host,
1876                                                 sconn->remote_port);
1877     if (!rconn) {
1878       SILC_LOG_INFO(("Unconfigured %s connection %s:%d, cannot connect",
1879                      (sconn->backup ? "backup router" : "router"),
1880                      sconn->remote_host, sconn->remote_port));
1881       silc_server_connection_free(sconn);
1882       return;
1883     }
1884     silc_server_config_ref(&sconn->conn, server->config, (void *)rconn);
1885   }
1886
1887   /* Connect to remote host */
1888   sconn->op =
1889     silc_net_tcp_connect((!server->config->server_info->primary ? NULL :
1890                           server->config->server_info->primary->server_ip),
1891                          sconn->remote_host, sconn->remote_port,
1892                          server->schedule, silc_server_connection_established,
1893                          sconn);
1894   if (!sconn->op) {
1895     SILC_LOG_ERROR(("Could not connect to router %s:%d",
1896                     sconn->remote_host, sconn->remote_port));
1897     silc_server_connection_free(sconn);
1898     return;
1899   }
1900
1901   /* Add to connection list */
1902   silc_dlist_add(server->conns, sconn);
1903 }
1904
1905 /* This function connects to our primary router or if we are a router this
1906    establishes all our primary routes. This is called at the start of the
1907    server to do authentication and key exchange with our router - called
1908    from schedule. */
1909
1910 SILC_TASK_CALLBACK(silc_server_connect_to_router)
1911 {
1912   SilcServer server = context;
1913   SilcServerConnection sconn;
1914   SilcServerConfigRouter *ptr;
1915
1916   /* Don't connect if we are shutting down. */
1917   if (server->server_shutdown)
1918     return;
1919
1920   SILC_LOG_DEBUG(("We are %s",
1921                   (server->server_type == SILC_SERVER ?
1922                    "normal server" : server->server_type == SILC_ROUTER ?
1923                    "router" : "backup router/normal server")));
1924
1925   if (!server->config->routers) {
1926     /* There wasn't a configured router, we will continue but we don't
1927        have a connection to outside world.  We will be standalone server. */
1928     SILC_LOG_DEBUG(("No router(s), we are standalone"));
1929     server->standalone = TRUE;
1930     return;
1931   }
1932
1933   /* Cancel any possible retry timeouts */
1934   silc_schedule_task_del_by_callback(server->schedule,
1935                                      silc_server_connect_router);
1936   silc_schedule_task_del_by_callback(server->schedule,
1937                                      silc_server_connect_to_router_retry);
1938
1939   /* Create the connections to all our routes */
1940   for (ptr = server->config->routers; ptr; ptr = ptr->next) {
1941
1942     SILC_LOG_DEBUG(("%s connection [%s] %s:%d",
1943                     ptr->backup_router ? "Backup router" : "Router",
1944                     ptr->initiator ? "Initiator" : "Responder",
1945                     ptr->host, ptr->port));
1946
1947     if (server->server_type == SILC_ROUTER && ptr->backup_router &&
1948         ptr->initiator == FALSE && !server->backup_router &&
1949         !silc_server_config_get_backup_router(server))
1950       server->wait_backup = TRUE;
1951
1952     if (!ptr->initiator)
1953       continue;
1954     if (ptr->dynamic_connection)
1955       continue;
1956
1957     /* Check whether we are connecting or connected to this host already */
1958     if (silc_server_num_sockets_by_remote(server,
1959                                           silc_net_is_ip(ptr->host) ?
1960                                           ptr->host : NULL,
1961                                           silc_net_is_ip(ptr->host) ?
1962                                           NULL : ptr->host, ptr->port,
1963                                           SILC_CONN_ROUTER)) {
1964       SILC_LOG_DEBUG(("We are already connected to %s:%d",
1965                       ptr->host, ptr->port));
1966
1967       /* If we don't have primary router and this connection is our
1968          primary router we are in desync.  Reconnect to the primary. */
1969       if (server->standalone && !server->router) {
1970         /* XXX */
1971         SilcPacketStream sock;
1972         SilcServerConfigRouter *primary =
1973           silc_server_config_get_primary_router(server);
1974         if (primary != ptr)
1975           continue;
1976         sock = silc_server_find_socket_by_host(server, SILC_CONN_ROUTER,
1977                                                ptr->host, ptr->port);
1978         if (!sock)
1979           continue;
1980         server->backup_noswitch = TRUE;
1981         silc_server_free_sock_user_data(server, sock, NULL);
1982         silc_server_disconnect_remote(server, sock, 0, NULL);
1983         server->backup_noswitch = FALSE;
1984         SILC_LOG_DEBUG(("Reconnecting to primary router"));
1985       } else {
1986         continue;
1987       }
1988     }
1989
1990     /* Allocate connection object for hold connection specific stuff. */
1991     sconn = silc_calloc(1, sizeof(*sconn));
1992     if (!sconn)
1993       continue;
1994     sconn->server = server;
1995     sconn->remote_host = strdup(ptr->host);
1996     sconn->remote_port = ptr->port;
1997     sconn->backup = ptr->backup_router;
1998     if (sconn->backup) {
1999       sconn->backup_replace_ip = strdup(ptr->backup_replace_ip);
2000       sconn->backup_replace_port = ptr->backup_replace_port;
2001     }
2002
2003     SILC_LOG_DEBUG(("Created connection %p", sconn));
2004
2005     if (!server->router_conn && !sconn->backup)
2006       server->router_conn = sconn;
2007
2008     /* Connect */
2009     silc_server_connect_router(server->schedule, server, SILC_TASK_EXPIRE,
2010                                0, sconn);
2011   }
2012 }
2013
2014
2015 /************************ Accepting new connection **************************/
2016
2017 /* After this is called, server don't wait for backup router anymore.
2018    This gets called automatically even after we have backup router
2019    connection established. */
2020
2021 SILC_TASK_CALLBACK(silc_server_backup_router_wait)
2022 {
2023   SilcServer server = context;
2024   server->wait_backup = FALSE;
2025 }
2026
2027 /* Authentication data callback */
2028
2029 static SilcBool
2030 silc_server_accept_get_auth(SilcConnAuth connauth,
2031                             SilcConnectionType conn_type,
2032                             unsigned char **passphrase,
2033                             SilcUInt32 *passphrase_len,
2034                             SilcSKR *repository,
2035                             void *context)
2036 {
2037   SilcPacketStream sock = context;
2038   SilcUnknownEntry entry = silc_packet_get_context(sock);
2039   SilcServer server = entry->server;
2040
2041   SILC_LOG_DEBUG(("Remote connection type %d", conn_type));
2042
2043   /* Remote end is client */
2044   if (conn_type == SILC_CONN_CLIENT) {
2045     SilcServerConfigClient *cconfig = entry->cconfig.ref_ptr;
2046     if (!cconfig)
2047       return FALSE;
2048
2049     *passphrase = cconfig->passphrase;
2050     *passphrase_len = cconfig->passphrase_len;
2051     if (cconfig->publickeys)
2052       *repository = server->repository;
2053
2054     if (cconfig->publickeys) {
2055       if (server->config->prefer_passphrase_auth) {
2056         *repository = NULL;
2057       } else {
2058         *passphrase = NULL;
2059         *passphrase_len = 0;
2060       }
2061     }
2062
2063     entry->conn_type = conn_type;
2064     return TRUE;
2065   }
2066
2067   /* Remote end is server */
2068   if (conn_type == SILC_CONN_SERVER) {
2069     SilcServerConfigServer *sconfig;
2070
2071     /* If we are normal server, don't accept the connection */
2072     if (server->server_type == SILC_SERVER)
2073       return FALSE;
2074
2075     sconfig = entry->sconfig.ref_ptr;
2076     if (!sconfig)
2077       return FALSE;
2078
2079     *passphrase = sconfig->passphrase;
2080     *passphrase_len = sconfig->passphrase_len;
2081     if (sconfig->publickeys)
2082       *repository = server->repository;
2083
2084     if (sconfig->publickeys) {
2085       if (server->config->prefer_passphrase_auth) {
2086         *repository = NULL;
2087       } else {
2088         *passphrase = NULL;
2089         *passphrase_len = 0;
2090       }
2091     }
2092
2093     entry->conn_type = conn_type;
2094     return TRUE;
2095   }
2096
2097   /* Remote end is router */
2098   if (conn_type == SILC_CONN_ROUTER) {
2099     SilcServerConfigRouter *rconfig = entry->rconfig.ref_ptr;
2100     if (!rconfig)
2101       return FALSE;
2102
2103     *passphrase = rconfig->passphrase;
2104     *passphrase_len = rconfig->passphrase_len;
2105     if (rconfig->publickeys)
2106       *repository = server->repository;
2107
2108     if (rconfig->publickeys) {
2109       if (server->config->prefer_passphrase_auth) {
2110         *repository = NULL;
2111       } else {
2112         *passphrase = NULL;
2113         *passphrase_len = 0;
2114       }
2115     }
2116
2117     entry->conn_type = conn_type;
2118     return TRUE;
2119   }
2120
2121   return FALSE;
2122 }
2123
2124 /* Authentication completion callback. */
2125
2126 static void
2127 silc_server_accept_auth_compl(SilcConnAuth connauth, SilcBool success,
2128                               void *context)
2129 {
2130   SilcPacketStream sock = context;
2131   SilcUnknownEntry entry = silc_packet_get_context(sock);
2132   SilcIDListData idata = (SilcIDListData)entry;
2133   SilcServer server = entry->server;
2134   SilcServerConfigConnParams *param = &server->config->param;
2135   SilcServerConnection sconn;
2136   void *id_entry;
2137   const char *hostname, *ip;
2138   SilcUInt16 port;
2139
2140   entry->op = NULL;
2141   silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
2142                               NULL, &hostname, &ip, &port);
2143
2144   if (success == FALSE) {
2145     /* Authentication failed */
2146     SILC_LOG_INFO(("Authentication failed for %s (%s) [%s]", entry->hostname,
2147                    entry->ip, SILC_CONNTYPE_STRING(entry->data.conn_type)));
2148     server->stat.auth_failures++;
2149     silc_server_disconnect_remote(server, sock,
2150                                   SILC_STATUS_ERR_KEY_EXCHANGE_FAILED, NULL);
2151     silc_server_config_unref(&entry->cconfig);
2152     silc_server_config_unref(&entry->sconfig);
2153     silc_server_config_unref(&entry->rconfig);
2154     silc_server_free_sock_user_data(server, sock, NULL);
2155     goto out;
2156   }
2157
2158   SILC_LOG_DEBUG(("Checking whether connection is allowed"));
2159
2160   switch (entry->conn_type) {
2161   case SILC_CONN_CLIENT:
2162     {
2163       SilcClientEntry client;
2164       SilcServerConfigClient *conn = entry->cconfig.ref_ptr;
2165
2166       /* Verify whether this connection is after all allowed to connect */
2167       if (!silc_server_connection_allowed(server, sock, entry->conn_type,
2168                                           &server->config->param,
2169                                           conn->param,
2170                                           silc_connauth_get_ske(connauth))) {
2171         server->stat.auth_failures++;
2172         goto out;
2173       }
2174
2175       /* If we are primary router and we have backup router configured
2176          but it has not connected to use yet, do not accept any other
2177          connection. */
2178       if (server->wait_backup && server->server_type == SILC_ROUTER &&
2179           !server->backup_router) {
2180         SilcServerConfigRouter *router;
2181         router = silc_server_config_get_backup_router(server);
2182         if (router && strcmp(server->config->server_info->primary->server_ip,
2183                              entry->ip) &&
2184             silc_server_find_socket_by_host(server,
2185                                             SILC_CONN_SERVER,
2186                                             router->backup_replace_ip, 0)) {
2187           SILC_LOG_INFO(("Will not accept connections because we do "
2188                          "not have backup router connection established"));
2189           silc_server_disconnect_remote(server, sock,
2190                                         SILC_STATUS_ERR_PERM_DENIED,
2191                                         "We do not have connection to backup "
2192                                         "router established, try later");
2193           silc_server_config_unref(&entry->cconfig);
2194           silc_server_config_unref(&entry->sconfig);
2195           silc_server_config_unref(&entry->rconfig);
2196           silc_server_free_sock_user_data(server, sock, NULL);
2197           server->stat.auth_failures++;
2198
2199           /* From here on, wait 20 seconds for the backup router to appear. */
2200           silc_schedule_task_add_timeout(server->schedule,
2201                                          silc_server_backup_router_wait,
2202                                          (void *)server, 20, 0);
2203           goto out;
2204         }
2205       }
2206
2207       SILC_LOG_DEBUG(("Remote host is client"));
2208       SILC_LOG_INFO(("Connection %s (%s) is client", entry->hostname,
2209                      entry->ip));
2210
2211       /* Add the client to the client ID cache. The nickname and Client ID
2212          and other information is created after we have received NEW_CLIENT
2213          packet from client. */
2214       client = silc_idlist_add_client(server->local_list,
2215                                       NULL, NULL, NULL, NULL, NULL, sock);
2216       if (!client) {
2217         SILC_LOG_ERROR(("Could not add new client to cache"));
2218         server->stat.auth_failures++;
2219         silc_server_disconnect_remote(server, sock,
2220                                       SILC_STATUS_ERR_AUTH_FAILED, NULL);
2221         silc_server_config_unref(&entry->cconfig);
2222         silc_server_config_unref(&entry->sconfig);
2223         silc_server_config_unref(&entry->rconfig);
2224         silc_server_free_sock_user_data(server, sock, NULL);
2225         goto out;
2226       }
2227       entry->data.status |= SILC_IDLIST_STATUS_LOCAL;
2228       entry->data.conn_type = SILC_CONN_CLIENT;
2229
2230       /* Statistics */
2231       server->stat.my_clients++;
2232       server->stat.clients++;
2233       server->stat.cell_clients++;
2234
2235       /* Get connection parameters */
2236       if (conn->param) {
2237         param = conn->param;
2238
2239         if (!param->keepalive_secs)
2240           param->keepalive_secs = server->config->param.keepalive_secs;
2241
2242         if (!param->qos && server->config->param.qos) {
2243           param->qos = server->config->param.qos;
2244           param->qos_rate_limit = server->config->param.qos_rate_limit;
2245           param->qos_bytes_limit = server->config->param.qos_bytes_limit;
2246           param->qos_limit_sec = server->config->param.qos_limit_sec;
2247           param->qos_limit_usec = server->config->param.qos_limit_usec;
2248         }
2249
2250         /* Check if to be anonymous connection */
2251         if (param->anonymous)
2252           client->mode |= SILC_UMODE_ANONYMOUS;
2253       }
2254
2255       /* Add public key to repository */
2256       SILC_LOG_DEBUG(("Add client public key to repository"));
2257       if (!silc_server_get_public_key_by_client(server, client, NULL))
2258         silc_skr_add_public_key_simple(server->repository,
2259                                        entry->data.public_key,
2260                                        SILC_SKR_USAGE_IDENTIFICATION, client,
2261                                        NULL);
2262
2263       id_entry = (void *)client;
2264       break;
2265     }
2266
2267   case SILC_CONN_SERVER:
2268   case SILC_CONN_ROUTER:
2269     {
2270       SilcServerEntry new_server;
2271       SilcBool initiator = FALSE;
2272       SilcBool backup_local = FALSE;
2273       SilcBool backup_router = FALSE;
2274       char *backup_replace_ip = NULL;
2275       SilcUInt16 backup_replace_port = 0;
2276       SilcServerConfigServer *srvconn = entry->sconfig.ref_ptr;
2277       SilcServerConfigRouter *rconn = entry->rconfig.ref_ptr;
2278
2279       /* If we are backup router and this is incoming server connection
2280          and we do not have connection to primary router, do not allow
2281          the connection. */
2282       if (server->server_type == SILC_BACKUP_ROUTER &&
2283           entry->conn_type == SILC_CONN_SERVER &&
2284           !SILC_PRIMARY_ROUTE(server)) {
2285         SILC_LOG_INFO(("Will not accept server connection because we do "
2286                        "not have primary router connection established"));
2287         silc_server_disconnect_remote(server, sock,
2288                                       SILC_STATUS_ERR_PERM_DENIED,
2289                                       "We do not have connection to primary "
2290                                       "router established, try later");
2291         silc_server_config_unref(&entry->cconfig);
2292         silc_server_config_unref(&entry->sconfig);
2293         silc_server_config_unref(&entry->rconfig);
2294         silc_server_free_sock_user_data(server, sock, NULL);
2295         server->stat.auth_failures++;
2296         goto out;
2297       }
2298
2299       if (entry->conn_type == SILC_CONN_ROUTER) {
2300         /* Verify whether this connection is after all allowed to connect */
2301         if (!silc_server_connection_allowed(server, sock,
2302                                             entry->conn_type,
2303                                             &server->config->param,
2304                                             rconn ? rconn->param : NULL,
2305                                             silc_connauth_get_ske(connauth))) {
2306           silc_server_config_unref(&entry->cconfig);
2307           silc_server_config_unref(&entry->sconfig);
2308           silc_server_config_unref(&entry->rconfig);
2309           server->stat.auth_failures++;
2310           goto out;
2311         }
2312
2313         if (rconn) {
2314           if (rconn->param) {
2315             param = rconn->param;
2316
2317             if (!param->keepalive_secs)
2318               param->keepalive_secs = server->config->param.keepalive_secs;
2319
2320             if (!param->qos && server->config->param.qos) {
2321               param->qos = server->config->param.qos;
2322               param->qos_rate_limit = server->config->param.qos_rate_limit;
2323               param->qos_bytes_limit = server->config->param.qos_bytes_limit;
2324               param->qos_limit_sec = server->config->param.qos_limit_sec;
2325               param->qos_limit_usec = server->config->param.qos_limit_usec;
2326             }
2327           }
2328
2329           initiator = rconn->initiator;
2330           backup_local = rconn->backup_local;
2331           backup_router = rconn->backup_router;
2332           backup_replace_ip = rconn->backup_replace_ip;
2333           backup_replace_port = rconn->backup_replace_port;
2334         }
2335       }
2336
2337       if (entry->conn_type == SILC_CONN_SERVER) {
2338         /* Verify whether this connection is after all allowed to connect */
2339         if (!silc_server_connection_allowed(server, sock,
2340                                             entry->conn_type,
2341                                             &server->config->param,
2342                                             srvconn ? srvconn->param : NULL,
2343                                             silc_connauth_get_ske(connauth))) {
2344           server->stat.auth_failures++;
2345           goto out;
2346         }
2347         if (srvconn) {
2348           if (srvconn->param) {
2349             param = srvconn->param;
2350
2351             if (!param->keepalive_secs)
2352               param->keepalive_secs = server->config->param.keepalive_secs;
2353
2354             if (!param->qos && server->config->param.qos) {
2355               param->qos = server->config->param.qos;
2356               param->qos_rate_limit = server->config->param.qos_rate_limit;
2357               param->qos_bytes_limit = server->config->param.qos_bytes_limit;
2358               param->qos_limit_sec = server->config->param.qos_limit_sec;
2359               param->qos_limit_usec = server->config->param.qos_limit_usec;
2360             }
2361           }
2362
2363           backup_router = srvconn->backup_router;
2364         }
2365       }
2366
2367       /* If we are primary router and we have backup router configured
2368          but it has not connected to use yet, do not accept any other
2369          connection. */
2370       if (server->wait_backup && server->server_type == SILC_ROUTER &&
2371           !server->backup_router && !backup_router) {
2372         SilcServerConfigRouter *router;
2373         router = silc_server_config_get_backup_router(server);
2374         if (router && strcmp(server->config->server_info->primary->server_ip,
2375                              ip) &&
2376             silc_server_find_socket_by_host(server,
2377                                             SILC_CONN_SERVER,
2378                                             router->backup_replace_ip, 0)) {
2379           SILC_LOG_INFO(("Will not accept connections because we do "
2380                          "not have backup router connection established"));
2381           silc_server_disconnect_remote(server, sock,
2382                                         SILC_STATUS_ERR_PERM_DENIED,
2383                                         "We do not have connection to backup "
2384                                         "router established, try later");
2385           silc_server_config_unref(&entry->cconfig);
2386           silc_server_config_unref(&entry->sconfig);
2387           silc_server_config_unref(&entry->rconfig);
2388           silc_server_free_sock_user_data(server, sock, NULL);
2389           server->stat.auth_failures++;
2390
2391           /* From here on, wait 20 seconds for the backup router to appear. */
2392           silc_schedule_task_add_timeout(server->schedule,
2393                                          silc_server_backup_router_wait,
2394                                          (void *)server, 20, 0);
2395           goto out;
2396         }
2397       }
2398
2399       SILC_LOG_DEBUG(("Remote host is %s",
2400                       entry->conn_type == SILC_CONN_SERVER ?
2401                       "server" : (backup_router ?
2402                                   "backup router" : "router")));
2403       SILC_LOG_INFO(("Connection %s (%s) is %s", entry->hostname,
2404                      entry->ip, entry->conn_type == SILC_CONN_SERVER ?
2405                      "server" : (backup_router ?
2406                                  "backup router" : "router")));
2407
2408       /* Add the server into server cache. The server name and Server ID
2409          is updated after we have received NEW_SERVER packet from the
2410          server. We mark ourselves as router for this server if we really
2411          are router. */
2412       new_server =
2413         silc_idlist_add_server((entry->conn_type == SILC_CONN_SERVER ?
2414                                 server->local_list : (backup_router ?
2415                                                       server->local_list :
2416                                                       server->global_list)),
2417                                NULL,
2418                                (entry->conn_type == SILC_CONN_SERVER ?
2419                                 SILC_SERVER : SILC_ROUTER),
2420                                NULL,
2421                                (entry->conn_type == SILC_CONN_SERVER ?
2422                                 server->id_entry : (backup_router ?
2423                                                     server->id_entry : NULL)),
2424                                sock);
2425       if (!new_server) {
2426         SILC_LOG_ERROR(("Could not add new server to cache"));
2427         silc_server_disconnect_remote(server, sock,
2428                                       SILC_STATUS_ERR_AUTH_FAILED, NULL);
2429         silc_server_config_unref(&entry->cconfig);
2430         silc_server_config_unref(&entry->sconfig);
2431         silc_server_config_unref(&entry->rconfig);
2432         silc_server_free_sock_user_data(server, sock, NULL);
2433         server->stat.auth_failures++;
2434         goto out;
2435       }
2436       entry->data.status |= SILC_IDLIST_STATUS_LOCAL;
2437       entry->data.conn_type = entry->conn_type;
2438
2439       id_entry = (void *)new_server;
2440
2441       /* If the incoming connection is router and marked as backup router
2442          then add it to be one of our backups */
2443       if (entry->data.conn_type == SILC_CONN_ROUTER && backup_router) {
2444         /* Change it back to SERVER type since that's what it really is. */
2445         if (backup_local)
2446           entry->data.conn_type = SILC_CONN_SERVER;
2447         new_server->server_type = SILC_BACKUP_ROUTER;
2448
2449         SILC_SERVER_SEND_OPERS(server, FALSE, TRUE, SILC_NOTIFY_TYPE_NONE,
2450                                ("Backup router %s is now online",
2451                                 entry->hostname));
2452
2453         /* Remove the backup waiting with timeout */
2454         silc_schedule_task_add_timeout(server->schedule,
2455                                        silc_server_backup_router_wait,
2456                                        (void *)server, 10, 0);
2457       }
2458
2459       /* Statistics */
2460       if (entry->data.conn_type == SILC_CONN_SERVER) {
2461         server->stat.my_servers++;
2462         server->stat.servers++;
2463         SILC_LOG_DEBUG(("my_servers %d", server->stat.my_servers));
2464       } else {
2465         server->stat.my_routers++;
2466         server->stat.routers++;
2467         SILC_LOG_DEBUG(("my_routers %d", server->stat.my_routers));
2468       }
2469
2470       /* Check whether this connection is to be our primary router connection
2471          if we do not already have the primary route. */
2472       if (!backup_router &&
2473           server->standalone && entry->data.conn_type == SILC_CONN_ROUTER) {
2474         if (silc_server_config_is_primary_route(server) && !initiator)
2475           break;
2476
2477         SILC_LOG_DEBUG(("We are not standalone server anymore"));
2478         server->standalone = FALSE;
2479         if (!server->id_entry->router) {
2480           server->id_entry->router = id_entry;
2481           server->router = id_entry;
2482         }
2483       }
2484
2485       break;
2486     }
2487
2488   default:
2489     goto out;
2490     break;
2491   }
2492
2493   /* Add connection to server->conns so that we know we have connection
2494      to this peer. */
2495   sconn = silc_calloc(1, sizeof(*sconn));
2496   sconn->server = server;
2497   sconn->sock = sock;
2498   sconn->remote_host = strdup(hostname);
2499   sconn->remote_port = port;
2500   silc_dlist_add(server->conns, sconn);
2501   idata->sconn = sconn;
2502   idata->last_receive = time(NULL);
2503
2504   /* Add the common data structure to the ID entry. */
2505   silc_idlist_add_data(id_entry, (SilcIDListData)entry);
2506   silc_packet_set_context(sock, id_entry);
2507
2508   /* Connection has been fully established now. Everything is ok. */
2509   SILC_LOG_DEBUG(("New connection %p authenticated", sconn));
2510
2511   /* Perform Quality of Service */
2512   if (param->qos)
2513     silc_socket_stream_set_qos(silc_packet_stream_get_stream(sock),
2514                                param->qos_rate_limit, param->qos_bytes_limit,
2515                                param->qos_limit_sec, param->qos_limit_usec);
2516
2517   silc_server_config_unref(&entry->cconfig);
2518   silc_server_config_unref(&entry->sconfig);
2519   silc_server_config_unref(&entry->rconfig);
2520   silc_free(entry);
2521
2522  out:
2523   silc_ske_free(silc_connauth_get_ske(connauth));
2524   silc_connauth_free(connauth);
2525 }
2526
2527 /* SKE completion callback.  We set the new keys into use here. */
2528
2529 static void
2530 silc_server_accept_completed(SilcSKE ske, SilcSKEStatus status,
2531                              SilcSKESecurityProperties prop,
2532                              SilcSKEKeyMaterial keymat,
2533                              SilcSKERekeyMaterial rekey,
2534                              void *context)
2535 {
2536   SilcPacketStream sock = context;
2537   SilcUnknownEntry entry = silc_packet_get_context(sock);
2538   SilcIDListData idata = (SilcIDListData)entry;
2539   SilcServer server = entry->server;
2540   SilcConnAuth connauth;
2541   SilcCipher send_key, receive_key;
2542   SilcHmac hmac_send, hmac_receive;
2543   SilcHash hash;
2544   unsigned char *pk;
2545   SilcUInt32 pk_len;
2546
2547   entry->op = NULL;
2548
2549   if (status != SILC_SKE_STATUS_OK) {
2550     /* SKE failed */
2551     SILC_LOG_ERROR(("Error (%s) during Key Exchange protocol with %s (%s)",
2552                     silc_ske_map_status(status), entry->hostname, entry->ip));
2553     silc_ske_free(ske);
2554     silc_server_disconnect_remote(server, sock,
2555                                   SILC_STATUS_ERR_KEY_EXCHANGE_FAILED, NULL);
2556     silc_server_config_unref(&entry->cconfig);
2557     silc_server_config_unref(&entry->sconfig);
2558     silc_server_config_unref(&entry->rconfig);
2559     silc_server_free_sock_user_data(server, sock, NULL);
2560     return;
2561   }
2562
2563   SILC_LOG_DEBUG(("Setting keys into use"));
2564
2565   /* Set the keys into use.  The data will be encrypted after this. */
2566   if (!silc_ske_set_keys(ske, keymat, prop, &send_key, &receive_key,
2567                          &hmac_send, &hmac_receive, &hash)) {
2568     /* Error setting keys */
2569     silc_ske_free(ske);
2570     silc_server_disconnect_remote(server, sock,
2571                                   SILC_STATUS_ERR_KEY_EXCHANGE_FAILED, NULL);
2572     silc_server_free_sock_user_data(server, sock, NULL);
2573     return;
2574   }
2575   silc_packet_set_keys(sock, send_key, receive_key, hmac_send,
2576                        hmac_receive, FALSE);
2577
2578   idata->rekey = rekey;
2579   idata->public_key = silc_pkcs_public_key_copy(prop->public_key);
2580   pk = silc_pkcs_public_key_encode(idata->public_key, &pk_len);
2581   silc_hash_make(server->sha1hash, pk, pk_len, idata->fingerprint);
2582
2583   silc_hash_alloc(silc_hash_get_name(prop->hash), &idata->hash);
2584
2585   SILC_LOG_DEBUG(("Starting connection authentication"));
2586   server->stat.auth_attempts++;
2587
2588   connauth = silc_connauth_alloc(server->schedule, ske,
2589                                  server->config->conn_auth_timeout);
2590   if (!connauth) {
2591     /** Error allocating auth protocol */
2592     silc_ske_free(ske);
2593     silc_server_disconnect_remote(server, sock,
2594                                   SILC_STATUS_ERR_RESOURCE_LIMIT, NULL);
2595     silc_server_config_unref(&entry->cconfig);
2596     silc_server_config_unref(&entry->sconfig);
2597     silc_server_config_unref(&entry->rconfig);
2598     silc_server_free_sock_user_data(server, sock, NULL);
2599     return;
2600   }
2601
2602   /* Start connection authentication */
2603   entry->op =
2604     silc_connauth_responder(connauth, silc_server_accept_get_auth,
2605                             silc_server_accept_auth_compl, sock);
2606 }
2607
2608 /* Accept new TCP connection */
2609
2610 static void silc_server_accept_new_connection(SilcNetStatus status,
2611                                               SilcStream stream,
2612                                               void *context)
2613 {
2614   SilcServer server = context;
2615   SilcPacketStream packet_stream;
2616   SilcServerConfigClient *cconfig = NULL;
2617   SilcServerConfigServer *sconfig = NULL;
2618   SilcServerConfigRouter *rconfig = NULL;
2619   SilcServerConfigDeny *deny;
2620   SilcUnknownEntry entry;
2621   SilcSKE ske;
2622   SilcSKEParamsStruct params;
2623   char *hostname, *ip;
2624   SilcUInt16 port;
2625
2626   SILC_LOG_DEBUG(("Accepting new connection"));
2627
2628   /* Check for maximum allowed connections */
2629   server->stat.conn_attempts++;
2630   if (silc_dlist_count(server->conns) >
2631       server->config->param.connections_max) {
2632     SILC_LOG_ERROR(("Refusing connection, server is full"));
2633     server->stat.conn_failures++;
2634     silc_stream_destroy(stream);
2635     return;
2636   }
2637
2638   /* Get hostname, IP and port */
2639   if (!silc_socket_stream_get_info(stream, NULL, (const char **)&hostname,
2640                                    (const char **)&ip, &port)) {
2641     /* Bad socket stream */
2642     server->stat.conn_failures++;
2643     silc_stream_destroy(stream);
2644     return;
2645   }
2646
2647   /* Create packet stream */
2648   packet_stream = silc_packet_stream_create(server->packet_engine,
2649                                             server->schedule, stream);
2650   if (!packet_stream) {
2651     SILC_LOG_ERROR(("Refusing connection, cannot create packet stream"));
2652     server->stat.conn_failures++;
2653     silc_stream_destroy(stream);
2654     return;
2655   }
2656   server->stat.conn_num++;
2657
2658   SILC_LOG_DEBUG(("Created packet stream %p", packet_stream));
2659
2660   /* Set source ID to packet stream */
2661   if (!silc_packet_set_ids(packet_stream, SILC_ID_SERVER, server->id,
2662                            0, NULL)) {
2663     /* Out of memory */
2664     server->stat.conn_failures++;
2665     silc_packet_stream_destroy(packet_stream);
2666     return;
2667   }
2668
2669   /* Check whether this connection is denied to connect to us. */
2670   deny = silc_server_config_find_denied(server, ip);
2671   if (!deny)
2672     deny = silc_server_config_find_denied(server, hostname);
2673   if (deny) {
2674     /* The connection is denied */
2675     SILC_LOG_INFO(("Connection %s (%s) is denied", hostname, ip));
2676     silc_server_disconnect_remote(server, packet_stream,
2677                                   SILC_STATUS_ERR_BANNED_FROM_SERVER,
2678                                   deny->reason);
2679     silc_server_free_sock_user_data(server, packet_stream, NULL);
2680     return;
2681   }
2682
2683   /* Check whether we have configured this sort of connection at all. We
2684      have to check all configurations since we don't know what type of
2685      connection this is. */
2686   if (!(cconfig = silc_server_config_find_client(server, ip)))
2687     cconfig = silc_server_config_find_client(server, hostname);
2688   if (!(sconfig = silc_server_config_find_server_conn(server, ip)))
2689     sconfig = silc_server_config_find_server_conn(server, hostname);
2690   if (server->server_type == SILC_ROUTER)
2691     if (!(rconfig = silc_server_config_find_router_conn(server, ip, port)))
2692       rconfig = silc_server_config_find_router_conn(server, hostname, port);
2693   if (!cconfig && !sconfig && !rconfig) {
2694     SILC_LOG_INFO(("Connection %s (%s) is not allowed", hostname, ip));
2695     server->stat.conn_failures++;
2696     silc_server_disconnect_remote(server, packet_stream,
2697                                   SILC_STATUS_ERR_BANNED_FROM_SERVER, NULL);
2698     silc_server_free_sock_user_data(server, packet_stream, NULL);
2699     return;
2700   }
2701
2702   /* The connection is allowed */
2703   entry = silc_calloc(1, sizeof(*entry));
2704   if (!entry) {
2705     server->stat.conn_failures++;
2706     silc_server_disconnect_remote(server, packet_stream,
2707                                   SILC_STATUS_ERR_RESOURCE_LIMIT, NULL);
2708     silc_server_free_sock_user_data(server, packet_stream, NULL);
2709     return;
2710   }
2711   entry->hostname = hostname;
2712   entry->ip = ip;
2713   entry->port = port;
2714   entry->server = server;
2715   entry->data.conn_type = SILC_CONN_UNKNOWN;
2716   silc_packet_set_context(packet_stream, entry);
2717
2718   SILC_LOG_DEBUG(("Created unknown connection %p", entry));
2719
2720   silc_server_config_ref(&entry->cconfig, server->config, cconfig);
2721   silc_server_config_ref(&entry->sconfig, server->config, sconfig);
2722   silc_server_config_ref(&entry->rconfig, server->config, rconfig);
2723
2724   /* Take flags for key exchange. Since we do not know what type of connection
2725      this is, we go through all found configurations and use the global ones
2726      as well. This will result always into strictest key exchange flags. */
2727   memset(&params, 0, sizeof(params));
2728   SILC_GET_SKE_FLAGS(cconfig, params.flags);
2729   SILC_GET_SKE_FLAGS(sconfig, params.flags);
2730   SILC_GET_SKE_FLAGS(rconfig, params.flags);
2731   if (server->config->param.key_exchange_pfs)
2732     params.flags |= SILC_SKE_SP_FLAG_PFS;
2733
2734   SILC_LOG_INFO(("Incoming connection %s (%s)", hostname, ip));
2735   server->stat.conn_attempts++;
2736
2737   /* Start SILC Key Exchange protocol */
2738   SILC_LOG_DEBUG(("Starting key exchange protocol"));
2739   ske = silc_ske_alloc(server->rng, server->schedule, server->repository,
2740                        server->public_key, server->private_key,
2741                        packet_stream);
2742   if (!ske) {
2743     server->stat.conn_failures++;
2744     silc_server_disconnect_remote(server, packet_stream,
2745                                   SILC_STATUS_ERR_RESOURCE_LIMIT, NULL);
2746     silc_server_free_sock_user_data(server, packet_stream, NULL);
2747     return;
2748   }
2749   silc_ske_set_callbacks(ske, silc_server_verify_key,
2750                          silc_server_accept_completed, packet_stream);
2751
2752   /* Start key exchange protocol */
2753   params.version = silc_version_string;
2754   params.timeout_secs = server->config->key_exchange_timeout;
2755   entry->op = silc_ske_responder(ske, packet_stream, &params);
2756 }
2757
2758
2759 /********************************** Rekey ***********************************/
2760
2761 /* Initiator rekey completion callback */
2762
2763 static void silc_server_rekey_completion(SilcSKE ske,
2764                                          SilcSKEStatus status,
2765                                          const SilcSKESecurityProperties prop,
2766                                          const SilcSKEKeyMaterial keymat,
2767                                          SilcSKERekeyMaterial rekey,
2768                                          void *context)
2769 {
2770   SilcPacketStream sock = context;
2771   SilcIDListData idata = silc_packet_get_context(sock);
2772   SilcServer server = idata->sconn->server;
2773
2774   idata->sconn->op = NULL;
2775   if (status != SILC_SKE_STATUS_OK) {
2776     SILC_LOG_ERROR(("Error during rekey protocol with %s",
2777                     idata->sconn->remote_host));
2778     return;
2779   }
2780
2781   SILC_LOG_DEBUG(("Rekey protocol completed with %s:%d [%s]",
2782                   idata->sconn->remote_host, idata->sconn->remote_port,
2783                   SILC_CONNTYPE_STRING(idata->conn_type)));
2784
2785   /* Save rekey data for next rekey */
2786   idata->rekey = rekey;
2787
2788   /* Register new rekey timeout */
2789   silc_schedule_task_add_timeout(server->schedule, silc_server_do_rekey,
2790                                  sock, idata->sconn->rekey_timeout, 0);
2791 }
2792
2793 /* Rekey callback.  Start rekey as initiator */
2794
2795 SILC_TASK_CALLBACK(silc_server_do_rekey)
2796 {
2797   SilcServer server = app_context;
2798   SilcPacketStream sock = context;
2799   SilcIDListData idata = silc_packet_get_context(sock);
2800   SilcSKE ske;
2801
2802   SILC_LOG_DEBUG(("Perform rekey, sock %p", sock));
2803
2804   /* Do not execute rekey with disabled connections */
2805   if (idata->status & SILC_IDLIST_STATUS_DISABLED)
2806     return;
2807
2808   /* If another protocol is active do not start rekey */
2809   if (idata->sconn->op) {
2810     SILC_LOG_DEBUG(("Waiting for other protocol to finish before rekeying"));
2811     silc_schedule_task_add_timeout(server->schedule, silc_server_do_rekey,
2812                                    sock, 60, 0);
2813     return;
2814   }
2815
2816   SILC_LOG_DEBUG(("Executing rekey protocol with %s:%d [%s]",
2817                   idata->sconn->remote_host, idata->sconn->remote_port,
2818                   SILC_CONNTYPE_STRING(idata->conn_type)));
2819
2820   /* Allocate SKE */
2821   ske = silc_ske_alloc(server->rng, server->schedule, NULL,
2822                        server->public_key, NULL, sock);
2823   if (!ske)
2824     return;
2825
2826   /* Set SKE callbacks */
2827   silc_ske_set_callbacks(ske, NULL, silc_server_rekey_completion, sock);
2828
2829   /* Perform rekey */
2830   idata->sconn->op = silc_ske_rekey_initiator(ske, sock, idata->rekey);
2831 }
2832
2833 /* Responder rekey completion callback */
2834
2835 static void
2836 silc_server_rekey_resp_completion(SilcSKE ske,
2837                                   SilcSKEStatus status,
2838                                   const SilcSKESecurityProperties prop,
2839                                   const SilcSKEKeyMaterial keymat,
2840                                   SilcSKERekeyMaterial rekey,
2841                                   void *context)
2842 {
2843   SilcPacketStream sock = context;
2844   SilcIDListData idata = silc_packet_get_context(sock);
2845
2846   idata->sconn->op = NULL;
2847   if (status != SILC_SKE_STATUS_OK) {
2848     SILC_LOG_ERROR(("Error during rekey protocol with %s",
2849                     idata->sconn->remote_host));
2850     return;
2851   }
2852
2853   SILC_LOG_DEBUG(("Rekey protocol completed with %s:%d [%s]",
2854                   idata->sconn->remote_host, idata->sconn->remote_port,
2855                   SILC_CONNTYPE_STRING(idata->conn_type)));
2856
2857   /* Save rekey data for next rekey */
2858   idata->rekey = rekey;
2859 }
2860
2861 /* Start rekey as responder */
2862
2863 static void silc_server_rekey(SilcServer server, SilcPacketStream sock,
2864                               SilcPacket packet)
2865 {
2866   SilcIDListData idata = silc_packet_get_context(sock);
2867   SilcSKE ske;
2868
2869   SILC_LOG_DEBUG(("Executing rekey protocol with %s:%d [%s], sock %p",
2870                   idata->sconn->remote_host, idata->sconn->remote_port,
2871                   SILC_CONNTYPE_STRING(idata->conn_type), sock));
2872
2873   /* Allocate SKE */
2874   ske = silc_ske_alloc(server->rng, server->schedule, NULL,
2875                        server->public_key, NULL, sock);
2876   if (!ske) {
2877     silc_packet_free(packet);
2878     return;
2879   }
2880
2881   /* Set SKE callbacks */
2882   silc_ske_set_callbacks(ske, NULL, silc_server_rekey_resp_completion, sock);
2883
2884   /* Perform rekey */
2885   idata->sconn->op = silc_ske_rekey_responder(ske, sock, idata->rekey,
2886                                               packet);
2887 }
2888
2889
2890 /****************************** Disconnection *******************************/
2891
2892 /* Destroys packet stream. */
2893
2894 SILC_TASK_CALLBACK(silc_server_close_connection_final)
2895 {
2896   silc_packet_stream_unref(context);
2897 }
2898
2899 /* Closes connection to socket connection */
2900
2901 void silc_server_close_connection(SilcServer server,
2902                                   SilcPacketStream sock)
2903 {
2904   SilcIDListData idata = silc_packet_get_context(sock);
2905   char tmp[128];
2906   const char *hostname;
2907   SilcUInt16 port;
2908
2909   if (!silc_packet_stream_is_valid(sock))
2910     return;
2911
2912   memset(tmp, 0, sizeof(tmp));
2913   //  silc_socket_get_error(sock, tmp, sizeof(tmp));
2914   silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
2915                               NULL, &hostname, NULL, &port);
2916   SILC_LOG_INFO(("Closing connection %s:%d [%s] %s", hostname, port,
2917                  idata ? SILC_CONNTYPE_STRING(idata->conn_type) : "",
2918                  tmp[0] ? tmp : ""));
2919
2920   //  silc_socket_set_qos(sock, 0, 0, 0, 0, NULL);
2921
2922   if (idata && idata->sconn) {
2923     silc_server_connection_free(idata->sconn);
2924     idata->sconn = NULL;
2925   }
2926
2927   /* Take a reference and then destroy the stream.  The last reference
2928      is released later in a timeout callback. */
2929   silc_packet_stream_ref(sock);
2930   silc_packet_stream_destroy(sock);
2931
2932   /* Close connection with timeout */
2933   server->stat.conn_num--;
2934   silc_schedule_task_del_by_all(server->schedule, 0,
2935                                 silc_server_close_connection_final, sock);
2936   silc_schedule_task_add_timeout(server->schedule,
2937                                  silc_server_close_connection_final,
2938                                  sock, 0, 1);
2939 }
2940
2941 /* Sends disconnect message to remote connection and disconnects the
2942    connection. */
2943
2944 void silc_server_disconnect_remote(SilcServer server,
2945                                    SilcPacketStream sock,
2946                                    SilcStatus status, ...)
2947 {
2948   unsigned char buf[512];
2949   va_list ap;
2950   char *cp;
2951
2952   if (!sock)
2953     return;
2954
2955   SILC_LOG_DEBUG(("Disconnecting remote host, sock %p", sock));
2956
2957   va_start(ap, status);
2958   cp = va_arg(ap, char *);
2959   if (cp)
2960     silc_vsnprintf(buf, sizeof(buf), cp, ap);
2961   va_end(ap);
2962
2963   /* Send SILC_PACKET_DISCONNECT */
2964   silc_packet_send_va(sock, SILC_PACKET_DISCONNECT, 0,
2965                       SILC_STR_UI_CHAR(status),
2966                       SILC_STR_UI8_STRING(cp ? buf : NULL),
2967                       SILC_STR_END);
2968
2969   /* Close connection */
2970   silc_server_close_connection(server, sock);
2971 }
2972
2973 /* Frees client data and notifies about client's signoff. */
2974
2975 void silc_server_free_client_data(SilcServer server,
2976                                   SilcPacketStream sock,
2977                                   SilcClientEntry client,
2978                                   int notify,
2979                                   const char *signoff)
2980 {
2981   SILC_LOG_DEBUG(("Freeing client %p data", client));
2982
2983   if (client->id) {
2984     /* Check if anyone is watching this nickname */
2985     if (server->server_type == SILC_ROUTER)
2986       silc_server_check_watcher_list(server, client, NULL,
2987                                      SILC_NOTIFY_TYPE_SIGNOFF);
2988
2989     /* Send SIGNOFF notify to routers. */
2990     if (notify)
2991       silc_server_send_notify_signoff(server, SILC_PRIMARY_ROUTE(server),
2992                                       SILC_BROADCAST(server), client->id,
2993                                       signoff);
2994   }
2995
2996   /* Remove client from all channels */
2997   if (notify)
2998     silc_server_remove_from_channels(server, NULL, client,
2999                                      TRUE, (char *)signoff, TRUE, FALSE);
3000   else
3001     silc_server_remove_from_channels(server, NULL, client,
3002                                      FALSE, NULL, FALSE, FALSE);
3003
3004   /* Remove this client from watcher list if it is */
3005   silc_server_del_from_watcher_list(server, client);
3006
3007   /* Remove client's public key from repository, this will free it too. */
3008   if (client->data.public_key) {
3009     silc_skr_del_public_key(server->repository, client->data.public_key,
3010                             client);
3011     client->data.public_key = NULL;
3012   }
3013
3014   /* Update statistics */
3015   server->stat.my_clients--;
3016   server->stat.clients--;
3017   if (server->stat.cell_clients)
3018     server->stat.cell_clients--;
3019   SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
3020   SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
3021   silc_schedule_task_del_by_context(server->schedule, client);
3022
3023   if (client->data.sconn) {
3024     silc_server_connection_free(client->data.sconn);
3025     client->data.sconn = NULL;
3026   }
3027
3028   /* We will not delete the client entry right away. We will take it
3029      into history (for WHOWAS command) for 5 minutes, unless we're
3030      shutting down server. */
3031   if (!server->server_shutdown) {
3032     client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
3033     client->mode = 0;
3034     client->router = NULL;
3035     client->connection = NULL;
3036     client->data.created = silc_time();
3037     silc_dlist_del(server->expired_clients, client);
3038     silc_dlist_add(server->expired_clients, client);
3039   } else {
3040     /* Delete directly since we're shutting down server */
3041     SILC_LOG_DEBUG(("Delete client directly"));
3042     silc_idlist_del_data(client);
3043     silc_idlist_del_client(server->local_list, client);
3044   }
3045 }
3046
3047 /* Frees user_data pointer from socket connection object. This also sends
3048    appropriate notify packets to the network to inform about leaving
3049    entities. */
3050
3051 void silc_server_free_sock_user_data(SilcServer server,
3052                                      SilcPacketStream sock,
3053                                      const char *signoff_message)
3054 {
3055   SilcIDListData idata;
3056   const char *ip;
3057   SilcUInt16 port;
3058
3059   if (!sock)
3060     return;
3061
3062   SILC_LOG_DEBUG(("Start, sock %p", sock));
3063
3064   idata = silc_packet_get_context(sock);
3065   if (!idata)
3066     return;
3067
3068   silc_schedule_task_del_by_all(server->schedule, 0, silc_server_do_rekey,
3069                                 sock);
3070
3071   /* Cancel active protocols */
3072   if (idata) {
3073     if (idata->sconn && idata->sconn->op) {
3074       SILC_LOG_DEBUG(("Abort active protocol"));
3075       silc_async_abort(idata->sconn->op, NULL, NULL);
3076     }
3077     if (idata->conn_type == SILC_CONN_UNKNOWN &&
3078         ((SilcUnknownEntry)idata)->op) {
3079       SILC_LOG_DEBUG(("Abort active protocol"));
3080       silc_async_abort(((SilcUnknownEntry)idata)->op, NULL, NULL);
3081     }
3082   }
3083
3084   switch (idata->conn_type) {
3085   case SILC_CONN_CLIENT:
3086     {
3087       SilcClientEntry client_entry = (SilcClientEntry)idata;
3088       silc_server_free_client_data(server, sock, client_entry, TRUE,
3089                                    signoff_message);
3090       silc_packet_set_context(sock, NULL);
3091       break;
3092     }
3093
3094   case SILC_CONN_SERVER:
3095   case SILC_CONN_ROUTER:
3096     {
3097       SilcServerEntry user_data = (SilcServerEntry)idata;
3098       SilcServerEntry backup_router = NULL;
3099
3100       SILC_LOG_DEBUG(("Freeing server %p data", user_data));
3101
3102       if (user_data->id)
3103         backup_router = silc_server_backup_get(server, user_data->id);
3104
3105       if (!server->backup_router && server->server_type == SILC_ROUTER &&
3106           backup_router == server->id_entry &&
3107           idata->conn_type != SILC_CONN_ROUTER)
3108         backup_router = NULL;
3109
3110       if (server->server_shutdown || server->backup_noswitch)
3111         backup_router = NULL;
3112
3113       silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
3114                                   NULL, NULL, &ip, &port);
3115
3116       /* If this was our primary router connection then we're lost to
3117          the outside world. */
3118       if (server->router == user_data) {
3119         /* Check whether we have a backup router connection */
3120         if (!backup_router || backup_router == user_data) {
3121           if (!server->no_reconnect)
3122             silc_server_create_connections(server);
3123           server->id_entry->router = NULL;
3124           server->router = NULL;
3125           server->standalone = TRUE;
3126           server->backup_primary = FALSE;
3127           backup_router = NULL;
3128         } else {
3129           if (server->id_entry != backup_router) {
3130             SILC_LOG_INFO(("New primary router is backup router %s",
3131                            backup_router->server_name));
3132             server->id_entry->router = backup_router;
3133             server->router = backup_router;
3134             server->router_connect = time(0);
3135             server->backup_primary = TRUE;
3136             backup_router->data.status &= ~SILC_IDLIST_STATUS_DISABLED;
3137
3138             /* Send START_USE to backup router to indicate we have switched */
3139             silc_server_backup_send_start_use(server,
3140                                               backup_router->connection,
3141                                               FALSE);
3142           } else {
3143             SILC_LOG_INFO(("We are now new primary router in this cell"));
3144             server->id_entry->router = NULL;
3145             server->router = NULL;
3146             server->standalone = TRUE;
3147           }
3148
3149           /* We stop here to take a breath */
3150           sleep(2);
3151
3152           if (server->backup_router) {
3153             server->server_type = SILC_ROUTER;
3154
3155             /* We'll need to constantly try to reconnect to the primary
3156                router so that we'll see when it comes back online. */
3157             silc_server_create_connection(server, FALSE, FALSE, ip, port,
3158                                          silc_server_backup_connected,
3159                                          NULL);
3160           }
3161
3162           /* Mark this connection as replaced */
3163           silc_server_backup_replaced_add(server, user_data->id,
3164                                           backup_router);
3165         }
3166       } else if (backup_router) {
3167         SILC_LOG_INFO(("Enabling the use of backup router %s",
3168                        backup_router->server_name));
3169
3170         /* Mark this connection as replaced */
3171         silc_server_backup_replaced_add(server, user_data->id,
3172                                         backup_router);
3173       } else if (server->server_type == SILC_SERVER &&
3174                  idata->conn_type == SILC_CONN_ROUTER) {
3175         /* Reconnect to the router (backup) */
3176         if (!server->no_reconnect)
3177           silc_server_create_connections(server);
3178       }
3179
3180       if (user_data->server_name)
3181         SILC_SERVER_SEND_OPERS(server, FALSE, TRUE, SILC_NOTIFY_TYPE_NONE,
3182                                ("Server %s signoff", user_data->server_name));
3183
3184       if (!backup_router) {
3185         /* Remove all servers that are originated from this server, and
3186            remove the clients of those servers too. */
3187         silc_server_remove_servers_by_server(server, user_data, TRUE);
3188
3189 #if 0
3190         /* Remove the clients that this server owns as they will become
3191            invalid now too.  For backup router the server is actually
3192            coming from the primary router, so mark that as the owner
3193            of this entry. */
3194         if (server->server_type == SILC_BACKUP_ROUTER &&
3195             sock->type == SILC_CONN_SERVER)
3196           silc_server_remove_clients_by_server(server, server->router,
3197                                                user_data, TRUE);
3198         else
3199 #endif
3200           silc_server_remove_clients_by_server(server, user_data,
3201                                                user_data, TRUE);
3202
3203         /* Remove channels owned by this server */
3204         if (server->server_type == SILC_SERVER)
3205           silc_server_remove_channels_by_server(server, user_data);
3206       } else {
3207         /* Enable local server connections that may be disabled */
3208         silc_server_local_servers_toggle_enabled(server, TRUE);
3209
3210         /* Update the client entries of this server to the new backup
3211            router.  If we are the backup router we also resolve the real
3212            servers for the clients.  After updating is over this also
3213            removes the clients that this server explicitly owns. */
3214         silc_server_update_clients_by_server(server, user_data,
3215                                              backup_router, TRUE);
3216
3217         /* If we are router and just lost our primary router (now standlaone)
3218            we remove everything that was behind it, since we don't know
3219            any better. */
3220         if (server->server_type == SILC_ROUTER && server->standalone)
3221           /* Remove all servers that are originated from this server, and
3222              remove the clients of those servers too. */
3223           silc_server_remove_servers_by_server(server, user_data, TRUE);
3224
3225         /* Finally remove the clients that are explicitly owned by this
3226            server.  They go down with the server. */
3227         silc_server_remove_clients_by_server(server, user_data,
3228                                              user_data, TRUE);
3229
3230         /* Update our server cache to use the new backup router too. */
3231         silc_server_update_servers_by_server(server, user_data, backup_router);
3232         if (server->server_type == SILC_SERVER)
3233           silc_server_update_channels_by_server(server, user_data,
3234                                                 backup_router);
3235
3236         /* Send notify about primary router going down to local operators */
3237         if (server->backup_router)
3238           SILC_SERVER_SEND_OPERS(server, FALSE, TRUE,
3239                                  SILC_NOTIFY_TYPE_NONE,
3240                                  ("%s switched to backup router %s "
3241                                   "(we are primary router now)",
3242                                   server->server_name, server->server_name));
3243         else if (server->router)
3244           SILC_SERVER_SEND_OPERS(server, FALSE, TRUE,
3245                                  SILC_NOTIFY_TYPE_NONE,
3246                                  ("%s switched to backup router %s",
3247                                   server->server_name,
3248                                   server->router->server_name));
3249       }
3250       server->backup_noswitch = FALSE;
3251
3252       if (idata->sconn) {
3253         silc_server_connection_free(idata->sconn);
3254         idata->sconn = NULL;
3255       }
3256
3257       /* Statistics */
3258       if (idata->conn_type == SILC_CONN_SERVER) {
3259         server->stat.my_servers--;
3260         server->stat.servers--;
3261         SILC_LOG_DEBUG(("my_servers %d", server->stat.my_servers));
3262       } else if (idata->conn_type == SILC_CONN_ROUTER) {
3263         server->stat.my_routers--;
3264         server->stat.routers--;
3265         SILC_LOG_DEBUG(("my_routers %d", server->stat.my_routers));
3266       }
3267       if (server->server_type == SILC_ROUTER)
3268         server->stat.cell_servers--;
3269
3270       /* Free the server entry */
3271       silc_server_backup_del(server, user_data);
3272       silc_server_backup_replaced_del(server, user_data);
3273       silc_idlist_del_data(user_data);
3274       if (!silc_idlist_del_server(server->local_list, user_data))
3275         silc_idlist_del_server(server->global_list, user_data);
3276
3277       if (backup_router && backup_router != server->id_entry) {
3278         /* Announce all of our stuff that was created about 5 minutes ago.
3279            The backup router knows all the other stuff already. */
3280         if (server->server_type == SILC_ROUTER)
3281           silc_server_announce_servers(server, FALSE, time(0) - 300,
3282                                        backup_router->connection);
3283
3284         /* Announce our clients and channels to the router */
3285         silc_server_announce_clients(server, time(0) - 300,
3286                                      backup_router->connection);
3287         silc_server_announce_channels(server, time(0) - 300,
3288                                       backup_router->connection);
3289       }
3290
3291       silc_packet_set_context(sock, NULL);
3292       break;
3293     }
3294
3295   default:
3296     {
3297       SilcUnknownEntry entry = (SilcUnknownEntry)idata;
3298
3299       SILC_LOG_DEBUG(("Freeing unknown connection data %p", entry));
3300
3301       if (idata->sconn) {
3302         if (server->router_conn == idata->sconn) {
3303           if (!server->no_reconnect)
3304             silc_server_create_connections(server);
3305           server->router_conn = NULL;
3306         }
3307
3308         silc_server_connection_free(idata->sconn);
3309         idata->sconn = NULL;
3310       }
3311       silc_idlist_del_data(idata);
3312       silc_free(entry);
3313       silc_packet_set_context(sock, NULL);
3314       break;
3315     }
3316   }
3317 }
3318
3319 /* Removes client from all channels it has joined. This is used when client
3320    connection is disconnected. If the client on a channel is last, the
3321    channel is removed as well. This sends the SIGNOFF notify types. */
3322
3323 void silc_server_remove_from_channels(SilcServer server,
3324                                       SilcPacketStream sock,
3325                                       SilcClientEntry client,
3326                                       SilcBool notify,
3327                                       const char *signoff_message,
3328                                       SilcBool keygen,
3329                                       SilcBool killed)
3330 {
3331   SilcChannelEntry channel;
3332   SilcChannelClientEntry chl;
3333   SilcHashTableList htl;
3334   SilcBuffer clidp = NULL;
3335
3336   if (!client)
3337     return;
3338
3339   if (notify && !client->id)
3340     notify = FALSE;
3341
3342   SILC_LOG_DEBUG(("Removing client %s from joined channels",
3343                   notify ? silc_id_render(client->id, SILC_ID_CLIENT) : ""));
3344
3345   if (notify) {
3346     clidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
3347     if (!clidp)
3348       notify = FALSE;
3349   }
3350
3351   /* Remove the client from all channels. The client is removed from
3352      the channels' user list. */
3353   silc_hash_table_list(client->channels, &htl);
3354   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
3355     channel = chl->channel;
3356
3357     /* Remove channel if this is last client leaving the channel, unless
3358        the channel is permanent. */
3359     if (server->server_type != SILC_SERVER &&
3360         silc_hash_table_count(channel->user_list) < 2) {
3361       silc_server_channel_delete(server, channel);
3362       continue;
3363     }
3364
3365     silc_hash_table_del(client->channels, channel);
3366     silc_hash_table_del(channel->user_list, client);
3367     channel->user_count--;
3368
3369     /* If there is no global users on the channel anymore mark the channel
3370        as local channel. Do not check if the removed client is local client. */
3371     if (server->server_type == SILC_SERVER && channel->global_users &&
3372         chl->client->router && !silc_server_channel_has_global(channel))
3373       channel->global_users = FALSE;
3374
3375     memset(chl, 'A', sizeof(*chl));
3376     silc_free(chl);
3377
3378     /* Update statistics */
3379     if (SILC_IS_LOCAL(client))
3380       server->stat.my_chanclients--;
3381     if (server->server_type == SILC_ROUTER) {
3382       server->stat.cell_chanclients--;
3383       server->stat.chanclients--;
3384     }
3385
3386     /* If there is not at least one local user on the channel then we don't
3387        need the channel entry anymore, we can remove it safely, unless the
3388        channel is permanent channel */
3389     if (server->server_type == SILC_SERVER &&
3390         !silc_server_channel_has_local(channel)) {
3391       /* Notify about leaving client if this channel has global users. */
3392       if (notify && channel->global_users)
3393         silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
3394                                            SILC_NOTIFY_TYPE_SIGNOFF,
3395                                            signoff_message ? 2 : 1,
3396                                            clidp->data, silc_buffer_len(clidp),
3397                                            signoff_message, signoff_message ?
3398                                            strlen(signoff_message) : 0);
3399
3400       silc_schedule_task_del_by_context(server->schedule, channel->rekey);
3401       silc_server_channel_delete(server, channel);
3402       continue;
3403     }
3404
3405     /* Send notify to channel about client leaving SILC and channel too */
3406     if (notify)
3407       silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
3408                                          SILC_NOTIFY_TYPE_SIGNOFF,
3409                                          signoff_message ? 2 : 1,
3410                                          clidp->data, silc_buffer_len(clidp),
3411                                          signoff_message, signoff_message ?
3412                                          strlen(signoff_message) : 0);
3413
3414     if (killed && clidp) {
3415       /* Remove the client from channel's invite list */
3416       if (channel->invite_list &&
3417           silc_hash_table_count(channel->invite_list)) {
3418         SilcBuffer ab;
3419         SilcArgumentPayload iargs;
3420         ab = silc_argument_payload_encode_one(NULL, clidp->data,
3421                                               silc_buffer_len(clidp), 3);
3422         iargs = silc_argument_payload_parse(ab->data, silc_buffer_len(ab), 1);
3423         silc_server_inviteban_process(server, channel->invite_list, 1, iargs);
3424         silc_buffer_free(ab);
3425         silc_argument_payload_free(iargs);
3426       }
3427     }
3428
3429     /* Don't create keys if we are shutting down */
3430     if (server->server_shutdown)
3431       continue;
3432
3433     /* Re-generate channel key if needed */
3434     if (keygen && !(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
3435       if (!silc_server_create_channel_key(server, channel, 0))
3436         continue;
3437
3438       /* Send the channel key to the channel. The key of course is not sent
3439          to the client who was removed from the channel. */
3440       silc_server_send_channel_key(server, client->connection, channel,
3441                                    server->server_type == SILC_ROUTER ?
3442                                    FALSE : !server->standalone);
3443     }
3444   }
3445
3446   silc_hash_table_list_reset(&htl);
3447   if (clidp)
3448     silc_buffer_free(clidp);
3449 }
3450
3451 /* Removes client from one channel. This is used for example when client
3452    calls LEAVE command to remove itself from the channel. Returns TRUE
3453    if channel still exists and FALSE if the channel is removed when
3454    last client leaves the channel. If `notify' is FALSE notify messages
3455    are not sent. */
3456
3457 SilcBool silc_server_remove_from_one_channel(SilcServer server,
3458                                          SilcPacketStream sock,
3459                                          SilcChannelEntry channel,
3460                                          SilcClientEntry client,
3461                                          SilcBool notify)
3462 {
3463   SilcChannelClientEntry chl;
3464   SilcBuffer clidp;
3465
3466   SILC_LOG_DEBUG(("Removing %s from channel %s",
3467                   silc_id_render(client->id, SILC_ID_CLIENT),
3468                   channel->channel_name));
3469
3470   /* Get the entry to the channel, if this client is not on the channel
3471      then return Ok. */
3472   if (!silc_hash_table_find(client->channels, channel, NULL, (void *)&chl))
3473     return TRUE;
3474
3475   /* Remove channel if this is last client leaving the channel, unless
3476      the channel is permanent. */
3477   if (server->server_type != SILC_SERVER &&
3478       silc_hash_table_count(channel->user_list) < 2) {
3479     silc_server_channel_delete(server, channel);
3480     return FALSE;
3481   }
3482
3483   silc_hash_table_del(client->channels, channel);
3484   silc_hash_table_del(channel->user_list, client);
3485   channel->user_count--;
3486
3487   /* If there is no global users on the channel anymore mark the channel
3488      as local channel. Do not check if the client is local client. */
3489   if (server->server_type == SILC_SERVER && channel->global_users &&
3490       chl->client->router && !silc_server_channel_has_global(channel))
3491     channel->global_users = FALSE;
3492
3493   memset(chl, 'O', sizeof(*chl));
3494   silc_free(chl);
3495
3496   /* Update statistics */
3497   if (SILC_IS_LOCAL(client))
3498     server->stat.my_chanclients--;
3499   if (server->server_type == SILC_ROUTER) {
3500     server->stat.cell_chanclients--;
3501     server->stat.chanclients--;
3502   }
3503
3504   clidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
3505   if (!clidp)
3506     notify = FALSE;
3507
3508   /* If there is not at least one local user on the channel then we don't
3509      need the channel entry anymore, we can remove it safely, unless the
3510      channel is permanent channel */
3511   if (server->server_type == SILC_SERVER &&
3512       !silc_server_channel_has_local(channel)) {
3513     /* Notify about leaving client if this channel has global users. */
3514     if (notify && channel->global_users)
3515       silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
3516                                          SILC_NOTIFY_TYPE_LEAVE, 1,
3517                                          clidp->data, silc_buffer_len(clidp));
3518
3519     silc_schedule_task_del_by_context(server->schedule, channel->rekey);
3520     silc_server_channel_delete(server, channel);
3521     silc_buffer_free(clidp);
3522     return FALSE;
3523   }
3524
3525   /* Send notify to channel about client leaving the channel */
3526   if (notify)
3527     silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
3528                                        SILC_NOTIFY_TYPE_LEAVE, 1,
3529                                        clidp->data, silc_buffer_len(clidp));
3530
3531   silc_buffer_free(clidp);
3532   return TRUE;
3533 }
3534
3535 /* Creates new channel. Sends NEW_CHANNEL packet to primary route. This
3536    function may be used only by router. In real SILC network all channels
3537    are created by routers thus this function is never used by normal
3538    server. */
3539
3540 SilcChannelEntry silc_server_create_new_channel(SilcServer server,
3541                                                 SilcServerID *router_id,
3542                                                 char *cipher,
3543                                                 char *hmac,
3544                                                 char *channel_name,
3545                                                 int broadcast)
3546 {
3547   SilcChannelID *channel_id;
3548   SilcChannelEntry entry;
3549   SilcCipher send_key, receive_key;
3550   SilcHmac newhmac;
3551
3552   SILC_LOG_DEBUG(("Creating new channel %s", channel_name));
3553
3554   if (!cipher)
3555     cipher = SILC_DEFAULT_CIPHER;
3556   if (!hmac)
3557     hmac = SILC_DEFAULT_HMAC;
3558
3559   /* Allocate cipher */
3560   if (!silc_cipher_alloc(cipher, &send_key))
3561     return NULL;
3562   if (!silc_cipher_alloc(cipher, &receive_key)) {
3563     silc_cipher_free(send_key);
3564     return NULL;
3565   }
3566
3567   /* Allocate hmac */
3568   if (!silc_hmac_alloc(hmac, NULL, &newhmac)) {
3569     silc_cipher_free(send_key);
3570     silc_cipher_free(receive_key);
3571     return NULL;
3572   }
3573
3574   channel_name = strdup(channel_name);
3575
3576   /* Create the channel ID */
3577   if (!silc_id_create_channel_id(server, router_id, server->rng,
3578                                  &channel_id)) {
3579     silc_free(channel_name);
3580     silc_cipher_free(send_key);
3581     silc_cipher_free(receive_key);
3582     silc_hmac_free(newhmac);
3583     return NULL;
3584   }
3585
3586   /* Create the channel */
3587   entry = silc_idlist_add_channel(server->local_list, channel_name,
3588                                   SILC_CHANNEL_MODE_NONE, channel_id,
3589                                   NULL, send_key, receive_key, newhmac);
3590   if (!entry) {
3591     silc_free(channel_name);
3592     silc_cipher_free(send_key);
3593     silc_cipher_free(receive_key);
3594     silc_hmac_free(newhmac);
3595     silc_free(channel_id);
3596     return NULL;
3597   }
3598
3599   entry->cipher = strdup(cipher);
3600   entry->hmac_name = strdup(hmac);
3601
3602   /* Now create the actual key material */
3603   if (!silc_server_create_channel_key(server, entry,
3604                                       silc_cipher_get_key_len(send_key) / 8)) {
3605     silc_idlist_del_channel(server->local_list, entry);
3606     return NULL;
3607   }
3608
3609   /* Notify other routers about the new channel. We send the packet
3610      to our primary route. */
3611   if (broadcast)
3612     silc_server_send_new_channel(server, SILC_PRIMARY_ROUTE(server), TRUE,
3613                                  channel_name, entry->id,
3614                                  silc_id_get_len(entry->id, SILC_ID_CHANNEL),
3615                                  entry->mode);
3616
3617   /* Distribute to backup routers */
3618   if (broadcast && server->server_type == SILC_ROUTER) {
3619     SilcBuffer packet;
3620     unsigned char cid[32];
3621     SilcUInt32 name_len = strlen(channel_name);
3622     SilcUInt32 id_len;
3623
3624     silc_id_id2str(entry->id, SILC_ID_CHANNEL, cid, sizeof(cid), &id_len);
3625     packet = silc_channel_payload_encode(channel_name, name_len,
3626                                          cid, id_len, entry->mode);
3627     silc_server_backup_send(server, NULL, SILC_PACKET_NEW_CHANNEL, 0,
3628                             packet->data, silc_buffer_len(packet), FALSE,
3629                             TRUE);
3630     silc_buffer_free(packet);
3631   }
3632
3633   server->stat.my_channels++;
3634   if (server->server_type == SILC_ROUTER) {
3635     server->stat.channels++;
3636     server->stat.cell_channels++;
3637     entry->users_resolved = TRUE;
3638   }
3639
3640   return entry;
3641 }
3642
3643 /* Same as above but creates the channel with Channel ID `channel_id. */
3644
3645 SilcChannelEntry
3646 silc_server_create_new_channel_with_id(SilcServer server,
3647                                        char *cipher,
3648                                        char *hmac,
3649                                        char *channel_name,
3650                                        SilcChannelID *channel_id,
3651                                        int broadcast)
3652 {
3653   SilcChannelEntry entry;
3654   SilcCipher send_key, receive_key;
3655   SilcHmac newhmac;
3656
3657   SILC_LOG_DEBUG(("Creating new channel %s", channel_name));
3658
3659   if (!cipher)
3660     cipher = SILC_DEFAULT_CIPHER;
3661   if (!hmac)
3662     hmac = SILC_DEFAULT_HMAC;
3663
3664   /* Allocate cipher */
3665   if (!silc_cipher_alloc(cipher, &send_key))
3666     return NULL;
3667   if (!silc_cipher_alloc(cipher, &receive_key)) {
3668     silc_cipher_free(send_key);
3669     return NULL;
3670   }
3671
3672   /* Allocate hmac */
3673   if (!silc_hmac_alloc(hmac, NULL, &newhmac)) {
3674     silc_cipher_free(send_key);
3675     silc_cipher_free(receive_key);
3676     return NULL;
3677   }
3678
3679   channel_name = strdup(channel_name);
3680
3681   /* Create the channel */
3682   entry = silc_idlist_add_channel(server->local_list, channel_name,
3683                                   SILC_CHANNEL_MODE_NONE, channel_id,
3684                                   NULL, send_key, receive_key, newhmac);
3685   if (!entry) {
3686     silc_cipher_free(send_key);
3687     silc_cipher_free(receive_key);
3688     silc_hmac_free(newhmac);
3689     silc_free(channel_name);
3690     return NULL;
3691   }
3692
3693   /* Now create the actual key material */
3694   if (!silc_server_create_channel_key(server, entry,
3695                                       silc_cipher_get_key_len(send_key) / 8)) {
3696     silc_idlist_del_channel(server->local_list, entry);
3697     return NULL;
3698   }
3699
3700   /* Notify other routers about the new channel. We send the packet
3701      to our primary route. */
3702   if (broadcast)
3703     silc_server_send_new_channel(server, SILC_PRIMARY_ROUTE(server), TRUE,
3704                                  channel_name, entry->id,
3705                                  silc_id_get_len(entry->id, SILC_ID_CHANNEL),
3706                                  entry->mode);
3707
3708   /* Distribute to backup routers */
3709   if (broadcast && server->server_type == SILC_ROUTER) {
3710     SilcBuffer packet;
3711     unsigned char cid[32];
3712     SilcUInt32 name_len = strlen(channel_name);
3713     SilcUInt32 id_len;
3714
3715     silc_id_id2str(entry->id, SILC_ID_CHANNEL, cid, sizeof(cid), &id_len);
3716     packet = silc_channel_payload_encode(channel_name, name_len,
3717                                          cid, id_len, entry->mode);
3718     silc_server_backup_send(server, NULL, SILC_PACKET_NEW_CHANNEL, 0,
3719                             packet->data, silc_buffer_len(packet), FALSE,
3720                             TRUE);
3721     silc_buffer_free(packet);
3722   }
3723
3724   server->stat.my_channels++;
3725   if (server->server_type == SILC_ROUTER) {
3726     server->stat.channels++;
3727     server->stat.cell_channels++;
3728     entry->users_resolved = TRUE;
3729   }
3730
3731   return entry;
3732 }
3733
3734 /* Channel's key re-key timeout callback. */
3735
3736 SILC_TASK_CALLBACK(silc_server_channel_key_rekey)
3737 {
3738   SilcServer server = app_context;
3739   SilcServerChannelRekey rekey = (SilcServerChannelRekey)context;
3740
3741   rekey->task = NULL;
3742
3743   /* Return now if we are shutting down */
3744   if (server->server_shutdown)
3745     return;
3746
3747   if (!silc_server_create_channel_key(server, rekey->channel, rekey->key_len))
3748     return;
3749
3750   silc_server_send_channel_key(server, NULL, rekey->channel, FALSE);
3751 }
3752
3753 /* Generates new channel key. This is used to create the initial channel key
3754    but also to re-generate new key for channel. If `key_len' is provided
3755    it is the bytes of the key length. */
3756
3757 SilcBool silc_server_create_channel_key(SilcServer server,
3758                                         SilcChannelEntry channel,
3759                                         SilcUInt32 key_len)
3760 {
3761   int i;
3762   unsigned char channel_key[32], hash[SILC_HASH_MAXLEN];
3763   SilcUInt32 len;
3764
3765   if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY) {
3766     SILC_LOG_DEBUG(("Channel has private keys, will not generate new key"));
3767     return TRUE;
3768   }
3769
3770   SILC_LOG_DEBUG(("Generating channel %s key", channel->channel_name));
3771
3772   if (!channel->send_key)
3773     if (!silc_cipher_alloc(SILC_DEFAULT_CIPHER, &channel->send_key)) {
3774       channel->send_key = NULL;
3775       return FALSE;
3776     }
3777   if (!channel->receive_key)
3778     if (!silc_cipher_alloc(SILC_DEFAULT_CIPHER, &channel->receive_key)) {
3779       silc_cipher_free(channel->send_key);
3780       channel->send_key = channel->receive_key = NULL;
3781       return FALSE;
3782     }
3783
3784   if (key_len)
3785     len = key_len;
3786   else if (channel->key_len)
3787     len = channel->key_len / 8;
3788   else
3789     len = silc_cipher_get_key_len(channel->send_key) / 8;
3790
3791   /* Create channel key */
3792   for (i = 0; i < len; i++) channel_key[i] = silc_rng_get_byte(server->rng);
3793
3794   /* Set the key */
3795   silc_cipher_set_key(channel->send_key, channel_key, len * 8, TRUE);
3796   silc_cipher_set_key(channel->receive_key, channel_key, len * 8, FALSE);
3797
3798   /* Remove old key if exists */
3799   if (channel->key) {
3800     memset(channel->key, 0, channel->key_len / 8);
3801     silc_free(channel->key);
3802   }
3803
3804   /* Save the key */
3805   channel->key_len = len * 8;
3806   channel->key = silc_memdup(channel_key, len);
3807   memset(channel_key, 0, sizeof(channel_key));
3808
3809   /* Generate HMAC key from the channel key data and set it */
3810   if (!channel->hmac)
3811     if (!silc_hmac_alloc(SILC_DEFAULT_HMAC, NULL, &channel->hmac)) {
3812       memset(channel->key, 0, channel->key_len / 8);
3813       silc_free(channel->key);
3814       silc_cipher_free(channel->send_key);
3815       silc_cipher_free(channel->receive_key);
3816       channel->send_key = channel->receive_key = NULL;
3817       return FALSE;
3818     }
3819   silc_hash_make(silc_hmac_get_hash(channel->hmac), channel->key, len, hash);
3820   silc_hmac_set_key(channel->hmac, hash,
3821                     silc_hash_len(silc_hmac_get_hash(channel->hmac)));
3822   memset(hash, 0, sizeof(hash));
3823
3824   if (server->server_type == SILC_ROUTER) {
3825     if (!channel->rekey)
3826       channel->rekey = silc_calloc(1, sizeof(*channel->rekey));
3827     channel->rekey->channel = channel;
3828     channel->rekey->key_len = key_len;
3829     if (channel->rekey->task)
3830       silc_schedule_task_del(server->schedule, channel->rekey->task);
3831
3832     channel->rekey->task =
3833       silc_schedule_task_add_timeout(server->schedule,
3834                                      silc_server_channel_key_rekey,
3835                                      (void *)channel->rekey,
3836                                      server->config->channel_rekey_secs, 0);
3837   }
3838
3839   return TRUE;
3840 }
3841
3842 /* Saves the channel key found in the encoded `key_payload' buffer. This
3843    function is used when we receive Channel Key Payload and also when we're
3844    processing JOIN command reply. Returns entry to the channel. */
3845
3846 SilcChannelEntry silc_server_save_channel_key(SilcServer server,
3847                                               SilcBuffer key_payload,
3848                                               SilcChannelEntry channel)
3849 {
3850   SilcChannelKeyPayload payload = NULL;
3851   SilcChannelID id;
3852   unsigned char *tmp, hash[SILC_HASH_MAXLEN];
3853   SilcUInt32 tmp_len;
3854   char *cipher;
3855
3856   /* Decode channel key payload */
3857   payload = silc_channel_key_payload_parse(key_payload->data,
3858                                            silc_buffer_len(key_payload));
3859   if (!payload) {
3860     SILC_LOG_ERROR(("Bad channel key payload received, dropped"));
3861     channel = NULL;
3862     goto out;
3863   }
3864
3865   /* Get the channel entry */
3866   if (!channel) {
3867
3868     /* Get channel ID */
3869     tmp = silc_channel_key_get_id(payload, &tmp_len);
3870     if (!silc_id_str2id(tmp, tmp_len, SILC_ID_CHANNEL, &id, sizeof(id))) {
3871       channel = NULL;
3872       goto out;
3873     }
3874
3875     channel = silc_idlist_find_channel_by_id(server->local_list, &id, NULL);
3876     if (!channel) {
3877       channel = silc_idlist_find_channel_by_id(server->global_list, &id, NULL);
3878       if (!channel) {
3879         if (server->server_type == SILC_ROUTER)
3880           SILC_LOG_ERROR(("Received key for non-existent channel %s",
3881                           silc_id_render(&id, SILC_ID_CHANNEL)));
3882         goto out;
3883       }
3884     }
3885   }
3886
3887   SILC_LOG_DEBUG(("Saving new channel %s key", channel->channel_name));
3888
3889   tmp = silc_channel_key_get_key(payload, &tmp_len);
3890   if (!tmp) {
3891     channel = NULL;
3892     goto out;
3893   }
3894
3895   cipher = silc_channel_key_get_cipher(payload, NULL);
3896   if (!cipher) {
3897     channel = NULL;
3898     goto out;
3899   }
3900
3901   /* Remove old key if exists */
3902   if (channel->key) {
3903     memset(channel->key, 0, channel->key_len / 8);
3904     silc_free(channel->key);
3905     silc_cipher_free(channel->send_key);
3906     silc_cipher_free(channel->receive_key);
3907   }
3908
3909   /* Create new cipher */
3910   if (!silc_cipher_alloc(cipher, &channel->send_key)) {
3911     channel->send_key = NULL;
3912     channel = NULL;
3913     goto out;
3914   }
3915   if (!silc_cipher_alloc(cipher, &channel->receive_key)) {
3916     silc_cipher_free(channel->send_key);
3917     channel->send_key = channel->receive_key = NULL;
3918     channel = NULL;
3919     goto out;
3920   }
3921
3922   if (channel->cipher)
3923     silc_free(channel->cipher);
3924   channel->cipher = strdup(cipher);
3925
3926   /* Save the key */
3927   channel->key_len = tmp_len * 8;
3928   channel->key = silc_memdup(tmp, tmp_len);
3929   silc_cipher_set_key(channel->send_key, tmp, channel->key_len, TRUE);
3930   silc_cipher_set_key(channel->receive_key, tmp, channel->key_len, FALSE);
3931
3932   /* Generate HMAC key from the channel key data and set it */
3933   if (!channel->hmac)
3934     if (!silc_hmac_alloc(SILC_DEFAULT_HMAC, NULL, &channel->hmac)) {
3935       memset(channel->key, 0, channel->key_len / 8);
3936       silc_free(channel->key);
3937       silc_cipher_free(channel->send_key);
3938       silc_cipher_free(channel->receive_key);
3939       channel->send_key = channel->receive_key = NULL;
3940       return FALSE;
3941     }
3942   silc_hash_make(silc_hmac_get_hash(channel->hmac), tmp, tmp_len, hash);
3943   silc_hmac_set_key(channel->hmac, hash,
3944                     silc_hash_len(silc_hmac_get_hash(channel->hmac)));
3945
3946   memset(hash, 0, sizeof(hash));
3947   memset(tmp, 0, tmp_len);
3948
3949   if (server->server_type == SILC_ROUTER) {
3950     if (!channel->rekey)
3951       channel->rekey = silc_calloc(1, sizeof(*channel->rekey));
3952     channel->rekey->channel = channel;
3953     if (channel->rekey->task)
3954       silc_schedule_task_del(server->schedule, channel->rekey->task);
3955
3956     channel->rekey->task =
3957       silc_schedule_task_add_timeout(server->schedule,
3958                                      silc_server_channel_key_rekey,
3959                                      (void *)channel->rekey,
3960                                      server->config->channel_rekey_secs, 0);
3961   }
3962
3963  out:
3964   if (payload)
3965     silc_channel_key_payload_free(payload);
3966
3967   return channel;
3968 }
3969
3970 /* Returns assembled of all servers in the given ID list. The packet's
3971    form is dictated by the New ID payload. */
3972
3973 static void silc_server_announce_get_servers(SilcServer server,
3974                                              SilcServerEntry remote,
3975                                              SilcIDList id_list,
3976                                              SilcBuffer *servers,
3977                                              unsigned long creation_time)
3978 {
3979   SilcList list;
3980   SilcIDCacheEntry id_cache;
3981   SilcServerEntry entry;
3982   SilcBuffer idp;
3983   void *tmp;
3984
3985   /* Go through all clients in the list */
3986   if (silc_idcache_get_all(id_list->servers, &list)) {
3987     silc_list_start(list);
3988     while ((id_cache = silc_list_get(list))) {
3989       entry = (SilcServerEntry)id_cache->context;
3990
3991       /* Do not announce the one we've sending our announcements and
3992          do not announce ourself. Also check the creation time if it's
3993          provided. */
3994       if ((entry == remote) || (entry == server->id_entry) ||
3995           (creation_time && entry->data.created < creation_time))
3996         continue;
3997
3998       idp = silc_id_payload_encode(entry->id, SILC_ID_SERVER);
3999
4000       tmp = silc_buffer_realloc(*servers,
4001                                 (*servers ?
4002                                  silc_buffer_truelen((*servers)) +
4003                                  silc_buffer_len(idp) :
4004                                  silc_buffer_len(idp)));
4005       if (!tmp)
4006         return;
4007       *servers = tmp;
4008       silc_buffer_pull_tail(*servers, ((*servers)->end - (*servers)->data));
4009       silc_buffer_put(*servers, idp->data, silc_buffer_len(idp));
4010       silc_buffer_pull(*servers, silc_buffer_len(idp));
4011       silc_buffer_free(idp);
4012     }
4013   }
4014 }
4015
4016 static SilcBuffer
4017 silc_server_announce_encode_notify(SilcNotifyType notify, SilcUInt32 argc, ...)
4018 {
4019   va_list ap;
4020   SilcBuffer p;
4021
4022   va_start(ap, argc);
4023   p = silc_notify_payload_encode(notify, argc, ap);
4024   va_end(ap);
4025
4026   return p;
4027 }
4028
4029 /* This function is used by router to announce existing servers to our
4030    primary router when we've connected to it. If `creation_time' is non-zero
4031    then only the servers that has been created after the `creation_time'
4032    will be announced. */
4033
4034 void silc_server_announce_servers(SilcServer server, SilcBool global,
4035                                   unsigned long creation_time,
4036                                   SilcPacketStream remote)
4037 {
4038   SilcBuffer servers = NULL;
4039
4040   SILC_LOG_DEBUG(("Announcing servers"));
4041
4042   /* Get servers in local list */
4043   silc_server_announce_get_servers(server, silc_packet_get_context(remote),
4044                                    server->local_list, &servers,
4045                                    creation_time);
4046
4047   if (global)
4048     /* Get servers in global list */
4049     silc_server_announce_get_servers(server, silc_packet_get_context(remote),
4050                                      server->global_list, &servers,
4051                                      creation_time);
4052
4053   if (servers) {
4054     silc_buffer_push(servers, servers->data - servers->head);
4055     SILC_LOG_HEXDUMP(("servers"), servers->data, silc_buffer_len(servers));
4056
4057     /* Send the packet */
4058     silc_server_packet_send(server, remote,
4059                             SILC_PACKET_NEW_ID, SILC_PACKET_FLAG_LIST,
4060                             servers->data, silc_buffer_len(servers));
4061
4062     silc_buffer_free(servers);
4063   }
4064 }
4065
4066 /* Returns assembled packet of all clients in the given ID list. The
4067    packet's form is dictated by the New ID Payload. */
4068
4069 static void silc_server_announce_get_clients(SilcServer server,
4070                                              SilcIDList id_list,
4071                                              SilcBuffer *clients,
4072                                              SilcBuffer *umodes,
4073                                              unsigned long creation_time)
4074 {
4075   SilcList list;
4076   SilcIDCacheEntry id_cache;
4077   SilcClientEntry client;
4078   SilcBuffer idp;
4079   SilcBuffer tmp;
4080   unsigned char mode[4];
4081   void *tmp2;
4082
4083   /* Go through all clients in the list */
4084   if (silc_idcache_get_all(id_list->clients, &list)) {
4085     silc_list_start(list);
4086     while ((id_cache = silc_list_get(list))) {
4087       client = (SilcClientEntry)id_cache->context;
4088
4089       if (creation_time && client->data.created < creation_time)
4090         continue;
4091       if (!(client->data.status & SILC_IDLIST_STATUS_REGISTERED))
4092         continue;
4093       if (!client->connection && !client->router)
4094         continue;
4095
4096       SILC_LOG_DEBUG(("Announce Client ID %s",
4097                       silc_id_render(client->id, SILC_ID_CLIENT)));
4098
4099       idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
4100       if (!idp)
4101         return;
4102
4103       tmp2 = silc_buffer_realloc(*clients,
4104                                 (*clients ?
4105                                  silc_buffer_truelen((*clients)) +
4106                                  silc_buffer_len(idp) :
4107                                  silc_buffer_len(idp)));
4108       if (!tmp2)
4109         return;
4110       *clients = tmp2;
4111       silc_buffer_pull_tail(*clients, ((*clients)->end - (*clients)->data));
4112       silc_buffer_put(*clients, idp->data, silc_buffer_len(idp));
4113       silc_buffer_pull(*clients, silc_buffer_len(idp));
4114
4115       SILC_PUT32_MSB(client->mode, mode);
4116       tmp =
4117         silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_UMODE_CHANGE,
4118                                            2, idp->data, silc_buffer_len(idp),
4119                                            mode, 4);
4120       tmp2 = silc_buffer_realloc(*umodes,
4121                                  (*umodes ?
4122                                   silc_buffer_truelen((*umodes)) +
4123                                   silc_buffer_len(tmp) :
4124                                   silc_buffer_len(tmp)));
4125       if (!tmp2)
4126         return;
4127       *umodes = tmp2;
4128       silc_buffer_pull_tail(*umodes, ((*umodes)->end - (*umodes)->data));
4129       silc_buffer_put(*umodes, tmp->data, silc_buffer_len(tmp));
4130       silc_buffer_pull(*umodes, silc_buffer_len(tmp));
4131       silc_buffer_free(tmp);
4132
4133       silc_buffer_free(idp);
4134     }
4135   }
4136 }
4137
4138 /* This function is used to announce our existing clients to our router
4139    when we've connected to it. If `creation_time' is non-zero then only
4140    the clients that has been created after the `creation_time' will be
4141    announced. */
4142
4143 void silc_server_announce_clients(SilcServer server,
4144                                   unsigned long creation_time,
4145                                   SilcPacketStream remote)
4146 {
4147   SilcBuffer clients = NULL;
4148   SilcBuffer umodes = NULL;
4149
4150   SILC_LOG_DEBUG(("Announcing clients"));
4151
4152   /* Get clients in local list */
4153   silc_server_announce_get_clients(server, server->local_list,
4154                                    &clients, &umodes, creation_time);
4155
4156   /* As router we announce our global list as well */
4157   if (server->server_type == SILC_ROUTER)
4158     silc_server_announce_get_clients(server, server->global_list,
4159                                      &clients, &umodes, creation_time);
4160
4161   if (clients) {
4162     silc_buffer_push(clients, clients->data - clients->head);
4163     SILC_LOG_HEXDUMP(("clients"), clients->data, silc_buffer_len(clients));
4164
4165     /* Send the packet */
4166     silc_server_packet_send(server, remote,
4167                             SILC_PACKET_NEW_ID, SILC_PACKET_FLAG_LIST,
4168                             clients->data, silc_buffer_len(clients));
4169
4170     silc_buffer_free(clients);
4171   }
4172
4173   if (umodes) {
4174     silc_buffer_push(umodes, umodes->data - umodes->head);
4175     SILC_LOG_HEXDUMP(("umodes"), umodes->data, silc_buffer_len(umodes));
4176
4177     /* Send the packet */
4178     silc_server_packet_send(server, remote,
4179                             SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4180                             umodes->data, silc_buffer_len(umodes));
4181
4182     silc_buffer_free(umodes);
4183   }
4184 }
4185
4186 /* Returns channel's topic for announcing it */
4187
4188 void silc_server_announce_get_channel_topic(SilcServer server,
4189                                             SilcChannelEntry channel,
4190                                             SilcBuffer *topic)
4191 {
4192   SilcBuffer chidp;
4193
4194   if (channel->topic) {
4195     chidp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL);
4196     *topic = silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_TOPIC_SET, 2,
4197                                                 chidp->data,
4198                                                 silc_buffer_len(chidp),
4199                                                 channel->topic,
4200                                                 strlen(channel->topic));
4201     silc_buffer_free(chidp);
4202   }
4203 }
4204
4205 /* Returns channel's invite and ban lists */
4206
4207 void silc_server_announce_get_inviteban(SilcServer server,
4208                                         SilcChannelEntry channel,
4209                                         SilcBuffer *invite,
4210                                         SilcBuffer *ban)
4211 {
4212   SilcBuffer list, idp, idp2, tmp2;
4213   SilcUInt32 type;
4214   void *ptype;
4215   SilcHashTableList htl;
4216   const unsigned char a[1] = { 0x03 };
4217
4218   idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
4219
4220   /* Encode invite list */
4221   if (channel->invite_list && silc_hash_table_count(channel->invite_list)) {
4222     list = silc_buffer_alloc_size(2);
4223     type = silc_hash_table_count(channel->invite_list);
4224     SILC_PUT16_MSB(type, list->data);
4225     silc_hash_table_list(channel->invite_list, &htl);
4226     while (silc_hash_table_get(&htl, (void *)&ptype, (void *)&tmp2))
4227       list = silc_argument_payload_encode_one(list, tmp2->data,
4228                                               silc_buffer_len(tmp2),
4229                                               SILC_PTR_TO_32(ptype));
4230     silc_hash_table_list_reset(&htl);
4231
4232     idp2 = silc_id_payload_encode(server->id, SILC_ID_SERVER);
4233     *invite =
4234       silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_INVITE, 5,
4235                                          idp->data, silc_buffer_len(idp),
4236                                          channel->channel_name,
4237                                          strlen(channel->channel_name),
4238                                          idp2->data, silc_buffer_len(idp2),
4239                                          a, 1,
4240                                          list->data, silc_buffer_len(list));
4241     silc_buffer_free(idp2);
4242     silc_buffer_free(list);
4243   }
4244
4245   /* Encode ban list */
4246   if (channel->ban_list && silc_hash_table_count(channel->ban_list)) {
4247     list = silc_buffer_alloc_size(2);
4248     type = silc_hash_table_count(channel->ban_list);
4249     SILC_PUT16_MSB(type, list->data);
4250     silc_hash_table_list(channel->ban_list, &htl);
4251     while (silc_hash_table_get(&htl, (void *)&ptype, (void *)&tmp2))
4252       list = silc_argument_payload_encode_one(list, tmp2->data,
4253                                               silc_buffer_len(tmp2),
4254                                               SILC_PTR_TO_32(ptype));
4255     silc_hash_table_list_reset(&htl);
4256
4257     *ban =
4258       silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_BAN, 3,
4259                                          idp->data, silc_buffer_len(idp),
4260                                          a, 1,
4261                                          list->data, silc_buffer_len(list));
4262     silc_buffer_free(list);
4263   }
4264
4265   silc_buffer_free(idp);
4266 }
4267
4268 /* Returns assembled packets for channel users of the `channel'. */
4269
4270 void silc_server_announce_get_channel_users(SilcServer server,
4271                                             SilcChannelEntry channel,
4272                                             SilcBuffer *channel_modes,
4273                                             SilcBuffer *channel_users,
4274                                             SilcBuffer *channel_users_modes)
4275 {
4276   SilcChannelClientEntry chl;
4277   SilcHashTableList htl;
4278   SilcBuffer chidp, clidp, csidp;
4279   SilcBuffer tmp, fkey = NULL, chpklist;
4280   int len;
4281   unsigned char mode[4], ulimit[4];
4282   char *hmac;
4283   void *tmp2;
4284
4285   SILC_LOG_DEBUG(("Start"));
4286
4287   chidp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL);
4288   csidp = silc_id_payload_encode(server->id, SILC_ID_SERVER);
4289   chpklist = silc_server_get_channel_pk_list(server, channel, TRUE, FALSE);
4290
4291   /* CMODE notify */
4292   SILC_PUT32_MSB(channel->mode, mode);
4293   if (channel->mode & SILC_CHANNEL_MODE_ULIMIT)
4294     SILC_PUT32_MSB(channel->user_limit, ulimit);
4295   hmac = channel->hmac ? (char *)silc_hmac_get_name(channel->hmac) : NULL;
4296   if (channel->founder_key)
4297     fkey = silc_public_key_payload_encode(channel->founder_key);
4298   tmp =
4299     silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_CMODE_CHANGE,
4300                                        8, csidp->data,
4301                                        silc_buffer_len(csidp),
4302                                        mode, sizeof(mode),
4303                                        NULL, 0,
4304                                        hmac, hmac ? strlen(hmac) : 0,
4305                                        channel->passphrase,
4306                                        channel->passphrase ?
4307                                        strlen(channel->passphrase) : 0,
4308                                        fkey ? fkey->data : NULL,
4309                                        fkey ? silc_buffer_len(fkey) : 0,
4310                                        chpklist ? chpklist->data : NULL,
4311                                        chpklist ?
4312                                        silc_buffer_len(chpklist) : 0,
4313                                        (channel->mode &
4314                                         SILC_CHANNEL_MODE_ULIMIT ?
4315                                         ulimit : NULL),
4316                                        (channel->mode &
4317                                         SILC_CHANNEL_MODE_ULIMIT ?
4318                                         sizeof(ulimit) : 0));
4319   len = silc_buffer_len(tmp);
4320   tmp2 =
4321     silc_buffer_realloc(*channel_modes,
4322                         (*channel_modes ?
4323                          silc_buffer_truelen((*channel_modes)) + len : len));
4324   if (!tmp2)
4325     return;
4326   *channel_modes = tmp2;
4327   silc_buffer_pull_tail(*channel_modes,
4328                         ((*channel_modes)->end -
4329                          (*channel_modes)->data));
4330   silc_buffer_put(*channel_modes, tmp->data, silc_buffer_len(tmp));
4331   silc_buffer_pull(*channel_modes, len);
4332   silc_buffer_free(tmp);
4333   silc_buffer_free(fkey);
4334   fkey = NULL;
4335
4336   /* Now find all users on the channel */
4337   silc_hash_table_list(channel->user_list, &htl);
4338   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
4339     clidp = silc_id_payload_encode(chl->client->id, SILC_ID_CLIENT);
4340
4341     SILC_LOG_DEBUG(("JOIN Client %s", silc_id_render(chl->client->id,
4342                                                      SILC_ID_CLIENT)));
4343
4344     /* JOIN Notify */
4345     tmp = silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_JOIN, 2,
4346                                              clidp->data,
4347                                              silc_buffer_len(clidp),
4348                                              chidp->data,
4349                                              silc_buffer_len(chidp));
4350     len = silc_buffer_len(tmp);
4351     tmp2 =
4352       silc_buffer_realloc(*channel_users,
4353                           (*channel_users ?
4354                            silc_buffer_truelen((*channel_users)) + len : len));
4355     if (!tmp2)
4356       return;
4357     *channel_users = tmp2;
4358     silc_buffer_pull_tail(*channel_users,
4359                           ((*channel_users)->end -
4360                            (*channel_users)->data));
4361
4362     silc_buffer_put(*channel_users, tmp->data, silc_buffer_len(tmp));
4363     silc_buffer_pull(*channel_users, len);
4364     silc_buffer_free(tmp);
4365
4366     /* CUMODE notify for mode change on the channel */
4367     SILC_PUT32_MSB(chl->mode, mode);
4368     if (chl->mode & SILC_CHANNEL_UMODE_CHANFO && channel->founder_key)
4369       fkey = silc_public_key_payload_encode(channel->founder_key);
4370     tmp = silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_CUMODE_CHANGE,
4371                                              4, csidp->data,
4372                                              silc_buffer_len(csidp),
4373                                              mode, sizeof(mode),
4374                                              clidp->data,
4375                                              silc_buffer_len(clidp),
4376                                              fkey ? fkey->data : NULL,
4377                                              fkey ? silc_buffer_len(fkey) : 0);
4378     len = silc_buffer_len(tmp);
4379     tmp2 =
4380       silc_buffer_realloc(*channel_users_modes,
4381                           (*channel_users_modes ?
4382                            silc_buffer_truelen((*channel_users_modes)) +
4383                            len : len));
4384     if (!tmp2)
4385       return;
4386     *channel_users_modes = tmp2;
4387     silc_buffer_pull_tail(*channel_users_modes,
4388                           ((*channel_users_modes)->end -
4389                            (*channel_users_modes)->data));
4390
4391     silc_buffer_put(*channel_users_modes, tmp->data, silc_buffer_len(tmp));
4392     silc_buffer_pull(*channel_users_modes, len);
4393     silc_buffer_free(tmp);
4394     silc_buffer_free(fkey);
4395     fkey = NULL;
4396     silc_buffer_free(clidp);
4397   }
4398   silc_hash_table_list_reset(&htl);
4399   silc_buffer_free(chidp);
4400   silc_buffer_free(csidp);
4401 }
4402
4403 /* Returns assembled packets for all channels and users on those channels
4404    from the given ID List. The packets are in the form dictated by the
4405    New Channel and New Channel User payloads. */
4406
4407 void silc_server_announce_get_channels(SilcServer server,
4408                                        SilcIDList id_list,
4409                                        SilcBuffer *channels,
4410                                        SilcBuffer **channel_modes,
4411                                        SilcBuffer *channel_users,
4412                                        SilcBuffer **channel_users_modes,
4413                                        SilcUInt32 *channel_users_modes_c,
4414                                        SilcBuffer **channel_topics,
4415                                        SilcBuffer **channel_invites,
4416                                        SilcBuffer **channel_bans,
4417                                        SilcChannelID ***channel_ids,
4418                                        unsigned long creation_time)
4419 {
4420   SilcList list;
4421   SilcIDCacheEntry id_cache;
4422   SilcChannelEntry channel;
4423   unsigned char cid[32];
4424   SilcUInt32 id_len;
4425   SilcUInt16 name_len;
4426   int len;
4427   int i = *channel_users_modes_c;
4428   void *tmp;
4429   SilcBool announce;
4430
4431   SILC_LOG_DEBUG(("Start"));
4432
4433   /* Go through all channels in the list */
4434   if (silc_idcache_get_all(id_list->channels, &list)) {
4435     silc_list_start(list);
4436     while ((id_cache = silc_list_get(list))) {
4437       channel = (SilcChannelEntry)id_cache->context;
4438
4439       if (creation_time && channel->created < creation_time)
4440         announce = FALSE;
4441       else
4442         announce = TRUE;
4443
4444       SILC_LOG_DEBUG(("Announce Channel ID %s",
4445                       silc_id_render(channel->id, SILC_ID_CHANNEL)));
4446
4447       silc_id_id2str(channel->id, SILC_ID_CHANNEL, cid, sizeof(cid), &id_len);
4448       name_len = strlen(channel->channel_name);
4449
4450       if (announce) {
4451         len = 4 + name_len + id_len + 4;
4452         tmp =
4453           silc_buffer_realloc(*channels,
4454                               (*channels ?
4455                                silc_buffer_truelen((*channels)) +
4456                                len : len));
4457         if (!tmp)
4458           break;
4459         *channels = tmp;
4460
4461         silc_buffer_pull_tail(*channels,
4462                               ((*channels)->end - (*channels)->data));
4463         silc_buffer_format(*channels,
4464                            SILC_STR_UI_SHORT(name_len),
4465                            SILC_STR_UI_XNSTRING(channel->channel_name,
4466                                                 name_len),
4467                            SILC_STR_UI_SHORT(id_len),
4468                              SILC_STR_UI_XNSTRING(cid, id_len),
4469                            SILC_STR_UI_INT(channel->mode),
4470                            SILC_STR_END);
4471         silc_buffer_pull(*channels, len);
4472       }
4473
4474       if (creation_time && channel->updated < creation_time)
4475         announce = FALSE;
4476       else
4477         announce = TRUE;
4478
4479       if (announce) {
4480         /* Channel user modes */
4481         tmp = silc_realloc(*channel_users_modes,
4482                             sizeof(**channel_users_modes) * (i + 1));
4483         if (!tmp)
4484           break;
4485         *channel_users_modes = tmp;
4486         (*channel_users_modes)[i] = NULL;
4487         tmp = silc_realloc(*channel_modes,
4488                            sizeof(**channel_modes) * (i + 1));
4489         if (!tmp)
4490           break;
4491         *channel_modes = tmp;
4492         (*channel_modes)[i] = NULL;
4493         tmp = silc_realloc(*channel_ids,
4494                            sizeof(**channel_ids) * (i + 1));
4495         if (!tmp)
4496           break;
4497         *channel_ids = tmp;
4498         (*channel_ids)[i] = NULL;
4499         silc_server_announce_get_channel_users(server, channel,
4500                                                &(*channel_modes)[i],
4501                                                channel_users,
4502                                                &(*channel_users_modes)[i]);
4503         (*channel_ids)[i] = channel->id;
4504
4505         /* Channel's topic */
4506         tmp = silc_realloc(*channel_topics,
4507                            sizeof(**channel_topics) * (i + 1));
4508         if (!tmp)
4509           break;
4510         *channel_topics = tmp;
4511         (*channel_topics)[i] = NULL;
4512         silc_server_announce_get_channel_topic(server, channel,
4513                                                &(*channel_topics)[i]);
4514
4515         /* Channel's invite and ban list */
4516         tmp = silc_realloc(*channel_invites,
4517                            sizeof(**channel_invites) * (i + 1));
4518         if (!tmp)
4519           break;
4520         *channel_invites = tmp;
4521         (*channel_invites)[i] = NULL;
4522         tmp = silc_realloc(*channel_bans,
4523                            sizeof(**channel_bans) * (i + 1));
4524         if (!tmp)
4525           break;
4526         *channel_bans = tmp;
4527         (*channel_bans)[i] = NULL;
4528         silc_server_announce_get_inviteban(server, channel,
4529                                            &(*channel_invites)[i],
4530                                            &(*channel_bans)[i]);
4531
4532         (*channel_users_modes_c)++;
4533
4534         i++;
4535       }
4536     }
4537   }
4538 }
4539
4540 /* This function is used to announce our existing channels to our router
4541    when we've connected to it. This also announces the users on the
4542    channels to the router. If the `creation_time' is non-zero only the
4543    channels that was created after the `creation_time' are announced.
4544    Note that the channel users are still announced even if the `creation_time'
4545    was provided. */
4546
4547 void silc_server_announce_channels(SilcServer server,
4548                                    unsigned long creation_time,
4549                                    SilcPacketStream remote)
4550 {
4551   SilcBuffer channels = NULL, *channel_modes = NULL, channel_users = NULL;
4552   SilcBuffer *channel_users_modes = NULL;
4553   SilcBuffer *channel_topics = NULL;
4554   SilcBuffer *channel_invites = NULL;
4555   SilcBuffer *channel_bans = NULL;
4556   SilcUInt32 channel_users_modes_c = 0;
4557   SilcChannelID **channel_ids = NULL;
4558
4559   SILC_LOG_DEBUG(("Announcing channels and channel users"));
4560
4561   /* Get channels and channel users in local list */
4562   silc_server_announce_get_channels(server, server->local_list,
4563                                     &channels, &channel_modes,
4564                                     &channel_users,
4565                                     &channel_users_modes,
4566                                     &channel_users_modes_c,
4567                                     &channel_topics,
4568                                     &channel_invites,
4569                                     &channel_bans,
4570                                     &channel_ids, creation_time);
4571
4572   /* Get channels and channel users in global list */
4573   if (server->server_type != SILC_SERVER)
4574     silc_server_announce_get_channels(server, server->global_list,
4575                                       &channels, &channel_modes,
4576                                       &channel_users,
4577                                       &channel_users_modes,
4578                                       &channel_users_modes_c,
4579                                       &channel_topics,
4580                                       &channel_invites,
4581                                       &channel_bans,
4582                                       &channel_ids, creation_time);
4583
4584   if (channels) {
4585     silc_buffer_push(channels, channels->data - channels->head);
4586     SILC_LOG_HEXDUMP(("channels"), channels->data, silc_buffer_len(channels));
4587
4588     /* Send the packet */
4589     silc_server_packet_send(server, remote,
4590                             SILC_PACKET_NEW_CHANNEL, SILC_PACKET_FLAG_LIST,
4591                             channels->data, silc_buffer_len(channels));
4592
4593     silc_buffer_free(channels);
4594   }
4595
4596   if (channel_users) {
4597     silc_buffer_push(channel_users, channel_users->data - channel_users->head);
4598     SILC_LOG_HEXDUMP(("channel users"), channel_users->data,
4599                      silc_buffer_len(channel_users));
4600
4601     /* Send the packet */
4602     silc_server_packet_send(server, remote,
4603                             SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4604                             channel_users->data, silc_buffer_len(channel_users));
4605
4606     silc_buffer_free(channel_users);
4607   }
4608
4609   if (channel_modes) {
4610     int i;
4611
4612     for (i = 0; i < channel_users_modes_c; i++) {
4613       if (!channel_modes[i])
4614         continue;
4615       silc_buffer_push(channel_modes[i],
4616                        channel_modes[i]->data -
4617                        channel_modes[i]->head);
4618       SILC_LOG_HEXDUMP(("channel modes"), channel_modes[i]->data,
4619                        silc_buffer_len(channel_modes[i]));
4620       silc_server_packet_send_dest(server, remote,
4621                                    SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4622                                    channel_ids[i], SILC_ID_CHANNEL,
4623                                    channel_modes[i]->data,
4624                                    silc_buffer_len(channel_modes[i]));
4625       silc_buffer_free(channel_modes[i]);
4626     }
4627     silc_free(channel_modes);
4628   }
4629
4630   if (channel_users_modes) {
4631     int i;
4632
4633     for (i = 0; i < channel_users_modes_c; i++) {
4634       if (!channel_users_modes[i])
4635         continue;
4636       silc_buffer_push(channel_users_modes[i],
4637                        channel_users_modes[i]->data -
4638                        channel_users_modes[i]->head);
4639       SILC_LOG_HEXDUMP(("channel users modes"), channel_users_modes[i]->data,
4640                        silc_buffer_len(channel_users_modes[i]));
4641       silc_server_packet_send_dest(server, remote,
4642                                    SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4643                                    channel_ids[i], SILC_ID_CHANNEL,
4644                                    channel_users_modes[i]->data,
4645                                    silc_buffer_len(channel_users_modes[i]));
4646       silc_buffer_free(channel_users_modes[i]);
4647     }
4648     silc_free(channel_users_modes);
4649   }
4650
4651   if (channel_topics) {
4652     int i;
4653
4654     for (i = 0; i < channel_users_modes_c; i++) {
4655       if (!channel_topics[i])
4656         continue;
4657
4658       silc_buffer_push(channel_topics[i],
4659                        channel_topics[i]->data -
4660                        channel_topics[i]->head);
4661       SILC_LOG_HEXDUMP(("channel topic"), channel_topics[i]->data,
4662                        silc_buffer_len(channel_topics[i]));
4663       silc_server_packet_send_dest(server, remote,
4664                                    SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4665                                    channel_ids[i], SILC_ID_CHANNEL,
4666                                    channel_topics[i]->data,
4667                                    silc_buffer_len(channel_topics[i]));
4668       silc_buffer_free(channel_topics[i]);
4669     }
4670     silc_free(channel_topics);
4671   }
4672
4673   if (channel_invites) {
4674     int i;
4675
4676     for (i = 0; i < channel_users_modes_c; i++) {
4677       if (!channel_invites[i])
4678         continue;
4679
4680       silc_buffer_push(channel_invites[i],
4681                        channel_invites[i]->data -
4682                        channel_invites[i]->head);
4683       SILC_LOG_HEXDUMP(("channel invite list"), channel_invites[i]->data,
4684                        silc_buffer_len(channel_invites[i]));
4685       silc_server_packet_send_dest(server, remote,
4686                                    SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4687                                    channel_ids[i], SILC_ID_CHANNEL,
4688                                    channel_invites[i]->data,
4689                                    silc_buffer_len(channel_invites[i]));
4690       silc_buffer_free(channel_invites[i]);
4691     }
4692     silc_free(channel_invites);
4693   }
4694
4695   if (channel_bans) {
4696     int i;
4697
4698     for (i = 0; i < channel_users_modes_c; i++) {
4699       if (!channel_bans[i])
4700         continue;
4701
4702       silc_buffer_push(channel_bans[i],
4703                        channel_bans[i]->data -
4704                        channel_bans[i]->head);
4705       SILC_LOG_HEXDUMP(("channel ban list"), channel_bans[i]->data,
4706                        silc_buffer_len(channel_bans[i]));
4707       silc_server_packet_send_dest(server, remote,
4708                                    SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4709                                    channel_ids[i], SILC_ID_CHANNEL,
4710                                    channel_bans[i]->data,
4711                                    silc_buffer_len(channel_bans[i]));
4712       silc_buffer_free(channel_bans[i]);
4713     }
4714     silc_free(channel_bans);
4715   }
4716
4717   silc_free(channel_ids);
4718 }
4719
4720 /* Announces WATCH list. */
4721
4722 void silc_server_announce_watches(SilcServer server,
4723                                   SilcPacketStream remote)
4724 {
4725   SilcHashTableList htl;
4726   SilcBuffer buffer, idp, args, pkp;
4727   SilcClientEntry client;
4728   void *key;
4729
4730   SILC_LOG_DEBUG(("Announcing watch list"));
4731
4732   /* XXX because way we save the nicks (hash) we cannot announce them. */
4733
4734   /* XXX we should send all public keys in one command if client is
4735      watching more than one key */
4736   silc_hash_table_list(server->watcher_list_pk, &htl);
4737   while (silc_hash_table_get(&htl, &key, (void *)&client)) {
4738     if (!client || !client->id)
4739       continue;
4740
4741     server->stat.commands_sent++;
4742
4743     idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
4744     args = silc_buffer_alloc_size(2);
4745     silc_buffer_format(args,
4746                        SILC_STR_UI_SHORT(1),
4747                        SILC_STR_END);
4748     pkp = silc_public_key_payload_encode(key);
4749     args = silc_argument_payload_encode_one(args, pkp->data,
4750                                             silc_buffer_len(pkp), 0x00);
4751     buffer = silc_command_payload_encode_va(SILC_COMMAND_WATCH,
4752                                             ++server->cmd_ident, 2,
4753                                             1, idp->data, silc_buffer_len(idp),
4754                                             4, args->data,
4755                                             silc_buffer_len(args));
4756
4757     /* Send command */
4758     silc_server_packet_send(server, remote, SILC_PACKET_COMMAND, 0,
4759                             buffer->data, silc_buffer_len(buffer));
4760
4761     silc_buffer_free(pkp);
4762     silc_buffer_free(args);
4763     silc_buffer_free(idp);
4764     silc_buffer_free(buffer);
4765   }
4766   silc_hash_table_list_reset(&htl);
4767 }
4768
4769 /* Assembles user list and users mode list from the `channel'. */
4770
4771 SilcBool silc_server_get_users_on_channel(SilcServer server,
4772                                           SilcChannelEntry channel,
4773                                           SilcBuffer *user_list,
4774                                           SilcBuffer *mode_list,
4775                                           SilcUInt32 *user_count)
4776 {
4777   SilcChannelClientEntry chl;
4778   SilcHashTableList htl;
4779   SilcBuffer client_id_list;
4780   SilcBuffer client_mode_list;
4781   SilcBuffer idp;
4782   SilcUInt32 list_count = 0, len = 0;
4783
4784   if (!silc_hash_table_count(channel->user_list))
4785     return FALSE;
4786
4787   silc_hash_table_list(channel->user_list, &htl);
4788   while (silc_hash_table_get(&htl, NULL, (void *)&chl))
4789     len += (silc_id_get_len(chl->client->id, SILC_ID_CLIENT) + 4);
4790   silc_hash_table_list_reset(&htl);
4791
4792   client_id_list = silc_buffer_alloc(len);
4793   client_mode_list =
4794     silc_buffer_alloc(4 * silc_hash_table_count(channel->user_list));
4795   silc_buffer_pull_tail(client_id_list, silc_buffer_truelen(client_id_list));
4796   silc_buffer_pull_tail(client_mode_list,
4797                         silc_buffer_truelen(client_mode_list));
4798
4799   silc_hash_table_list(channel->user_list, &htl);
4800   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
4801     /* Client ID */
4802     idp = silc_id_payload_encode(chl->client->id, SILC_ID_CLIENT);
4803     silc_buffer_put(client_id_list, idp->data, silc_buffer_len(idp));
4804     silc_buffer_pull(client_id_list, silc_buffer_len(idp));
4805     silc_buffer_free(idp);
4806
4807     /* Client's mode on channel */
4808     SILC_PUT32_MSB(chl->mode, client_mode_list->data);
4809     silc_buffer_pull(client_mode_list, 4);
4810
4811     list_count++;
4812   }
4813   silc_hash_table_list_reset(&htl);
4814   silc_buffer_push(client_id_list,
4815                    client_id_list->data - client_id_list->head);
4816   silc_buffer_push(client_mode_list,
4817                    client_mode_list->data - client_mode_list->head);
4818
4819   *user_list = client_id_list;
4820   *mode_list = client_mode_list;
4821   *user_count = list_count;
4822   return TRUE;
4823 }
4824
4825 /* Saves users and their modes to the `channel'. */
4826
4827 void silc_server_save_users_on_channel(SilcServer server,
4828                                        SilcPacketStream sock,
4829                                        SilcChannelEntry channel,
4830                                        SilcClientID *noadd,
4831                                        SilcBuffer user_list,
4832                                        SilcBuffer mode_list,
4833                                        SilcUInt32 user_count)
4834 {
4835   int i;
4836   SilcUInt16 idp_len;
4837   SilcUInt32 mode;
4838   SilcID id;
4839   SilcClientEntry client;
4840   SilcIDCacheEntry cache;
4841   SilcChannelClientEntry chl;
4842
4843   SILC_LOG_DEBUG(("Saving %d users on %s channel", user_count,
4844                   channel->channel_name));
4845
4846   for (i = 0; i < user_count; i++) {
4847     /* Client ID */
4848     SILC_GET16_MSB(idp_len, user_list->data + 2);
4849     idp_len += 4;
4850     if (!silc_id_payload_parse_id(user_list->data, idp_len, &id))
4851       continue;
4852     silc_buffer_pull(user_list, idp_len);
4853
4854     /* Mode */
4855     SILC_GET32_MSB(mode, mode_list->data);
4856     silc_buffer_pull(mode_list, 4);
4857
4858     if (noadd && SILC_ID_CLIENT_COMPARE(&id.u.client_id, noadd))
4859       continue;
4860
4861     cache = NULL;
4862
4863     /* Check if we have this client cached already. */
4864     client = silc_idlist_find_client_by_id(server->local_list,
4865                                            &id.u.client_id,
4866                                            server->server_type, &cache);
4867     if (!client)
4868       client = silc_idlist_find_client_by_id(server->global_list,
4869                                              &id.u.client_id,
4870                                              server->server_type, &cache);
4871     if (!client) {
4872       /* If router did not find such Client ID in its lists then this must
4873          be bogus client or some router in the net is buggy. */
4874       if (server->server_type != SILC_SERVER)
4875         continue;
4876
4877       /* We don't have that client anywhere, add it. The client is added
4878          to global list since server didn't have it in the lists so it must be
4879          global. */
4880       client = silc_idlist_add_client(server->global_list, NULL, NULL, NULL,
4881                                       silc_id_dup(&id.u.client_id,
4882                                                   SILC_ID_CLIENT),
4883                                       silc_packet_get_context(sock),
4884                                       NULL);
4885       if (!client) {
4886         SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
4887         continue;
4888       }
4889
4890       client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
4891     }
4892
4893     if (!(client->data.status & SILC_IDLIST_STATUS_REGISTERED)) {
4894       SILC_LOG_ERROR(("Attempting to add unregistered client to channel ",
4895                       "%s", channel->channel_name));
4896       continue;
4897     }
4898
4899     if (!silc_server_client_on_channel(client, channel, &chl)) {
4900       /* Client was not on the channel, add it. */
4901       chl = silc_calloc(1, sizeof(*chl));
4902       chl->client = client;
4903       chl->mode = mode;
4904       chl->channel = channel;
4905       silc_hash_table_add(channel->user_list, chl->client, chl);
4906       silc_hash_table_add(client->channels, chl->channel, chl);
4907       channel->user_count++;
4908     } else {
4909       /* Update mode */
4910       chl->mode = mode;
4911     }
4912   }
4913 }
4914
4915 /* Saves channels and channels user modes to the `client'.  Removes
4916    the client from those channels that are not sent in the list but
4917    it has joined. */
4918
4919 void silc_server_save_user_channels(SilcServer server,
4920                                     SilcPacketStream sock,
4921                                     SilcClientEntry client,
4922                                     SilcBuffer channels,
4923                                     SilcBuffer channels_user_modes)
4924 {
4925   SilcDList ch;
4926   SilcUInt32 *chumodes;
4927   SilcChannelPayload entry;
4928   SilcChannelEntry channel;
4929   SilcChannelID channel_id;
4930   SilcChannelClientEntry chl;
4931   SilcHashTable ht = NULL;
4932   SilcHashTableList htl;
4933   char *name;
4934   int i = 0;
4935
4936   if (!channels || !channels_user_modes ||
4937       !(client->data.status & SILC_IDLIST_STATUS_REGISTERED))
4938     goto out;
4939
4940   ch = silc_channel_payload_parse_list(channels->data,
4941                                        silc_buffer_len(channels));
4942   if (ch && silc_get_mode_list(channels_user_modes, silc_dlist_count(ch),
4943                                &chumodes)) {
4944     ht = silc_hash_table_alloc(0, silc_hash_ptr, NULL, NULL,
4945                                NULL, NULL, NULL, TRUE);
4946     silc_dlist_start(ch);
4947     while ((entry = silc_dlist_get(ch)) != SILC_LIST_END) {
4948       /* Check if we have this channel, and add it if we don't have it.
4949          Also add the client on the channel unless it is there already. */
4950       if (!silc_channel_get_id_parse(entry, &channel_id))
4951         continue;
4952       channel = silc_idlist_find_channel_by_id(server->local_list,
4953                                                &channel_id, NULL);
4954       if (!channel)
4955         channel = silc_idlist_find_channel_by_id(server->global_list,
4956                                                  &channel_id, NULL);
4957       if (!channel) {
4958         if (server->server_type != SILC_SERVER) {
4959           i++;
4960           continue;
4961         }
4962
4963         /* We don't have that channel anywhere, add it. */
4964         name = silc_channel_get_name(entry, NULL);
4965         channel = silc_idlist_add_channel(server->global_list, strdup(name), 0,
4966                                           silc_id_dup(&channel_id,
4967                                                       SILC_ID_CHANNEL),
4968                                           server->router, NULL, NULL, 0);
4969         if (!channel) {
4970           i++;
4971           continue;
4972         }
4973       }
4974
4975       channel->mode = silc_channel_get_mode(entry);
4976
4977       /* Add the client on the channel */
4978       if (!silc_server_client_on_channel(client, channel, &chl)) {
4979         chl = silc_calloc(1, sizeof(*chl));
4980         chl->client = client;
4981         chl->mode = chumodes[i++];
4982         chl->channel = channel;
4983         silc_hash_table_add(channel->user_list, chl->client, chl);
4984         silc_hash_table_add(client->channels, chl->channel, chl);
4985         channel->user_count++;
4986       } else {
4987         /* Update mode */
4988         chl->mode = chumodes[i++];
4989       }
4990
4991       silc_hash_table_add(ht, channel, channel);
4992     }
4993     silc_channel_payload_list_free(ch);
4994     silc_free(chumodes);
4995   }
4996
4997  out:
4998   /* Go through the list again and remove client from channels that
4999      are no part of the list. */
5000   if (ht) {
5001     silc_hash_table_list(client->channels, &htl);
5002     while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
5003       if (!silc_hash_table_find(ht, chl->channel, NULL, NULL)) {
5004         silc_hash_table_del(chl->channel->user_list, chl->client);
5005         silc_hash_table_del(chl->client->channels, chl->channel);
5006         silc_free(chl);
5007       }
5008     }
5009     silc_hash_table_list_reset(&htl);
5010     silc_hash_table_free(ht);
5011   } else {
5012     silc_hash_table_list(client->channels, &htl);
5013     while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
5014       silc_hash_table_del(chl->channel->user_list, chl->client);
5015       silc_hash_table_del(chl->client->channels, chl->channel);
5016       silc_free(chl);
5017     }
5018     silc_hash_table_list_reset(&htl);
5019   }
5020 }
5021
5022 /* Lookups route to the client indicated by the `id_data'. The connection
5023    object and internal data object is returned. Returns NULL if route
5024    could not be found to the client. If the `client_id' is specified then
5025    it is used and the `id_data' is ignored. */
5026
5027 SilcPacketStream
5028 silc_server_get_client_route(SilcServer server,
5029                              unsigned char *id_data,
5030                              SilcUInt32 id_len,
5031                              SilcClientID *client_id,
5032                              SilcIDListData *idata,
5033                              SilcClientEntry *client_entry)
5034 {
5035   SilcClientID *id, clid;
5036   SilcClientEntry client;
5037
5038   SILC_LOG_DEBUG(("Start"));
5039
5040   if (client_entry)
5041     *client_entry = NULL;
5042
5043   /* Decode destination Client ID */
5044   if (!client_id) {
5045     if (!silc_id_str2id(id_data, id_len, SILC_ID_CLIENT, &clid, sizeof(clid)))
5046       return NULL;
5047     id = silc_id_dup(&clid, SILC_ID_CLIENT);
5048   } else {
5049     id = silc_id_dup(client_id, SILC_ID_CLIENT);
5050   }
5051
5052   /* If the destination belongs to our server we don't have to route
5053      the packet anywhere but to send it to the local destination. */
5054   client = silc_idlist_find_client_by_id(server->local_list, id, TRUE, NULL);
5055   if (client) {
5056     silc_free(id);
5057
5058     /* If we are router and the client has router then the client is in
5059        our cell but not directly connected to us. */
5060     if (server->server_type == SILC_ROUTER && client->router) {
5061       /* We are of course in this case the client's router thus the route
5062          to the client is the server who owns the client. So, we will send
5063          the packet to that server. */
5064       if (idata)
5065         *idata = (SilcIDListData)client->router;
5066       return client->router->connection;
5067     }
5068
5069     /* Seems that client really is directly connected to us */
5070     if (idata)
5071       *idata = (SilcIDListData)client;
5072     if (client_entry)
5073       *client_entry = client;
5074     return client->connection;
5075   }
5076
5077   /* Destination belongs to someone not in this server. If we are normal
5078      server our action is to send the packet to our router. */
5079   if (server->server_type != SILC_ROUTER && !server->standalone) {
5080     silc_free(id);
5081     if (idata)
5082       *idata = (SilcIDListData)server->router;
5083     return SILC_PRIMARY_ROUTE(server);
5084   }
5085
5086   /* We are router and we will perform route lookup for the destination
5087      and send the packet to fastest route. */
5088   if (server->server_type == SILC_ROUTER && !server->standalone) {
5089     /* Check first that the ID is valid */
5090     client = silc_idlist_find_client_by_id(server->global_list, id,
5091                                            TRUE, NULL);
5092     if (client) {
5093       SilcPacketStream dst_sock;
5094
5095       dst_sock = silc_server_route_get(server, id, SILC_ID_CLIENT);
5096
5097       silc_free(id);
5098       if (idata && dst_sock)
5099         *idata = silc_packet_get_context(dst_sock);
5100       return dst_sock;
5101     }
5102   }
5103
5104   silc_free(id);
5105   return NULL;
5106 }
5107
5108 /* Encodes and returns channel list of channels the `client' has joined.
5109    Secret channels are not put to the list. */
5110
5111 SilcBuffer silc_server_get_client_channel_list(SilcServer server,
5112                                                SilcClientEntry client,
5113                                                SilcBool get_private,
5114                                                SilcBool get_secret,
5115                                                SilcBuffer *user_mode_list)
5116 {
5117   SilcBuffer buffer = NULL;
5118   SilcChannelEntry channel;
5119   SilcChannelClientEntry chl;
5120   SilcHashTableList htl;
5121   unsigned char cid[32];
5122   SilcUInt32 id_len;
5123   SilcUInt16 name_len;
5124   int len;
5125
5126   if (user_mode_list)
5127     *user_mode_list = NULL;
5128
5129   silc_hash_table_list(client->channels, &htl);
5130   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
5131     channel = chl->channel;
5132
5133     if (channel->mode & SILC_CHANNEL_MODE_SECRET && !get_secret)
5134       continue;
5135     if (channel->mode & SILC_CHANNEL_MODE_PRIVATE && !get_private)
5136       continue;
5137
5138     silc_id_id2str(channel->id, SILC_ID_CHANNEL, cid, sizeof(cid), &id_len);
5139     name_len = strlen(channel->channel_name);
5140
5141     len = 4 + name_len + id_len + 4;
5142     buffer = silc_buffer_realloc(buffer,
5143                                  (buffer ?
5144                                   silc_buffer_truelen(buffer) + len : len));
5145     silc_buffer_pull_tail(buffer, (buffer->end - buffer->data));
5146     silc_buffer_format(buffer,
5147                        SILC_STR_UI_SHORT(name_len),
5148                        SILC_STR_DATA(channel->channel_name, name_len),
5149                        SILC_STR_UI_SHORT(id_len),
5150                        SILC_STR_DATA(cid, id_len),
5151                        SILC_STR_UI_INT(chl->channel->mode),
5152                        SILC_STR_END);
5153     silc_buffer_pull(buffer, len);
5154
5155     if (user_mode_list) {
5156       *user_mode_list =
5157         silc_buffer_realloc(*user_mode_list,
5158                             (*user_mode_list ?
5159                              silc_buffer_truelen((*user_mode_list)) + 4 : 4));
5160       silc_buffer_pull_tail(*user_mode_list, ((*user_mode_list)->end -
5161                                               (*user_mode_list)->data));
5162       SILC_PUT32_MSB(chl->mode, (*user_mode_list)->data);
5163       silc_buffer_pull(*user_mode_list, 4);
5164     }
5165   }
5166   silc_hash_table_list_reset(&htl);
5167
5168   if (buffer)
5169     silc_buffer_push(buffer, buffer->data - buffer->head);
5170   if (user_mode_list && *user_mode_list)
5171     silc_buffer_push(*user_mode_list, ((*user_mode_list)->data -
5172                                        (*user_mode_list)->head));
5173
5174   return buffer;
5175 }
5176
5177 /* Task callback used to retrieve network statistical information from
5178    router server once in a while. */
5179
5180 SILC_TASK_CALLBACK(silc_server_get_stats)
5181 {
5182   SilcServer server = (SilcServer)context;
5183   SilcBuffer idp, packet;
5184
5185   if (!server->standalone) {
5186     SILC_LOG_DEBUG(("Retrieving stats from router"));
5187     server->stat.commands_sent++;
5188     idp = silc_id_payload_encode(server->router->id, SILC_ID_SERVER);
5189     if (idp) {
5190       packet = silc_command_payload_encode_va(SILC_COMMAND_STATS,
5191                                               ++server->cmd_ident, 1,
5192                                               1, idp->data,
5193                                               silc_buffer_len(idp));
5194       silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
5195                               SILC_PACKET_COMMAND, 0, packet->data,
5196                               silc_buffer_len(packet));
5197       silc_buffer_free(packet);
5198       silc_buffer_free(idp);
5199     }
5200   }
5201
5202   silc_schedule_task_add_timeout(server->schedule, silc_server_get_stats,
5203                                  server, 120, 0);
5204 }