apps/silcd/server.c

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