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