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