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