apps/silcd/server.c

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