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