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