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