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, stream,
 285                                  silc_rng_get_byte(server->rng) % 5, 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 /* Helper to stop future rekeys on a link. */
2907 void silc_server_stop_rekey(SilcServer server, SilcClientEntry client)
2908 {
2909   if (!client->connection)
2910     return;
2911
2912   SILC_LOG_DEBUG(("Stopping rekey for client %p", client));
2913
2914   silc_schedule_task_del_by_all(server->schedule, 0, silc_server_do_rekey,
2915                                 client->connection);
2916 }
2917
2918 /* Rekey callback.  Start rekey as initiator */
2919
2920 SILC_TASK_CALLBACK(silc_server_do_rekey)
2921 {
2922   SilcServer server = app_context;
2923   SilcPacketStream sock = context;
2924   SilcIDListData idata = silc_packet_get_context(sock);
2925   SilcSKE ske;
2926
2927   SILC_LOG_DEBUG(("Perform rekey, sock %p", sock));
2928
2929   /* Do not execute rekey with disabled connections */
2930   if (idata->status & SILC_IDLIST_STATUS_DISABLED || !idata->rekey)
2931     return;
2932
2933   /* If another protocol is active do not start rekey */
2934   if (idata->sconn->op) {
2935     SILC_LOG_DEBUG(("Waiting for other protocol to finish before rekeying"));
2936     silc_schedule_task_add_timeout(server->schedule, silc_server_do_rekey,
2937                                    sock, 60, 0);
2938     return;
2939   }
2940
2941   SILC_LOG_DEBUG(("Executing rekey protocol with %s:%d [%s]",
2942                   idata->sconn->remote_host, idata->sconn->remote_port,
2943                   SILC_CONNTYPE_STRING(idata->conn_type)));
2944
2945   /* Allocate SKE */
2946   ske = silc_ske_alloc(server->rng, server->schedule, NULL,
2947                        server->public_key, NULL, sock);
2948   if (!ske)
2949     return;
2950
2951   /* Set SKE callbacks */
2952   silc_ske_set_callbacks(ske, NULL, silc_server_rekey_completion, sock);
2953
2954   /* Perform rekey */
2955   idata->sconn->op = silc_ske_rekey_initiator(ske, sock, idata->rekey);
2956 }
2957
2958 /* Responder rekey completion callback */
2959
2960 static void
2961 silc_server_rekey_resp_completion(SilcSKE ske,
2962                                   SilcSKEStatus status,
2963                                   const SilcSKESecurityProperties prop,
2964                                   const SilcSKEKeyMaterial keymat,
2965                                   SilcSKERekeyMaterial rekey,
2966                                   void *context)
2967 {
2968   SilcPacketStream sock = context;
2969   SilcIDListData idata = silc_packet_get_context(sock);
2970
2971   idata->sconn->op = NULL;
2972   if (status != SILC_SKE_STATUS_OK) {
2973     SILC_LOG_ERROR(("Error during rekey protocol with %s",
2974                     idata->sconn->remote_host));
2975     return;
2976   }
2977
2978   SILC_LOG_DEBUG(("Rekey protocol completed with %s:%d [%s]",
2979                   idata->sconn->remote_host, idata->sconn->remote_port,
2980                   SILC_CONNTYPE_STRING(idata->conn_type)));
2981
2982   /* Save rekey data for next rekey */
2983   idata->rekey = rekey;
2984 }
2985
2986 /* Start rekey as responder */
2987
2988 static void silc_server_rekey(SilcServer server, SilcPacketStream sock,
2989                               SilcPacket packet)
2990 {
2991   SilcIDListData idata = silc_packet_get_context(sock);
2992   SilcSKE ske;
2993
2994   if (!idata->rekey) {
2995     silc_packet_free(packet);
2996     return;
2997   }
2998
2999   SILC_LOG_DEBUG(("Executing rekey protocol with %s:%d [%s], sock %p",
3000                   idata->sconn->remote_host, idata->sconn->remote_port,
3001                   SILC_CONNTYPE_STRING(idata->conn_type), sock));
3002
3003   /* Allocate SKE */
3004   ske = silc_ske_alloc(server->rng, server->schedule, NULL,
3005                        server->public_key, NULL, sock);
3006   if (!ske) {
3007     silc_packet_free(packet);
3008     return;
3009   }
3010
3011   /* Set SKE callbacks */
3012   silc_ske_set_callbacks(ske, NULL, silc_server_rekey_resp_completion, sock);
3013
3014   /* Perform rekey */
3015   idata->sconn->op = silc_ske_rekey_responder(ske, sock, idata->rekey,
3016                                               packet);
3017 }
3018
3019
3020 /****************************** Disconnection *******************************/
3021
3022 /* Destroys packet stream. */
3023
3024 SILC_TASK_CALLBACK(silc_server_close_connection_final)
3025 {
3026   silc_packet_stream_unref(context);
3027 }
3028
3029 /* Closes connection to socket connection */
3030
3031 void silc_server_close_connection(SilcServer server,
3032                                   SilcPacketStream sock)
3033 {
3034   SilcIDListData idata = silc_packet_get_context(sock);
3035   char tmp[128];
3036   const char *hostname;
3037   SilcUInt16 port;
3038
3039   if (!silc_packet_stream_is_valid(sock))
3040     return;
3041
3042   memset(tmp, 0, sizeof(tmp));
3043   //  silc_socket_get_error(sock, tmp, sizeof(tmp));
3044   silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
3045                               NULL, &hostname, NULL, &port);
3046   SILC_LOG_INFO(("Closing connection %s:%d [%s] %s", hostname, port,
3047                  idata ? SILC_CONNTYPE_STRING(idata->conn_type) : "",
3048                  tmp[0] ? tmp : ""));
3049
3050   //  silc_socket_set_qos(sock, 0, 0, 0, 0, NULL);
3051
3052   if (idata && idata->sconn) {
3053     silc_server_connection_free(idata->sconn);
3054     idata->sconn = NULL;
3055   }
3056
3057   /* Take a reference and then destroy the stream.  The last reference
3058      is released later in a timeout callback. */
3059   silc_packet_stream_ref(sock);
3060   silc_packet_stream_destroy(sock);
3061
3062   /* Close connection with timeout */
3063   server->stat.conn_num--;
3064   silc_schedule_task_del_by_all(server->schedule, 0,
3065                                 silc_server_close_connection_final, sock);
3066   silc_schedule_task_add_timeout(server->schedule,
3067                                  silc_server_close_connection_final,
3068                                  sock, 0, 1);
3069 }
3070
3071 /* Sends disconnect message to remote connection and disconnects the
3072    connection. */
3073
3074 void silc_server_disconnect_remote(SilcServer server,
3075                                    SilcPacketStream sock,
3076                                    SilcStatus status, ...)
3077 {
3078   unsigned char buf[512];
3079   va_list ap;
3080   char *cp;
3081
3082   if (!sock)
3083     return;
3084
3085   SILC_LOG_DEBUG(("Disconnecting remote host, sock %p", sock));
3086
3087   va_start(ap, status);
3088   cp = va_arg(ap, char *);
3089   if (cp)
3090     silc_vsnprintf(buf, sizeof(buf), cp, ap);
3091   va_end(ap);
3092
3093   /* Send SILC_PACKET_DISCONNECT */
3094   silc_packet_send_va(sock, SILC_PACKET_DISCONNECT, 0,
3095                       SILC_STR_UI_CHAR(status),
3096                       SILC_STR_UI8_STRING(cp ? buf : NULL),
3097                       SILC_STR_END);
3098
3099   /* Close connection */
3100   silc_server_close_connection(server, sock);
3101 }
3102
3103 /* Frees client data and notifies about client's signoff. */
3104
3105 void silc_server_free_client_data(SilcServer server,
3106                                   SilcPacketStream sock,
3107                                   SilcClientEntry client,
3108                                   int notify,
3109                                   const char *signoff)
3110 {
3111   SILC_LOG_DEBUG(("Freeing client %p data", client));
3112
3113   if (client->id) {
3114     /* Check if anyone is watching this nickname */
3115     if (server->server_type == SILC_ROUTER)
3116       silc_server_check_watcher_list(server, client, NULL,
3117                                      SILC_NOTIFY_TYPE_SIGNOFF);
3118
3119     /* Send SIGNOFF notify to routers. */
3120     if (notify)
3121       silc_server_send_notify_signoff(server, SILC_PRIMARY_ROUTE(server),
3122                                       SILC_BROADCAST(server), client->id,
3123                                       signoff);
3124   }
3125
3126   /* Remove client from all channels */
3127   if (notify)
3128     silc_server_remove_from_channels(server, NULL, client,
3129                                      TRUE, (char *)signoff, TRUE, FALSE);
3130   else
3131     silc_server_remove_from_channels(server, NULL, client,
3132                                      FALSE, NULL, FALSE, FALSE);
3133
3134   /* Remove this client from watcher list if it is */
3135   silc_server_del_from_watcher_list(server, client);
3136
3137   /* Remove client's public key from repository, this will free it too. */
3138   if (client->data.public_key) {
3139     silc_skr_del_public_key(server->repository, client->data.public_key,
3140                             client);
3141     client->data.public_key = NULL;
3142   }
3143
3144   /* Update statistics */
3145   server->stat.my_clients--;
3146   SILC_VERIFY(server->stat.clients > 0);
3147   server->stat.clients--;
3148   if (server->stat.cell_clients)
3149     server->stat.cell_clients--;
3150   SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
3151   SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
3152   silc_schedule_task_del_by_context(server->schedule, client);
3153
3154   if (client->data.sconn) {
3155     silc_server_connection_free(client->data.sconn);
3156     client->data.sconn = NULL;
3157   }
3158
3159   /* We will not delete the client entry right away. We will take it
3160      into history (for WHOWAS command) for 5 minutes, unless we're
3161      shutting down server. */
3162   if (!server->server_shutdown) {
3163     client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
3164     client->mode = 0;
3165     client->router = NULL;
3166     client->connection = NULL;
3167     client->data.created = silc_time();
3168     silc_dlist_del(server->expired_clients, client);
3169     silc_dlist_add(server->expired_clients, client);
3170   } else {
3171     /* Delete directly since we're shutting down server */
3172     SILC_LOG_DEBUG(("Delete client directly"));
3173     silc_idlist_del_data(client);
3174     silc_idlist_del_client(server->local_list, client);
3175   }
3176 }
3177
3178 /* Frees user_data pointer from socket connection object. This also sends
3179    appropriate notify packets to the network to inform about leaving
3180    entities. */
3181
3182 void silc_server_free_sock_user_data(SilcServer server,
3183                                      SilcPacketStream sock,
3184                                      const char *signoff_message)
3185 {
3186   SilcIDListData idata;
3187   const char *ip;
3188   SilcUInt16 port;
3189
3190   if (!sock)
3191     return;
3192
3193   SILC_LOG_DEBUG(("Start, sock %p", sock));
3194
3195   idata = silc_packet_get_context(sock);
3196   if (!idata)
3197     return;
3198
3199   silc_schedule_task_del_by_all(server->schedule, 0, silc_server_do_rekey,
3200                                 sock);
3201
3202   /* Cancel active protocols */
3203   if (idata) {
3204     if (idata->sconn && idata->sconn->op) {
3205       SILC_LOG_DEBUG(("Abort active protocol"));
3206       silc_async_abort(idata->sconn->op, NULL, NULL);
3207     }
3208     if (idata->conn_type == SILC_CONN_UNKNOWN &&
3209         ((SilcUnknownEntry)idata)->op) {
3210       SILC_LOG_DEBUG(("Abort active protocol"));
3211       silc_async_abort(((SilcUnknownEntry)idata)->op, NULL, NULL);
3212     }
3213   }
3214
3215   switch (idata->conn_type) {
3216   case SILC_CONN_CLIENT:
3217     {
3218       SilcClientEntry client_entry = (SilcClientEntry)idata;
3219       silc_server_free_client_data(server, sock, client_entry, TRUE,
3220                                    signoff_message);
3221       silc_packet_set_context(sock, NULL);
3222       break;
3223     }
3224
3225   case SILC_CONN_SERVER:
3226   case SILC_CONN_ROUTER:
3227     {
3228       SilcServerEntry user_data = (SilcServerEntry)idata;
3229       SilcServerEntry backup_router = NULL;
3230
3231       SILC_LOG_DEBUG(("Freeing server %p data", user_data));
3232
3233       if (user_data->id)
3234         backup_router = silc_server_backup_get(server, user_data->id);
3235
3236       if (!server->backup_router && server->server_type == SILC_ROUTER &&
3237           backup_router == server->id_entry &&
3238           idata->conn_type != SILC_CONN_ROUTER)
3239         backup_router = NULL;
3240
3241       if (server->server_shutdown || server->backup_noswitch)
3242         backup_router = NULL;
3243
3244       silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
3245                                   NULL, NULL, &ip, &port);
3246
3247       /* If this was our primary router connection then we're lost to
3248          the outside world. */
3249       if (server->router == user_data) {
3250         /* Check whether we have a backup router connection */
3251         if (!backup_router || backup_router == user_data) {
3252           if (!server->no_reconnect)
3253             silc_server_create_connections(server);
3254           server->id_entry->router = NULL;
3255           server->router = NULL;
3256           server->standalone = TRUE;
3257           server->backup_primary = FALSE;
3258           backup_router = NULL;
3259         } else {
3260           if (server->id_entry != backup_router) {
3261             SILC_LOG_INFO(("New primary router is backup router %s",
3262                            backup_router->server_name));
3263             server->id_entry->router = backup_router;
3264             server->router = backup_router;
3265             server->router_connect = time(0);
3266             server->backup_primary = TRUE;
3267             backup_router->data.status &= ~SILC_IDLIST_STATUS_DISABLED;
3268
3269             /* Send START_USE to backup router to indicate we have switched */
3270             silc_server_backup_send_start_use(server,
3271                                               backup_router->connection,
3272                                               FALSE);
3273           } else {
3274             SILC_LOG_INFO(("We are now new primary router in this cell"));
3275             server->id_entry->router = NULL;
3276             server->router = NULL;
3277             server->standalone = TRUE;
3278           }
3279
3280           /* We stop here to take a breath */
3281           sleep(2);
3282
3283           if (server->backup_router) {
3284             server->server_type = SILC_ROUTER;
3285
3286             /* We'll need to constantly try to reconnect to the primary
3287                router so that we'll see when it comes back online. */
3288             silc_server_create_connection(server, TRUE, FALSE, ip, port,
3289                                          silc_server_backup_connected,
3290                                          NULL);
3291           }
3292
3293           /* Mark this connection as replaced */
3294           silc_server_backup_replaced_add(server, user_data->id,
3295                                           backup_router);
3296         }
3297       } else if (backup_router) {
3298         SILC_LOG_INFO(("Enabling the use of backup router %s",
3299                        backup_router->server_name));
3300
3301         /* Mark this connection as replaced */
3302         silc_server_backup_replaced_add(server, user_data->id,
3303                                         backup_router);
3304       } else if (server->server_type == SILC_SERVER &&
3305                  idata->conn_type == SILC_CONN_ROUTER) {
3306         /* Reconnect to the router (backup) */
3307         if (!server->no_reconnect)
3308           silc_server_create_connections(server);
3309       }
3310
3311       if (user_data->server_name)
3312         SILC_SERVER_SEND_OPERS(server, FALSE, TRUE, SILC_NOTIFY_TYPE_NONE,
3313                                ("Server %s signoff", user_data->server_name));
3314
3315       if (!backup_router) {
3316         /* Remove all servers that are originated from this server, and
3317            remove the clients of those servers too. */
3318         silc_server_remove_servers_by_server(server, user_data, TRUE);
3319
3320 #if 0
3321         /* Remove the clients that this server owns as they will become
3322            invalid now too.  For backup router the server is actually
3323            coming from the primary router, so mark that as the owner
3324            of this entry. */
3325         if (server->server_type == SILC_BACKUP_ROUTER &&
3326             sock->type == SILC_CONN_SERVER)
3327           silc_server_remove_clients_by_server(server, server->router,
3328                                                user_data, TRUE);
3329         else
3330 #endif
3331           silc_server_remove_clients_by_server(server, user_data,
3332                                                user_data, TRUE);
3333
3334         /* Remove channels owned by this server */
3335         if (server->server_type == SILC_SERVER)
3336           silc_server_remove_channels_by_server(server, user_data);
3337       } else {
3338         /* Enable local server connections that may be disabled */
3339         silc_server_local_servers_toggle_enabled(server, TRUE);
3340
3341         /* Update the client entries of this server to the new backup
3342            router.  If we are the backup router we also resolve the real
3343            servers for the clients.  After updating is over this also
3344            removes the clients that this server explicitly owns. */
3345         silc_server_update_clients_by_server(server, user_data,
3346                                              backup_router, TRUE);
3347
3348         /* If we are router and just lost our primary router (now standlaone)
3349            we remove everything that was behind it, since we don't know
3350            any better. */
3351         if (server->server_type == SILC_ROUTER && server->standalone)
3352           /* Remove all servers that are originated from this server, and
3353              remove the clients of those servers too. */
3354           silc_server_remove_servers_by_server(server, user_data, TRUE);
3355
3356         /* Finally remove the clients that are explicitly owned by this
3357            server.  They go down with the server. */
3358         silc_server_remove_clients_by_server(server, user_data,
3359                                              user_data, TRUE);
3360
3361         /* Update our server cache to use the new backup router too. */
3362         silc_server_update_servers_by_server(server, user_data, backup_router);
3363         if (server->server_type == SILC_SERVER)
3364           silc_server_update_channels_by_server(server, user_data,
3365                                                 backup_router);
3366
3367         /* Send notify about primary router going down to local operators */
3368         if (server->backup_router)
3369           SILC_SERVER_SEND_OPERS(server, FALSE, TRUE,
3370                                  SILC_NOTIFY_TYPE_NONE,
3371                                  ("%s switched to backup router %s "
3372                                   "(we are primary router now)",
3373                                   server->server_name, server->server_name));
3374         else if (server->router)
3375           SILC_SERVER_SEND_OPERS(server, FALSE, TRUE,
3376                                  SILC_NOTIFY_TYPE_NONE,
3377                                  ("%s switched to backup router %s",
3378                                   server->server_name,
3379                                   server->router->server_name));
3380       }
3381       server->backup_noswitch = FALSE;
3382
3383       if (idata->sconn) {
3384         silc_server_connection_free(idata->sconn);
3385         idata->sconn = NULL;
3386       }
3387
3388       /* Statistics */
3389       if (idata->conn_type == SILC_CONN_SERVER) {
3390         server->stat.my_servers--;
3391         server->stat.servers--;
3392         SILC_LOG_DEBUG(("my_servers %d", server->stat.my_servers));
3393       } else if (idata->conn_type == SILC_CONN_ROUTER) {
3394         server->stat.my_routers--;
3395         server->stat.routers--;
3396         SILC_LOG_DEBUG(("my_routers %d", server->stat.my_routers));
3397       }
3398       if (server->server_type == SILC_ROUTER)
3399         server->stat.cell_servers--;
3400
3401       /* Free the server entry */
3402       silc_server_backup_del(server, user_data);
3403       silc_server_backup_replaced_del(server, user_data);
3404       silc_idlist_del_data(user_data);
3405       if (!silc_idlist_del_server(server->local_list, user_data))
3406         silc_idlist_del_server(server->global_list, user_data);
3407
3408       if (backup_router && backup_router != server->id_entry) {
3409         /* Announce all of our stuff that was created about 5 minutes ago.
3410            The backup router knows all the other stuff already. */
3411         if (server->server_type == SILC_ROUTER)
3412           silc_server_announce_servers(server, FALSE, time(0) - 300,
3413                                        backup_router->connection);
3414
3415         /* Announce our clients and channels to the router */
3416         silc_server_announce_clients(server, time(0) - 300,
3417                                      backup_router->connection);
3418         silc_server_announce_channels(server, time(0) - 300,
3419                                       backup_router->connection);
3420       }
3421
3422       silc_packet_set_context(sock, NULL);
3423       break;
3424     }
3425
3426   default:
3427     {
3428       SilcUnknownEntry entry = (SilcUnknownEntry)idata;
3429
3430       SILC_LOG_DEBUG(("Freeing unknown connection data %p", entry));
3431
3432       if (idata->sconn) {
3433         if (server->router_conn == idata->sconn) {
3434           if (!server->no_reconnect)
3435             silc_server_create_connections(server);
3436           server->router_conn = NULL;
3437         }
3438
3439         silc_server_connection_free(idata->sconn);
3440         idata->sconn = NULL;
3441       }
3442       silc_idlist_del_data(idata);
3443       silc_free(entry);
3444       silc_packet_set_context(sock, NULL);
3445       break;
3446     }
3447   }
3448 }
3449
3450 /* Removes client from all channels it has joined. This is used when client
3451    connection is disconnected. If the client on a channel is last, the
3452    channel is removed as well. This sends the SIGNOFF notify types. */
3453
3454 void silc_server_remove_from_channels(SilcServer server,
3455                                       SilcPacketStream sock,
3456                                       SilcClientEntry client,
3457                                       SilcBool notify,
3458                                       const char *signoff_message,
3459                                       SilcBool keygen,
3460                                       SilcBool killed)
3461 {
3462   SilcChannelEntry channel;
3463   SilcChannelClientEntry chl;
3464   SilcHashTableList htl;
3465   SilcBuffer clidp = NULL;
3466
3467   if (!client)
3468     return;
3469
3470   if (notify && !client->id)
3471     notify = FALSE;
3472
3473   SILC_LOG_DEBUG(("Removing client %s from joined channels",
3474                   notify ? silc_id_render(client->id, SILC_ID_CLIENT) : ""));
3475
3476   if (notify) {
3477     clidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
3478     if (!clidp)
3479       notify = FALSE;
3480   }
3481
3482   /* Remove the client from all channels. The client is removed from
3483      the channels' user list. */
3484   silc_hash_table_list(client->channels, &htl);
3485   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
3486     channel = chl->channel;
3487
3488     /* Remove channel if this is last client leaving the channel, unless
3489        the channel is permanent. */
3490     if (server->server_type != SILC_SERVER &&
3491         silc_hash_table_count(channel->user_list) < 2) {
3492       silc_server_channel_delete(server, channel);
3493       continue;
3494     }
3495
3496     silc_hash_table_del(client->channels, channel);
3497     silc_hash_table_del(channel->user_list, client);
3498     channel->user_count--;
3499
3500     /* If there is no global users on the channel anymore mark the channel
3501        as local channel. Do not check if the removed client is local client. */
3502     if (server->server_type == SILC_SERVER && channel->global_users &&
3503         chl->client->router && !silc_server_channel_has_global(channel))
3504       channel->global_users = FALSE;
3505
3506     memset(chl, 'A', sizeof(*chl));
3507     silc_free(chl);
3508
3509     /* Update statistics */
3510     if (SILC_IS_LOCAL(client))
3511       server->stat.my_chanclients--;
3512     if (server->server_type == SILC_ROUTER) {
3513       server->stat.cell_chanclients--;
3514       server->stat.chanclients--;
3515     }
3516
3517     /* If there is not at least one local user on the channel then we don't
3518        need the channel entry anymore, we can remove it safely, unless the
3519        channel is permanent channel */
3520     if (server->server_type == SILC_SERVER &&
3521         !silc_server_channel_has_local(channel)) {
3522       /* Notify about leaving client if this channel has global users. */
3523       if (notify && channel->global_users)
3524         silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
3525                                            SILC_NOTIFY_TYPE_SIGNOFF,
3526                                            signoff_message ? 2 : 1,
3527                                            clidp->data, silc_buffer_len(clidp),
3528                                            signoff_message, signoff_message ?
3529                                            strlen(signoff_message) : 0);
3530
3531       silc_schedule_task_del_by_context(server->schedule, channel->rekey);
3532       silc_server_channel_delete(server, channel);
3533       continue;
3534     }
3535
3536     /* Send notify to channel about client leaving SILC and channel too */
3537     if (notify)
3538       silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
3539                                          SILC_NOTIFY_TYPE_SIGNOFF,
3540                                          signoff_message ? 2 : 1,
3541                                          clidp->data, silc_buffer_len(clidp),
3542                                          signoff_message, signoff_message ?
3543                                          strlen(signoff_message) : 0);
3544
3545     if (killed && clidp) {
3546       /* Remove the client from channel's invite list */
3547       if (channel->invite_list &&
3548           silc_hash_table_count(channel->invite_list)) {
3549         SilcBuffer ab;
3550         SilcArgumentPayload iargs;
3551         ab = silc_argument_payload_encode_one(NULL, clidp->data,
3552                                               silc_buffer_len(clidp), 3);
3553         iargs = silc_argument_payload_parse(ab->data, silc_buffer_len(ab), 1);
3554         silc_server_inviteban_process(server, channel->invite_list, 1, iargs);
3555         silc_buffer_free(ab);
3556         silc_argument_payload_free(iargs);
3557       }
3558     }
3559
3560     /* Don't create keys if we are shutting down */
3561     if (server->server_shutdown)
3562       continue;
3563
3564     /* Re-generate channel key if needed */
3565     if (keygen && !(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
3566       if (!silc_server_create_channel_key(server, channel, 0))
3567         continue;
3568
3569       /* Send the channel key to the channel. The key of course is not sent
3570          to the client who was removed from the channel. */
3571       silc_server_send_channel_key(server, client->connection, channel,
3572                                    server->server_type == SILC_ROUTER ?
3573                                    FALSE : !server->standalone);
3574     }
3575   }
3576
3577   silc_hash_table_list_reset(&htl);
3578   if (clidp)
3579     silc_buffer_free(clidp);
3580 }
3581
3582 /* Removes client from one channel. This is used for example when client
3583    calls LEAVE command to remove itself from the channel. Returns TRUE
3584    if channel still exists and FALSE if the channel is removed when
3585    last client leaves the channel. If `notify' is FALSE notify messages
3586    are not sent. */
3587
3588 SilcBool silc_server_remove_from_one_channel(SilcServer server,
3589                                          SilcPacketStream sock,
3590                                          SilcChannelEntry channel,
3591                                          SilcClientEntry client,
3592                                          SilcBool notify)
3593 {
3594   SilcChannelClientEntry chl;
3595   SilcBuffer clidp;
3596
3597   SILC_LOG_DEBUG(("Removing %s from channel %s",
3598                   silc_id_render(client->id, SILC_ID_CLIENT),
3599                   channel->channel_name));
3600
3601   /* Get the entry to the channel, if this client is not on the channel
3602      then return Ok. */
3603   if (!silc_hash_table_find(client->channels, channel, NULL, (void *)&chl))
3604     return TRUE;
3605
3606   /* Remove channel if this is last client leaving the channel, unless
3607      the channel is permanent. */
3608   if (server->server_type != SILC_SERVER &&
3609       silc_hash_table_count(channel->user_list) < 2) {
3610     silc_server_channel_delete(server, channel);
3611     return FALSE;
3612   }
3613
3614   silc_hash_table_del(client->channels, channel);
3615   silc_hash_table_del(channel->user_list, client);
3616   channel->user_count--;
3617
3618   /* If there is no global users on the channel anymore mark the channel
3619      as local channel. Do not check if the client is local client. */
3620   if (server->server_type == SILC_SERVER && channel->global_users &&
3621       chl->client->router && !silc_server_channel_has_global(channel))
3622     channel->global_users = FALSE;
3623
3624   memset(chl, 'O', sizeof(*chl));
3625   silc_free(chl);
3626
3627   /* Update statistics */
3628   if (SILC_IS_LOCAL(client))
3629     server->stat.my_chanclients--;
3630   if (server->server_type == SILC_ROUTER) {
3631     server->stat.cell_chanclients--;
3632     server->stat.chanclients--;
3633   }
3634
3635   clidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
3636   if (!clidp)
3637     notify = FALSE;
3638
3639   /* If there is not at least one local user on the channel then we don't
3640      need the channel entry anymore, we can remove it safely, unless the
3641      channel is permanent channel */
3642   if (server->server_type == SILC_SERVER &&
3643       !silc_server_channel_has_local(channel)) {
3644     /* Notify about leaving client if this channel has global users. */
3645     if (notify && channel->global_users)
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_schedule_task_del_by_context(server->schedule, channel->rekey);
3651     silc_server_channel_delete(server, channel);
3652     silc_buffer_free(clidp);
3653     return FALSE;
3654   }
3655
3656   /* Send notify to channel about client leaving the channel */
3657   if (notify)
3658     silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
3659                                        SILC_NOTIFY_TYPE_LEAVE, 1,
3660                                        clidp->data, silc_buffer_len(clidp));
3661
3662   silc_buffer_free(clidp);
3663   return TRUE;
3664 }
3665
3666 /* Creates new channel. Sends NEW_CHANNEL packet to primary route. This
3667    function may be used only by router. In real SILC network all channels
3668    are created by routers thus this function is never used by normal
3669    server. */
3670
3671 SilcChannelEntry silc_server_create_new_channel(SilcServer server,
3672                                                 SilcServerID *router_id,
3673                                                 char *cipher,
3674                                                 char *hmac,
3675                                                 char *channel_name,
3676                                                 int broadcast)
3677 {
3678   SilcChannelID *channel_id;
3679   SilcChannelEntry entry;
3680   SilcCipher send_key, receive_key;
3681   SilcHmac newhmac;
3682
3683   SILC_LOG_DEBUG(("Creating new channel %s", channel_name));
3684
3685   if (!cipher)
3686     cipher = SILC_DEFAULT_CIPHER;
3687   if (!hmac)
3688     hmac = SILC_DEFAULT_HMAC;
3689
3690   /* Allocate cipher */
3691   if (!silc_cipher_alloc(cipher, &send_key))
3692     return NULL;
3693   if (!silc_cipher_alloc(cipher, &receive_key)) {
3694     silc_cipher_free(send_key);
3695     return NULL;
3696   }
3697
3698   /* Allocate hmac */
3699   if (!silc_hmac_alloc(hmac, NULL, &newhmac)) {
3700     silc_cipher_free(send_key);
3701     silc_cipher_free(receive_key);
3702     return NULL;
3703   }
3704
3705   channel_name = strdup(channel_name);
3706
3707   /* Create the channel ID */
3708   if (!silc_id_create_channel_id(server, router_id, server->rng,
3709                                  &channel_id)) {
3710     silc_free(channel_name);
3711     silc_cipher_free(send_key);
3712     silc_cipher_free(receive_key);
3713     silc_hmac_free(newhmac);
3714     return NULL;
3715   }
3716
3717   /* Create the channel */
3718   entry = silc_idlist_add_channel(server->local_list, channel_name,
3719                                   SILC_CHANNEL_MODE_NONE, channel_id,
3720                                   NULL, send_key, receive_key, newhmac);
3721   if (!entry) {
3722     silc_free(channel_name);
3723     silc_cipher_free(send_key);
3724     silc_cipher_free(receive_key);
3725     silc_hmac_free(newhmac);
3726     silc_free(channel_id);
3727     return NULL;
3728   }
3729
3730   entry->cipher = strdup(cipher);
3731   entry->hmac_name = strdup(hmac);
3732
3733   /* Now create the actual key material */
3734   if (!silc_server_create_channel_key(server, entry,
3735                                       silc_cipher_get_key_len(send_key) / 8)) {
3736     silc_idlist_del_channel(server->local_list, entry);
3737     return NULL;
3738   }
3739
3740   /* Notify other routers about the new channel. We send the packet
3741      to our primary route. */
3742   if (broadcast)
3743     silc_server_send_new_channel(server, SILC_PRIMARY_ROUTE(server), TRUE,
3744                                  channel_name, entry->id,
3745                                  silc_id_get_len(entry->id, SILC_ID_CHANNEL),
3746                                  entry->mode);
3747
3748   /* Distribute to backup routers */
3749   if (broadcast && server->server_type == SILC_ROUTER) {
3750     SilcBuffer packet;
3751     unsigned char cid[32];
3752     SilcUInt32 name_len = strlen(channel_name);
3753     SilcUInt32 id_len;
3754
3755     silc_id_id2str(entry->id, SILC_ID_CHANNEL, cid, sizeof(cid), &id_len);
3756     packet = silc_channel_payload_encode(channel_name, name_len,
3757                                          cid, id_len, entry->mode);
3758     silc_server_backup_send(server, NULL, SILC_PACKET_NEW_CHANNEL, 0,
3759                             packet->data, silc_buffer_len(packet), FALSE,
3760                             TRUE);
3761     silc_buffer_free(packet);
3762   }
3763
3764   server->stat.my_channels++;
3765   if (server->server_type == SILC_ROUTER) {
3766     server->stat.channels++;
3767     server->stat.cell_channels++;
3768     entry->users_resolved = TRUE;
3769   }
3770
3771   return entry;
3772 }
3773
3774 /* Same as above but creates the channel with Channel ID `channel_id. */
3775
3776 SilcChannelEntry
3777 silc_server_create_new_channel_with_id(SilcServer server,
3778                                        char *cipher,
3779                                        char *hmac,
3780                                        char *channel_name,
3781                                        SilcChannelID *channel_id,
3782                                        int broadcast)
3783 {
3784   SilcChannelEntry entry;
3785   SilcCipher send_key, receive_key;
3786   SilcHmac newhmac;
3787
3788   SILC_LOG_DEBUG(("Creating new channel %s", channel_name));
3789
3790   if (!cipher)
3791     cipher = SILC_DEFAULT_CIPHER;
3792   if (!hmac)
3793     hmac = SILC_DEFAULT_HMAC;
3794
3795   /* Allocate cipher */
3796   if (!silc_cipher_alloc(cipher, &send_key))
3797     return NULL;
3798   if (!silc_cipher_alloc(cipher, &receive_key)) {
3799     silc_cipher_free(send_key);
3800     return NULL;
3801   }
3802
3803   /* Allocate hmac */
3804   if (!silc_hmac_alloc(hmac, NULL, &newhmac)) {
3805     silc_cipher_free(send_key);
3806     silc_cipher_free(receive_key);
3807     return NULL;
3808   }
3809
3810   channel_name = strdup(channel_name);
3811
3812   /* Create the channel */
3813   entry = silc_idlist_add_channel(server->local_list, channel_name,
3814                                   SILC_CHANNEL_MODE_NONE, channel_id,
3815                                   NULL, send_key, receive_key, newhmac);
3816   if (!entry) {
3817     silc_cipher_free(send_key);
3818     silc_cipher_free(receive_key);
3819     silc_hmac_free(newhmac);
3820     silc_free(channel_name);
3821     return NULL;
3822   }
3823
3824   /* Now create the actual key material */
3825   if (!silc_server_create_channel_key(server, entry,
3826                                       silc_cipher_get_key_len(send_key) / 8)) {
3827     silc_idlist_del_channel(server->local_list, entry);
3828     return NULL;
3829   }
3830
3831   /* Notify other routers about the new channel. We send the packet
3832      to our primary route. */
3833   if (broadcast)
3834     silc_server_send_new_channel(server, SILC_PRIMARY_ROUTE(server), TRUE,
3835                                  channel_name, entry->id,
3836                                  silc_id_get_len(entry->id, SILC_ID_CHANNEL),
3837                                  entry->mode);
3838
3839   /* Distribute to backup routers */
3840   if (broadcast && server->server_type == SILC_ROUTER) {
3841     SilcBuffer packet;
3842     unsigned char cid[32];
3843     SilcUInt32 name_len = strlen(channel_name);
3844     SilcUInt32 id_len;
3845
3846     silc_id_id2str(entry->id, SILC_ID_CHANNEL, cid, sizeof(cid), &id_len);
3847     packet = silc_channel_payload_encode(channel_name, name_len,
3848                                          cid, id_len, entry->mode);
3849     silc_server_backup_send(server, NULL, SILC_PACKET_NEW_CHANNEL, 0,
3850                             packet->data, silc_buffer_len(packet), FALSE,
3851                             TRUE);
3852     silc_buffer_free(packet);
3853   }
3854
3855   server->stat.my_channels++;
3856   if (server->server_type == SILC_ROUTER) {
3857     server->stat.channels++;
3858     server->stat.cell_channels++;
3859     entry->users_resolved = TRUE;
3860   }
3861
3862   return entry;
3863 }
3864
3865 /* Channel's key re-key timeout callback. */
3866
3867 SILC_TASK_CALLBACK(silc_server_channel_key_rekey)
3868 {
3869   SilcServer server = app_context;
3870   SilcServerChannelRekey rekey = (SilcServerChannelRekey)context;
3871
3872   rekey->task = NULL;
3873
3874   /* Return now if we are shutting down */
3875   if (server->server_shutdown)
3876     return;
3877
3878   if (!silc_server_create_channel_key(server, rekey->channel, rekey->key_len))
3879     return;
3880
3881   silc_server_send_channel_key(server, NULL, rekey->channel, FALSE);
3882 }
3883
3884 /* Generates new channel key. This is used to create the initial channel key
3885    but also to re-generate new key for channel. If `key_len' is provided
3886    it is the bytes of the key length. */
3887
3888 SilcBool silc_server_create_channel_key(SilcServer server,
3889                                         SilcChannelEntry channel,
3890                                         SilcUInt32 key_len)
3891 {
3892   int i;
3893   unsigned char channel_key[32], hash[SILC_HASH_MAXLEN];
3894   SilcUInt32 len;
3895
3896   if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY) {
3897     SILC_LOG_DEBUG(("Channel has private keys, will not generate new key"));
3898     return TRUE;
3899   }
3900
3901   SILC_LOG_DEBUG(("Generating channel %s key", channel->channel_name));
3902
3903   if (!channel->send_key)
3904     if (!silc_cipher_alloc(SILC_DEFAULT_CIPHER, &channel->send_key)) {
3905       channel->send_key = NULL;
3906       return FALSE;
3907     }
3908   if (!channel->receive_key)
3909     if (!silc_cipher_alloc(SILC_DEFAULT_CIPHER, &channel->receive_key)) {
3910       silc_cipher_free(channel->send_key);
3911       channel->send_key = channel->receive_key = NULL;
3912       return FALSE;
3913     }
3914
3915   if (key_len)
3916     len = key_len;
3917   else if (channel->key_len)
3918     len = channel->key_len / 8;
3919   else
3920     len = silc_cipher_get_key_len(channel->send_key) / 8;
3921
3922   /* Create channel key */
3923   for (i = 0; i < len; i++) channel_key[i] = silc_rng_get_byte(server->rng);
3924
3925   /* Set the key */
3926   silc_cipher_set_key(channel->send_key, channel_key, len * 8, TRUE);
3927   silc_cipher_set_key(channel->receive_key, channel_key, len * 8, FALSE);
3928
3929   /* Remove old key if exists */
3930   if (channel->key) {
3931     memset(channel->key, 0, channel->key_len / 8);
3932     silc_free(channel->key);
3933   }
3934
3935   /* Save the key */
3936   channel->key_len = len * 8;
3937   channel->key = silc_memdup(channel_key, len);
3938   memset(channel_key, 0, sizeof(channel_key));
3939
3940   /* Generate HMAC key from the channel key data and set it */
3941   if (!channel->hmac)
3942     if (!silc_hmac_alloc(SILC_DEFAULT_HMAC, NULL, &channel->hmac)) {
3943       memset(channel->key, 0, channel->key_len / 8);
3944       silc_free(channel->key);
3945       silc_cipher_free(channel->send_key);
3946       silc_cipher_free(channel->receive_key);
3947       channel->send_key = channel->receive_key = NULL;
3948       return FALSE;
3949     }
3950   silc_hash_make(silc_hmac_get_hash(channel->hmac), channel->key, len, hash);
3951   silc_hmac_set_key(channel->hmac, hash,
3952                     silc_hash_len(silc_hmac_get_hash(channel->hmac)));
3953   memset(hash, 0, sizeof(hash));
3954
3955   if (server->server_type == SILC_ROUTER) {
3956     if (!channel->rekey)
3957       channel->rekey = silc_calloc(1, sizeof(*channel->rekey));
3958     channel->rekey->channel = channel;
3959     channel->rekey->key_len = key_len;
3960     if (channel->rekey->task)
3961       silc_schedule_task_del(server->schedule, channel->rekey->task);
3962
3963     channel->rekey->task =
3964       silc_schedule_task_add_timeout(server->schedule,
3965                                      silc_server_channel_key_rekey,
3966                                      (void *)channel->rekey,
3967                                      server->config->channel_rekey_secs, 0);
3968   }
3969
3970   return TRUE;
3971 }
3972
3973 /* Saves the channel key found in the encoded `key_payload' buffer. This
3974    function is used when we receive Channel Key Payload and also when we're
3975    processing JOIN command reply. Returns entry to the channel. */
3976
3977 SilcChannelEntry silc_server_save_channel_key(SilcServer server,
3978                                               SilcBuffer key_payload,
3979                                               SilcChannelEntry channel)
3980 {
3981   SilcChannelKeyPayload payload = NULL;
3982   SilcChannelID id;
3983   unsigned char *tmp, hash[SILC_HASH_MAXLEN];
3984   SilcUInt32 tmp_len;
3985   char *cipher;
3986
3987   /* Decode channel key payload */
3988   payload = silc_channel_key_payload_parse(key_payload->data,
3989                                            silc_buffer_len(key_payload));
3990   if (!payload) {
3991     SILC_LOG_ERROR(("Bad channel key payload received, dropped"));
3992     channel = NULL;
3993     goto out;
3994   }
3995
3996   /* Get the channel entry */
3997   if (!channel) {
3998
3999     /* Get channel ID */
4000     tmp = silc_channel_key_get_id(payload, &tmp_len);
4001     if (!silc_id_str2id(tmp, tmp_len, SILC_ID_CHANNEL, &id, sizeof(id))) {
4002       channel = NULL;
4003       goto out;
4004     }
4005
4006     channel = silc_idlist_find_channel_by_id(server->local_list, &id, NULL);
4007     if (!channel) {
4008       channel = silc_idlist_find_channel_by_id(server->global_list, &id, NULL);
4009       if (!channel) {
4010         if (server->server_type == SILC_ROUTER)
4011           SILC_LOG_ERROR(("Received key for non-existent channel %s",
4012                           silc_id_render(&id, SILC_ID_CHANNEL)));
4013         goto out;
4014       }
4015     }
4016   }
4017
4018   SILC_LOG_DEBUG(("Saving new channel %s key", channel->channel_name));
4019
4020   tmp = silc_channel_key_get_key(payload, &tmp_len);
4021   if (!tmp) {
4022     channel = NULL;
4023     goto out;
4024   }
4025
4026   cipher = silc_channel_key_get_cipher(payload, NULL);
4027   if (!cipher) {
4028     channel = NULL;
4029     goto out;
4030   }
4031
4032   /* Remove old key if exists */
4033   if (channel->key) {
4034     memset(channel->key, 0, channel->key_len / 8);
4035     silc_free(channel->key);
4036     silc_cipher_free(channel->send_key);
4037     silc_cipher_free(channel->receive_key);
4038   }
4039
4040   /* Create new cipher */
4041   if (!silc_cipher_alloc(cipher, &channel->send_key)) {
4042     channel->send_key = NULL;
4043     channel = NULL;
4044     goto out;
4045   }
4046   if (!silc_cipher_alloc(cipher, &channel->receive_key)) {
4047     silc_cipher_free(channel->send_key);
4048     channel->send_key = channel->receive_key = NULL;
4049     channel = NULL;
4050     goto out;
4051   }
4052
4053   if (channel->cipher)
4054     silc_free(channel->cipher);
4055   channel->cipher = strdup(cipher);
4056
4057   /* Save the key */
4058   channel->key_len = tmp_len * 8;
4059   channel->key = silc_memdup(tmp, tmp_len);
4060   silc_cipher_set_key(channel->send_key, tmp, channel->key_len, TRUE);
4061   silc_cipher_set_key(channel->receive_key, tmp, channel->key_len, FALSE);
4062
4063   /* Generate HMAC key from the channel key data and set it */
4064   if (!channel->hmac)
4065     if (!silc_hmac_alloc(SILC_DEFAULT_HMAC, NULL, &channel->hmac)) {
4066       memset(channel->key, 0, channel->key_len / 8);
4067       silc_free(channel->key);
4068       silc_cipher_free(channel->send_key);
4069       silc_cipher_free(channel->receive_key);
4070       channel->send_key = channel->receive_key = NULL;
4071       return FALSE;
4072     }
4073   silc_hash_make(silc_hmac_get_hash(channel->hmac), tmp, tmp_len, hash);
4074   silc_hmac_set_key(channel->hmac, hash,
4075                     silc_hash_len(silc_hmac_get_hash(channel->hmac)));
4076
4077   memset(hash, 0, sizeof(hash));
4078   memset(tmp, 0, tmp_len);
4079
4080   if (server->server_type == SILC_ROUTER) {
4081     if (!channel->rekey)
4082       channel->rekey = silc_calloc(1, sizeof(*channel->rekey));
4083     channel->rekey->channel = channel;
4084     if (channel->rekey->task)
4085       silc_schedule_task_del(server->schedule, channel->rekey->task);
4086
4087     channel->rekey->task =
4088       silc_schedule_task_add_timeout(server->schedule,
4089                                      silc_server_channel_key_rekey,
4090                                      (void *)channel->rekey,
4091                                      server->config->channel_rekey_secs, 0);
4092   }
4093
4094  out:
4095   if (payload)
4096     silc_channel_key_payload_free(payload);
4097
4098   return channel;
4099 }
4100
4101 /* Returns assembled of all servers in the given ID list. The packet's
4102    form is dictated by the New ID payload. */
4103
4104 static void silc_server_announce_get_servers(SilcServer server,
4105                                              SilcServerEntry remote,
4106                                              SilcIDList id_list,
4107                                              SilcBuffer *servers,
4108                                              unsigned long creation_time)
4109 {
4110   SilcList list;
4111   SilcIDCacheEntry id_cache;
4112   SilcServerEntry entry;
4113   SilcBuffer idp;
4114   void *tmp;
4115
4116   /* Go through all clients in the list */
4117   if (silc_idcache_get_all(id_list->servers, &list)) {
4118     silc_list_start(list);
4119     while ((id_cache = silc_list_get(list))) {
4120       entry = (SilcServerEntry)id_cache->context;
4121
4122       /* Do not announce the one we've sending our announcements and
4123          do not announce ourself. Also check the creation time if it's
4124          provided. */
4125       if ((entry == remote) || (entry == server->id_entry) ||
4126           (creation_time && entry->data.created < creation_time))
4127         continue;
4128
4129       idp = silc_id_payload_encode(entry->id, SILC_ID_SERVER);
4130
4131       tmp = silc_buffer_realloc(*servers,
4132                                 (*servers ?
4133                                  silc_buffer_truelen((*servers)) +
4134                                  silc_buffer_len(idp) :
4135                                  silc_buffer_len(idp)));
4136       if (!tmp)
4137         return;
4138       *servers = tmp;
4139       silc_buffer_pull_tail(*servers, ((*servers)->end - (*servers)->data));
4140       silc_buffer_put(*servers, idp->data, silc_buffer_len(idp));
4141       silc_buffer_pull(*servers, silc_buffer_len(idp));
4142       silc_buffer_free(idp);
4143     }
4144   }
4145 }
4146
4147 static SilcBuffer
4148 silc_server_announce_encode_notify(SilcNotifyType notify, SilcUInt32 argc, ...)
4149 {
4150   va_list ap;
4151   SilcBuffer p;
4152
4153   va_start(ap, argc);
4154   p = silc_notify_payload_encode(notify, argc, ap);
4155   va_end(ap);
4156
4157   return p;
4158 }
4159
4160 /* This function is used by router to announce existing servers to our
4161    primary router when we've connected to it. If `creation_time' is non-zero
4162    then only the servers that has been created after the `creation_time'
4163    will be announced. */
4164
4165 void silc_server_announce_servers(SilcServer server, SilcBool global,
4166                                   unsigned long creation_time,
4167                                   SilcPacketStream remote)
4168 {
4169   SilcBuffer servers = NULL;
4170
4171   SILC_LOG_DEBUG(("Announcing servers"));
4172
4173   /* Get servers in local list */
4174   silc_server_announce_get_servers(server, silc_packet_get_context(remote),
4175                                    server->local_list, &servers,
4176                                    creation_time);
4177
4178   if (global)
4179     /* Get servers in global list */
4180     silc_server_announce_get_servers(server, silc_packet_get_context(remote),
4181                                      server->global_list, &servers,
4182                                      creation_time);
4183
4184   if (servers) {
4185     silc_buffer_push(servers, servers->data - servers->head);
4186     SILC_LOG_HEXDUMP(("servers"), servers->data, silc_buffer_len(servers));
4187
4188     /* Send the packet */
4189     silc_server_packet_send(server, remote,
4190                             SILC_PACKET_NEW_ID, SILC_PACKET_FLAG_LIST,
4191                             servers->data, silc_buffer_len(servers));
4192
4193     silc_buffer_free(servers);
4194   }
4195 }
4196
4197 /* Returns assembled packet of all clients in the given ID list. The
4198    packet's form is dictated by the New ID Payload. */
4199
4200 static void silc_server_announce_get_clients(SilcServer server,
4201                                              SilcIDList id_list,
4202                                              SilcBuffer *clients,
4203                                              SilcBuffer *umodes,
4204                                              unsigned long creation_time)
4205 {
4206   SilcList list;
4207   SilcIDCacheEntry id_cache;
4208   SilcClientEntry client;
4209   SilcBuffer idp;
4210   SilcBuffer tmp;
4211   unsigned char mode[4];
4212   void *tmp2;
4213
4214   /* Go through all clients in the list */
4215   if (silc_idcache_get_all(id_list->clients, &list)) {
4216     silc_list_start(list);
4217     while ((id_cache = silc_list_get(list))) {
4218       client = (SilcClientEntry)id_cache->context;
4219
4220       if (creation_time && client->data.created < creation_time)
4221         continue;
4222       if (!(client->data.status & SILC_IDLIST_STATUS_REGISTERED))
4223         continue;
4224       if (!client->connection && !client->router)
4225         continue;
4226
4227       SILC_LOG_DEBUG(("Announce Client ID %s",
4228                       silc_id_render(client->id, SILC_ID_CLIENT)));
4229
4230       idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
4231       if (!idp)
4232         return;
4233
4234       tmp2 = silc_buffer_realloc(*clients,
4235                                 (*clients ?
4236                                  silc_buffer_truelen((*clients)) +
4237                                  silc_buffer_len(idp) :
4238                                  silc_buffer_len(idp)));
4239       if (!tmp2)
4240         return;
4241       *clients = tmp2;
4242       silc_buffer_pull_tail(*clients, ((*clients)->end - (*clients)->data));
4243       silc_buffer_put(*clients, idp->data, silc_buffer_len(idp));
4244       silc_buffer_pull(*clients, silc_buffer_len(idp));
4245
4246       SILC_PUT32_MSB(client->mode, mode);
4247       tmp =
4248         silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_UMODE_CHANGE,
4249                                            2, idp->data, silc_buffer_len(idp),
4250                                            mode, 4);
4251       tmp2 = silc_buffer_realloc(*umodes,
4252                                  (*umodes ?
4253                                   silc_buffer_truelen((*umodes)) +
4254                                   silc_buffer_len(tmp) :
4255                                   silc_buffer_len(tmp)));
4256       if (!tmp2)
4257         return;
4258       *umodes = tmp2;
4259       silc_buffer_pull_tail(*umodes, ((*umodes)->end - (*umodes)->data));
4260       silc_buffer_put(*umodes, tmp->data, silc_buffer_len(tmp));
4261       silc_buffer_pull(*umodes, silc_buffer_len(tmp));
4262       silc_buffer_free(tmp);
4263
4264       silc_buffer_free(idp);
4265     }
4266   }
4267 }
4268
4269 /* This function is used to announce our existing clients to our router
4270    when we've connected to it. If `creation_time' is non-zero then only
4271    the clients that has been created after the `creation_time' will be
4272    announced. */
4273
4274 void silc_server_announce_clients(SilcServer server,
4275                                   unsigned long creation_time,
4276                                   SilcPacketStream remote)
4277 {
4278   SilcBuffer clients = NULL;
4279   SilcBuffer umodes = NULL;
4280
4281   SILC_LOG_DEBUG(("Announcing clients"));
4282
4283   /* Get clients in local list */
4284   silc_server_announce_get_clients(server, server->local_list,
4285                                    &clients, &umodes, creation_time);
4286
4287   /* As router we announce our global list as well */
4288   if (server->server_type == SILC_ROUTER)
4289     silc_server_announce_get_clients(server, server->global_list,
4290                                      &clients, &umodes, creation_time);
4291
4292   if (clients) {
4293     silc_buffer_push(clients, clients->data - clients->head);
4294     SILC_LOG_HEXDUMP(("clients"), clients->data, silc_buffer_len(clients));
4295
4296     /* Send the packet */
4297     silc_server_packet_send(server, remote,
4298                             SILC_PACKET_NEW_ID, SILC_PACKET_FLAG_LIST,
4299                             clients->data, silc_buffer_len(clients));
4300
4301     silc_buffer_free(clients);
4302   }
4303
4304   if (umodes) {
4305     silc_buffer_push(umodes, umodes->data - umodes->head);
4306     SILC_LOG_HEXDUMP(("umodes"), umodes->data, silc_buffer_len(umodes));
4307
4308     /* Send the packet */
4309     silc_server_packet_send(server, remote,
4310                             SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4311                             umodes->data, silc_buffer_len(umodes));
4312
4313     silc_buffer_free(umodes);
4314   }
4315 }
4316
4317 /* Returns channel's topic for announcing it */
4318
4319 void silc_server_announce_get_channel_topic(SilcServer server,
4320                                             SilcChannelEntry channel,
4321                                             SilcBuffer *topic)
4322 {
4323   SilcBuffer chidp;
4324
4325   if (channel->topic) {
4326     chidp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL);
4327     *topic = silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_TOPIC_SET, 2,
4328                                                 chidp->data,
4329                                                 silc_buffer_len(chidp),
4330                                                 channel->topic,
4331                                                 strlen(channel->topic));
4332     silc_buffer_free(chidp);
4333   }
4334 }
4335
4336 /* Returns channel's invite and ban lists */
4337
4338 void silc_server_announce_get_inviteban(SilcServer server,
4339                                         SilcChannelEntry channel,
4340                                         SilcBuffer *invite,
4341                                         SilcBuffer *ban)
4342 {
4343   SilcBuffer list, idp, idp2, tmp2;
4344   SilcUInt32 type;
4345   void *ptype;
4346   SilcHashTableList htl;
4347   const unsigned char a[1] = { 0x03 };
4348
4349   idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
4350
4351   /* Encode invite list */
4352   if (channel->invite_list && silc_hash_table_count(channel->invite_list)) {
4353     list = silc_buffer_alloc_size(2);
4354     type = silc_hash_table_count(channel->invite_list);
4355     SILC_PUT16_MSB(type, list->data);
4356     silc_hash_table_list(channel->invite_list, &htl);
4357     while (silc_hash_table_get(&htl, (void *)&ptype, (void *)&tmp2))
4358       list = silc_argument_payload_encode_one(list, tmp2->data,
4359                                               silc_buffer_len(tmp2),
4360                                               SILC_PTR_TO_32(ptype));
4361     silc_hash_table_list_reset(&htl);
4362
4363     idp2 = silc_id_payload_encode(server->id, SILC_ID_SERVER);
4364     *invite =
4365       silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_INVITE, 5,
4366                                          idp->data, silc_buffer_len(idp),
4367                                          channel->channel_name,
4368                                          strlen(channel->channel_name),
4369                                          idp2->data, silc_buffer_len(idp2),
4370                                          a, 1,
4371                                          list->data, silc_buffer_len(list));
4372     silc_buffer_free(idp2);
4373     silc_buffer_free(list);
4374   }
4375
4376   /* Encode ban list */
4377   if (channel->ban_list && silc_hash_table_count(channel->ban_list)) {
4378     list = silc_buffer_alloc_size(2);
4379     type = silc_hash_table_count(channel->ban_list);
4380     SILC_PUT16_MSB(type, list->data);
4381     silc_hash_table_list(channel->ban_list, &htl);
4382     while (silc_hash_table_get(&htl, (void *)&ptype, (void *)&tmp2))
4383       list = silc_argument_payload_encode_one(list, tmp2->data,
4384                                               silc_buffer_len(tmp2),
4385                                               SILC_PTR_TO_32(ptype));
4386     silc_hash_table_list_reset(&htl);
4387
4388     *ban =
4389       silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_BAN, 3,
4390                                          idp->data, silc_buffer_len(idp),
4391                                          a, 1,
4392                                          list->data, silc_buffer_len(list));
4393     silc_buffer_free(list);
4394   }
4395
4396   silc_buffer_free(idp);
4397 }
4398
4399 /* Returns assembled packets for channel users of the `channel'. */
4400
4401 void silc_server_announce_get_channel_users(SilcServer server,
4402                                             SilcChannelEntry channel,
4403                                             SilcBuffer *channel_modes,
4404                                             SilcBuffer *channel_users,
4405                                             SilcBuffer *channel_users_modes)
4406 {
4407   SilcChannelClientEntry chl;
4408   SilcHashTableList htl;
4409   SilcBuffer chidp, clidp, csidp;
4410   SilcBuffer tmp, fkey = NULL, chpklist;
4411   int len;
4412   unsigned char mode[4], ulimit[4];
4413   char *hmac;
4414   void *tmp2;
4415
4416   SILC_LOG_DEBUG(("Start"));
4417
4418   chidp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL);
4419   csidp = silc_id_payload_encode(server->id, SILC_ID_SERVER);
4420   chpklist = silc_server_get_channel_pk_list(server, channel, TRUE, FALSE);
4421
4422   /* CMODE notify */
4423   SILC_PUT32_MSB(channel->mode, mode);
4424   if (channel->mode & SILC_CHANNEL_MODE_ULIMIT)
4425     SILC_PUT32_MSB(channel->user_limit, ulimit);
4426   hmac = channel->hmac ? (char *)silc_hmac_get_name(channel->hmac) : NULL;
4427   if (channel->founder_key)
4428     fkey = silc_public_key_payload_encode(channel->founder_key);
4429   tmp =
4430     silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_CMODE_CHANGE,
4431                                        8, csidp->data,
4432                                        silc_buffer_len(csidp),
4433                                        mode, sizeof(mode),
4434                                        NULL, 0,
4435                                        hmac, hmac ? strlen(hmac) : 0,
4436                                        channel->passphrase,
4437                                        channel->passphrase ?
4438                                        strlen(channel->passphrase) : 0,
4439                                        fkey ? fkey->data : NULL,
4440                                        fkey ? silc_buffer_len(fkey) : 0,
4441                                        chpklist ? chpklist->data : NULL,
4442                                        chpklist ?
4443                                        silc_buffer_len(chpklist) : 0,
4444                                        (channel->mode &
4445                                         SILC_CHANNEL_MODE_ULIMIT ?
4446                                         ulimit : NULL),
4447                                        (channel->mode &
4448                                         SILC_CHANNEL_MODE_ULIMIT ?
4449                                         sizeof(ulimit) : 0));
4450   len = silc_buffer_len(tmp);
4451   tmp2 =
4452     silc_buffer_realloc(*channel_modes,
4453                         (*channel_modes ?
4454                          silc_buffer_truelen((*channel_modes)) + len : len));
4455   if (!tmp2)
4456     return;
4457   *channel_modes = tmp2;
4458   silc_buffer_pull_tail(*channel_modes,
4459                         ((*channel_modes)->end -
4460                          (*channel_modes)->data));
4461   silc_buffer_put(*channel_modes, tmp->data, silc_buffer_len(tmp));
4462   silc_buffer_pull(*channel_modes, len);
4463   silc_buffer_free(tmp);
4464   silc_buffer_free(fkey);
4465   fkey = NULL;
4466
4467   /* Now find all users on the channel */
4468   silc_hash_table_list(channel->user_list, &htl);
4469   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
4470     clidp = silc_id_payload_encode(chl->client->id, SILC_ID_CLIENT);
4471
4472     SILC_LOG_DEBUG(("JOIN Client %s", silc_id_render(chl->client->id,
4473                                                      SILC_ID_CLIENT)));
4474
4475     /* JOIN Notify */
4476     tmp = silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_JOIN, 2,
4477                                              clidp->data,
4478                                              silc_buffer_len(clidp),
4479                                              chidp->data,
4480                                              silc_buffer_len(chidp));
4481     len = silc_buffer_len(tmp);
4482     tmp2 =
4483       silc_buffer_realloc(*channel_users,
4484                           (*channel_users ?
4485                            silc_buffer_truelen((*channel_users)) + len : len));
4486     if (!tmp2)
4487       return;
4488     *channel_users = tmp2;
4489     silc_buffer_pull_tail(*channel_users,
4490                           ((*channel_users)->end -
4491                            (*channel_users)->data));
4492
4493     silc_buffer_put(*channel_users, tmp->data, silc_buffer_len(tmp));
4494     silc_buffer_pull(*channel_users, len);
4495     silc_buffer_free(tmp);
4496
4497     /* CUMODE notify for mode change on the channel */
4498     SILC_PUT32_MSB(chl->mode, mode);
4499     if (chl->mode & SILC_CHANNEL_UMODE_CHANFO && channel->founder_key)
4500       fkey = silc_public_key_payload_encode(channel->founder_key);
4501     tmp = silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_CUMODE_CHANGE,
4502                                              4, csidp->data,
4503                                              silc_buffer_len(csidp),
4504                                              mode, sizeof(mode),
4505                                              clidp->data,
4506                                              silc_buffer_len(clidp),
4507                                              fkey ? fkey->data : NULL,
4508                                              fkey ? silc_buffer_len(fkey) : 0);
4509     len = silc_buffer_len(tmp);
4510     tmp2 =
4511       silc_buffer_realloc(*channel_users_modes,
4512                           (*channel_users_modes ?
4513                            silc_buffer_truelen((*channel_users_modes)) +
4514                            len : len));
4515     if (!tmp2)
4516       return;
4517     *channel_users_modes = tmp2;
4518     silc_buffer_pull_tail(*channel_users_modes,
4519                           ((*channel_users_modes)->end -
4520                            (*channel_users_modes)->data));
4521
4522     silc_buffer_put(*channel_users_modes, tmp->data, silc_buffer_len(tmp));
4523     silc_buffer_pull(*channel_users_modes, len);
4524     silc_buffer_free(tmp);
4525     silc_buffer_free(fkey);
4526     fkey = NULL;
4527     silc_buffer_free(clidp);
4528   }
4529   silc_hash_table_list_reset(&htl);
4530   silc_buffer_free(chidp);
4531   silc_buffer_free(csidp);
4532 }
4533
4534 /* Returns assembled packets for all channels and users on those channels
4535    from the given ID List. The packets are in the form dictated by the
4536    New Channel and New Channel User payloads. */
4537
4538 void silc_server_announce_get_channels(SilcServer server,
4539                                        SilcIDList id_list,
4540                                        SilcBuffer *channels,
4541                                        SilcBuffer **channel_modes,
4542                                        SilcBuffer *channel_users,
4543                                        SilcBuffer **channel_users_modes,
4544                                        SilcUInt32 *channel_users_modes_c,
4545                                        SilcBuffer **channel_topics,
4546                                        SilcBuffer **channel_invites,
4547                                        SilcBuffer **channel_bans,
4548                                        SilcChannelID ***channel_ids,
4549                                        unsigned long creation_time)
4550 {
4551   SilcList list;
4552   SilcIDCacheEntry id_cache;
4553   SilcChannelEntry channel;
4554   unsigned char cid[32];
4555   SilcUInt32 id_len;
4556   SilcUInt16 name_len;
4557   int len;
4558   int i = *channel_users_modes_c;
4559   void *tmp;
4560   SilcBool announce;
4561
4562   SILC_LOG_DEBUG(("Start"));
4563
4564   /* Go through all channels in the list */
4565   if (silc_idcache_get_all(id_list->channels, &list)) {
4566     silc_list_start(list);
4567     while ((id_cache = silc_list_get(list))) {
4568       channel = (SilcChannelEntry)id_cache->context;
4569
4570       if (creation_time && channel->created < creation_time)
4571         announce = FALSE;
4572       else
4573         announce = TRUE;
4574
4575       SILC_LOG_DEBUG(("Announce Channel ID %s",
4576                       silc_id_render(channel->id, SILC_ID_CHANNEL)));
4577
4578       silc_id_id2str(channel->id, SILC_ID_CHANNEL, cid, sizeof(cid), &id_len);
4579       name_len = strlen(channel->channel_name);
4580
4581       if (announce) {
4582         len = 4 + name_len + id_len + 4;
4583         tmp =
4584           silc_buffer_realloc(*channels,
4585                               (*channels ?
4586                                silc_buffer_truelen((*channels)) +
4587                                len : len));
4588         if (!tmp)
4589           break;
4590         *channels = tmp;
4591
4592         silc_buffer_pull_tail(*channels,
4593                               ((*channels)->end - (*channels)->data));
4594         silc_buffer_format(*channels,
4595                            SILC_STR_UI_SHORT(name_len),
4596                            SILC_STR_UI_XNSTRING(channel->channel_name,
4597                                                 name_len),
4598                            SILC_STR_UI_SHORT(id_len),
4599                              SILC_STR_UI_XNSTRING(cid, id_len),
4600                            SILC_STR_UI_INT(channel->mode),
4601                            SILC_STR_END);
4602         silc_buffer_pull(*channels, len);
4603       }
4604
4605       if (creation_time && channel->updated < creation_time)
4606         announce = FALSE;
4607       else
4608         announce = TRUE;
4609
4610       if (announce) {
4611         /* Channel user modes */
4612         tmp = silc_realloc(*channel_users_modes,
4613                             sizeof(**channel_users_modes) * (i + 1));
4614         if (!tmp)
4615           break;
4616         *channel_users_modes = tmp;
4617         (*channel_users_modes)[i] = NULL;
4618         tmp = silc_realloc(*channel_modes,
4619                            sizeof(**channel_modes) * (i + 1));
4620         if (!tmp)
4621           break;
4622         *channel_modes = tmp;
4623         (*channel_modes)[i] = NULL;
4624         tmp = silc_realloc(*channel_ids,
4625                            sizeof(**channel_ids) * (i + 1));
4626         if (!tmp)
4627           break;
4628         *channel_ids = tmp;
4629         (*channel_ids)[i] = NULL;
4630         silc_server_announce_get_channel_users(server, channel,
4631                                                &(*channel_modes)[i],
4632                                                channel_users,
4633                                                &(*channel_users_modes)[i]);
4634         (*channel_ids)[i] = channel->id;
4635
4636         /* Channel's topic */
4637         tmp = silc_realloc(*channel_topics,
4638                            sizeof(**channel_topics) * (i + 1));
4639         if (!tmp)
4640           break;
4641         *channel_topics = tmp;
4642         (*channel_topics)[i] = NULL;
4643         silc_server_announce_get_channel_topic(server, channel,
4644                                                &(*channel_topics)[i]);
4645
4646         /* Channel's invite and ban list */
4647         tmp = silc_realloc(*channel_invites,
4648                            sizeof(**channel_invites) * (i + 1));
4649         if (!tmp)
4650           break;
4651         *channel_invites = tmp;
4652         (*channel_invites)[i] = NULL;
4653         tmp = silc_realloc(*channel_bans,
4654                            sizeof(**channel_bans) * (i + 1));
4655         if (!tmp)
4656           break;
4657         *channel_bans = tmp;
4658         (*channel_bans)[i] = NULL;
4659         silc_server_announce_get_inviteban(server, channel,
4660                                            &(*channel_invites)[i],
4661                                            &(*channel_bans)[i]);
4662
4663         (*channel_users_modes_c)++;
4664
4665         i++;
4666       }
4667     }
4668   }
4669 }
4670
4671 /* This function is used to announce our existing channels to our router
4672    when we've connected to it. This also announces the users on the
4673    channels to the router. If the `creation_time' is non-zero only the
4674    channels that was created after the `creation_time' are announced.
4675    Note that the channel users are still announced even if the `creation_time'
4676    was provided. */
4677
4678 void silc_server_announce_channels(SilcServer server,
4679                                    unsigned long creation_time,
4680                                    SilcPacketStream remote)
4681 {
4682   SilcBuffer channels = NULL, *channel_modes = NULL, channel_users = NULL;
4683   SilcBuffer *channel_users_modes = NULL;
4684   SilcBuffer *channel_topics = NULL;
4685   SilcBuffer *channel_invites = NULL;
4686   SilcBuffer *channel_bans = NULL;
4687   SilcUInt32 channel_users_modes_c = 0;
4688   SilcChannelID **channel_ids = NULL;
4689
4690   SILC_LOG_DEBUG(("Announcing channels and channel users"));
4691
4692   /* Get channels and channel users in local list */
4693   silc_server_announce_get_channels(server, server->local_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   /* Get channels and channel users in global list */
4704   if (server->server_type != SILC_SERVER)
4705     silc_server_announce_get_channels(server, server->global_list,
4706                                       &channels, &channel_modes,
4707                                       &channel_users,
4708                                       &channel_users_modes,
4709                                       &channel_users_modes_c,
4710                                       &channel_topics,
4711                                       &channel_invites,
4712                                       &channel_bans,
4713                                       &channel_ids, creation_time);
4714
4715   if (channels) {
4716     silc_buffer_push(channels, channels->data - channels->head);
4717     SILC_LOG_HEXDUMP(("channels"), channels->data, silc_buffer_len(channels));
4718
4719     /* Send the packet */
4720     silc_server_packet_send(server, remote,
4721                             SILC_PACKET_NEW_CHANNEL, SILC_PACKET_FLAG_LIST,
4722                             channels->data, silc_buffer_len(channels));
4723
4724     silc_buffer_free(channels);
4725   }
4726
4727   if (channel_users) {
4728     silc_buffer_push(channel_users, channel_users->data - channel_users->head);
4729     SILC_LOG_HEXDUMP(("channel users"), channel_users->data,
4730                      silc_buffer_len(channel_users));
4731
4732     /* Send the packet */
4733     silc_server_packet_send(server, remote,
4734                             SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4735                             channel_users->data, silc_buffer_len(channel_users));
4736
4737     silc_buffer_free(channel_users);
4738   }
4739
4740   if (channel_modes) {
4741     int i;
4742
4743     for (i = 0; i < channel_users_modes_c; i++) {
4744       if (!channel_modes[i])
4745         continue;
4746       silc_buffer_push(channel_modes[i],
4747                        channel_modes[i]->data -
4748                        channel_modes[i]->head);
4749       SILC_LOG_HEXDUMP(("channel modes"), channel_modes[i]->data,
4750                        silc_buffer_len(channel_modes[i]));
4751       silc_server_packet_send_dest(server, remote,
4752                                    SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4753                                    channel_ids[i], SILC_ID_CHANNEL,
4754                                    channel_modes[i]->data,
4755                                    silc_buffer_len(channel_modes[i]));
4756       silc_buffer_free(channel_modes[i]);
4757     }
4758     silc_free(channel_modes);
4759   }
4760
4761   if (channel_users_modes) {
4762     int i;
4763
4764     for (i = 0; i < channel_users_modes_c; i++) {
4765       if (!channel_users_modes[i])
4766         continue;
4767       silc_buffer_push(channel_users_modes[i],
4768                        channel_users_modes[i]->data -
4769                        channel_users_modes[i]->head);
4770       SILC_LOG_HEXDUMP(("channel users modes"), channel_users_modes[i]->data,
4771                        silc_buffer_len(channel_users_modes[i]));
4772       silc_server_packet_send_dest(server, remote,
4773                                    SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4774                                    channel_ids[i], SILC_ID_CHANNEL,
4775                                    channel_users_modes[i]->data,
4776                                    silc_buffer_len(channel_users_modes[i]));
4777       silc_buffer_free(channel_users_modes[i]);
4778     }
4779     silc_free(channel_users_modes);
4780   }
4781
4782   if (channel_topics) {
4783     int i;
4784
4785     for (i = 0; i < channel_users_modes_c; i++) {
4786       if (!channel_topics[i])
4787         continue;
4788
4789       silc_buffer_push(channel_topics[i],
4790                        channel_topics[i]->data -
4791                        channel_topics[i]->head);
4792       SILC_LOG_HEXDUMP(("channel topic"), channel_topics[i]->data,
4793                        silc_buffer_len(channel_topics[i]));
4794       silc_server_packet_send_dest(server, remote,
4795                                    SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4796                                    channel_ids[i], SILC_ID_CHANNEL,
4797                                    channel_topics[i]->data,
4798                                    silc_buffer_len(channel_topics[i]));
4799       silc_buffer_free(channel_topics[i]);
4800     }
4801     silc_free(channel_topics);
4802   }
4803
4804   if (channel_invites) {
4805     int i;
4806
4807     for (i = 0; i < channel_users_modes_c; i++) {
4808       if (!channel_invites[i])
4809         continue;
4810
4811       silc_buffer_push(channel_invites[i],
4812                        channel_invites[i]->data -
4813                        channel_invites[i]->head);
4814       SILC_LOG_HEXDUMP(("channel invite list"), channel_invites[i]->data,
4815                        silc_buffer_len(channel_invites[i]));
4816       silc_server_packet_send_dest(server, remote,
4817                                    SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4818                                    channel_ids[i], SILC_ID_CHANNEL,
4819                                    channel_invites[i]->data,
4820                                    silc_buffer_len(channel_invites[i]));
4821       silc_buffer_free(channel_invites[i]);
4822     }
4823     silc_free(channel_invites);
4824   }
4825
4826   if (channel_bans) {
4827     int i;
4828
4829     for (i = 0; i < channel_users_modes_c; i++) {
4830       if (!channel_bans[i])
4831         continue;
4832
4833       silc_buffer_push(channel_bans[i],
4834                        channel_bans[i]->data -
4835                        channel_bans[i]->head);
4836       SILC_LOG_HEXDUMP(("channel ban list"), channel_bans[i]->data,
4837                        silc_buffer_len(channel_bans[i]));
4838       silc_server_packet_send_dest(server, remote,
4839                                    SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4840                                    channel_ids[i], SILC_ID_CHANNEL,
4841                                    channel_bans[i]->data,
4842                                    silc_buffer_len(channel_bans[i]));
4843       silc_buffer_free(channel_bans[i]);
4844     }
4845     silc_free(channel_bans);
4846   }
4847
4848   silc_free(channel_ids);
4849 }
4850
4851 /* Announces WATCH list. */
4852
4853 void silc_server_announce_watches(SilcServer server,
4854                                   SilcPacketStream remote)
4855 {
4856   SilcHashTableList htl;
4857   SilcBuffer buffer, idp, args, pkp;
4858   SilcClientEntry client;
4859   void *key;
4860
4861   SILC_LOG_DEBUG(("Announcing watch list"));
4862
4863   /* XXX because way we save the nicks (hash) we cannot announce them. */
4864
4865   /* XXX we should send all public keys in one command if client is
4866      watching more than one key */
4867   silc_hash_table_list(server->watcher_list_pk, &htl);
4868   while (silc_hash_table_get(&htl, &key, (void *)&client)) {
4869     if (!client || !client->id)
4870       continue;
4871
4872     server->stat.commands_sent++;
4873
4874     idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
4875     args = silc_buffer_alloc_size(2);
4876     silc_buffer_format(args,
4877                        SILC_STR_UI_SHORT(1),
4878                        SILC_STR_END);
4879     pkp = silc_public_key_payload_encode(key);
4880     args = silc_argument_payload_encode_one(args, pkp->data,
4881                                             silc_buffer_len(pkp), 0x00);
4882     buffer = silc_command_payload_encode_va(SILC_COMMAND_WATCH,
4883                                             ++server->cmd_ident, 2,
4884                                             1, idp->data, silc_buffer_len(idp),
4885                                             4, args->data,
4886                                             silc_buffer_len(args));
4887
4888     /* Send command */
4889     silc_server_packet_send(server, remote, SILC_PACKET_COMMAND, 0,
4890                             buffer->data, silc_buffer_len(buffer));
4891
4892     silc_buffer_free(pkp);
4893     silc_buffer_free(args);
4894     silc_buffer_free(idp);
4895     silc_buffer_free(buffer);
4896   }
4897   silc_hash_table_list_reset(&htl);
4898 }
4899
4900 /* Assembles user list and users mode list from the `channel'. */
4901
4902 SilcBool silc_server_get_users_on_channel(SilcServer server,
4903                                           SilcChannelEntry channel,
4904                                           SilcBuffer *user_list,
4905                                           SilcBuffer *mode_list,
4906                                           SilcUInt32 *user_count)
4907 {
4908   SilcChannelClientEntry chl;
4909   SilcHashTableList htl;
4910   SilcBuffer client_id_list;
4911   SilcBuffer client_mode_list;
4912   SilcBuffer idp;
4913   SilcUInt32 list_count = 0, len = 0;
4914
4915   if (!silc_hash_table_count(channel->user_list))
4916     return FALSE;
4917
4918   silc_hash_table_list(channel->user_list, &htl);
4919   while (silc_hash_table_get(&htl, NULL, (void *)&chl))
4920     len += (silc_id_get_len(chl->client->id, SILC_ID_CLIENT) + 4);
4921   silc_hash_table_list_reset(&htl);
4922
4923   client_id_list = silc_buffer_alloc(len);
4924   client_mode_list =
4925     silc_buffer_alloc(4 * silc_hash_table_count(channel->user_list));
4926   silc_buffer_pull_tail(client_id_list, silc_buffer_truelen(client_id_list));
4927   silc_buffer_pull_tail(client_mode_list,
4928                         silc_buffer_truelen(client_mode_list));
4929
4930   silc_hash_table_list(channel->user_list, &htl);
4931   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
4932     /* Client ID */
4933     idp = silc_id_payload_encode(chl->client->id, SILC_ID_CLIENT);
4934     silc_buffer_put(client_id_list, idp->data, silc_buffer_len(idp));
4935     silc_buffer_pull(client_id_list, silc_buffer_len(idp));
4936     silc_buffer_free(idp);
4937
4938     /* Client's mode on channel */
4939     SILC_PUT32_MSB(chl->mode, client_mode_list->data);
4940     silc_buffer_pull(client_mode_list, 4);
4941
4942     list_count++;
4943   }
4944   silc_hash_table_list_reset(&htl);
4945   silc_buffer_push(client_id_list,
4946                    client_id_list->data - client_id_list->head);
4947   silc_buffer_push(client_mode_list,
4948                    client_mode_list->data - client_mode_list->head);
4949
4950   *user_list = client_id_list;
4951   *mode_list = client_mode_list;
4952   *user_count = list_count;
4953   return TRUE;
4954 }
4955
4956 /* Saves users and their modes to the `channel'. */
4957
4958 void silc_server_save_users_on_channel(SilcServer server,
4959                                        SilcPacketStream sock,
4960                                        SilcChannelEntry channel,
4961                                        SilcClientID *noadd,
4962                                        SilcBuffer user_list,
4963                                        SilcBuffer mode_list,
4964                                        SilcUInt32 user_count)
4965 {
4966   int i;
4967   SilcUInt16 idp_len;
4968   SilcUInt32 mode;
4969   SilcID id;
4970   SilcClientEntry client;
4971   SilcIDCacheEntry cache;
4972   SilcChannelClientEntry chl;
4973
4974   SILC_LOG_DEBUG(("Saving %d users on %s channel", user_count,
4975                   channel->channel_name));
4976
4977   for (i = 0; i < user_count; i++) {
4978     /* Client ID */
4979     SILC_GET16_MSB(idp_len, user_list->data + 2);
4980     idp_len += 4;
4981     if (!silc_id_payload_parse_id(user_list->data, idp_len, &id))
4982       continue;
4983     silc_buffer_pull(user_list, idp_len);
4984
4985     /* Mode */
4986     SILC_GET32_MSB(mode, mode_list->data);
4987     silc_buffer_pull(mode_list, 4);
4988
4989     if (noadd && SILC_ID_CLIENT_COMPARE(&id.u.client_id, noadd))
4990       continue;
4991
4992     cache = NULL;
4993
4994     /* Check if we have this client cached already. */
4995     client = silc_idlist_find_client_by_id(server->local_list,
4996                                            &id.u.client_id,
4997                                            server->server_type, &cache);
4998     if (!client)
4999       client = silc_idlist_find_client_by_id(server->global_list,
5000                                              &id.u.client_id,
5001                                              server->server_type, &cache);
5002     if (!client) {
5003       /* If router did not find such Client ID in its lists then this must
5004          be bogus client or some router in the net is buggy. */
5005       if (server->server_type != SILC_SERVER)
5006         continue;
5007
5008       /* We don't have that client anywhere, add it. The client is added
5009          to global list since server didn't have it in the lists so it must be
5010          global. */
5011       client = silc_idlist_add_client(server->global_list, NULL, NULL, NULL,
5012                                       silc_id_dup(&id.u.client_id,
5013                                                   SILC_ID_CLIENT),
5014                                       silc_packet_get_context(sock),
5015                                       NULL);
5016       if (!client) {
5017         SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
5018         continue;
5019       }
5020
5021       client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
5022     }
5023
5024     if (!(client->data.status & SILC_IDLIST_STATUS_REGISTERED)) {
5025       SILC_LOG_ERROR(("Attempting to add unregistered client to channel ",
5026                       "%s", channel->channel_name));
5027       continue;
5028     }
5029
5030     if (!silc_server_client_on_channel(client, channel, &chl)) {
5031       /* Client was not on the channel, add it. */
5032       chl = silc_calloc(1, sizeof(*chl));
5033       chl->client = client;
5034       chl->mode = mode;
5035       chl->channel = channel;
5036       silc_hash_table_add(channel->user_list, chl->client, chl);
5037       silc_hash_table_add(client->channels, chl->channel, chl);
5038       channel->user_count++;
5039     } else {
5040       /* Update mode */
5041       chl->mode = mode;
5042     }
5043   }
5044 }
5045
5046 /* Saves channels and channels user modes to the `client'.  Removes
5047    the client from those channels that are not sent in the list but
5048    it has joined. */
5049
5050 void silc_server_save_user_channels(SilcServer server,
5051                                     SilcPacketStream sock,
5052                                     SilcClientEntry client,
5053                                     SilcBuffer channels,
5054                                     SilcBuffer channels_user_modes)
5055 {
5056   SilcDList ch;
5057   SilcUInt32 *chumodes;
5058   SilcChannelPayload entry;
5059   SilcChannelEntry channel;
5060   SilcChannelID channel_id;
5061   SilcChannelClientEntry chl;
5062   SilcHashTable ht = NULL;
5063   SilcHashTableList htl;
5064   char *name;
5065   int i = 0;
5066
5067   if (!channels || !channels_user_modes ||
5068       !(client->data.status & SILC_IDLIST_STATUS_REGISTERED))
5069     goto out;
5070
5071   ch = silc_channel_payload_parse_list(channels->data,
5072                                        silc_buffer_len(channels));
5073   if (ch && silc_get_mode_list(channels_user_modes, silc_dlist_count(ch),
5074                                &chumodes)) {
5075     ht = silc_hash_table_alloc(0, silc_hash_ptr, NULL, NULL,
5076                                NULL, NULL, NULL, TRUE);
5077     silc_dlist_start(ch);
5078     while ((entry = silc_dlist_get(ch)) != SILC_LIST_END) {
5079       /* Check if we have this channel, and add it if we don't have it.
5080          Also add the client on the channel unless it is there already. */
5081       if (!silc_channel_get_id_parse(entry, &channel_id))
5082         continue;
5083       channel = silc_idlist_find_channel_by_id(server->local_list,
5084                                                &channel_id, NULL);
5085       if (!channel)
5086         channel = silc_idlist_find_channel_by_id(server->global_list,
5087                                                  &channel_id, NULL);
5088       if (!channel) {
5089         if (server->server_type != SILC_SERVER) {
5090           i++;
5091           continue;
5092         }
5093
5094         /* We don't have that channel anywhere, add it. */
5095         name = silc_channel_get_name(entry, NULL);
5096         channel = silc_idlist_add_channel(server->global_list, strdup(name), 0,
5097                                           silc_id_dup(&channel_id,
5098                                                       SILC_ID_CHANNEL),
5099                                           server->router, NULL, NULL, 0);
5100         if (!channel) {
5101           i++;
5102           continue;
5103         }
5104       }
5105
5106       channel->mode = silc_channel_get_mode(entry);
5107
5108       /* Add the client on the channel */
5109       if (!silc_server_client_on_channel(client, channel, &chl)) {
5110         chl = silc_calloc(1, sizeof(*chl));
5111         chl->client = client;
5112         chl->mode = chumodes[i++];
5113         chl->channel = channel;
5114         silc_hash_table_add(channel->user_list, chl->client, chl);
5115         silc_hash_table_add(client->channels, chl->channel, chl);
5116         channel->user_count++;
5117       } else {
5118         /* Update mode */
5119         chl->mode = chumodes[i++];
5120       }
5121
5122       silc_hash_table_add(ht, channel, channel);
5123     }
5124     silc_channel_payload_list_free(ch);
5125     silc_free(chumodes);
5126   }
5127
5128  out:
5129   /* Go through the list again and remove client from channels that
5130      are no part of the list. */
5131   if (ht) {
5132     silc_hash_table_list(client->channels, &htl);
5133     while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
5134       if (!silc_hash_table_find(ht, chl->channel, NULL, NULL)) {
5135         silc_hash_table_del(chl->channel->user_list, chl->client);
5136         silc_hash_table_del(chl->client->channels, chl->channel);
5137         silc_free(chl);
5138       }
5139     }
5140     silc_hash_table_list_reset(&htl);
5141     silc_hash_table_free(ht);
5142   } else {
5143     silc_hash_table_list(client->channels, &htl);
5144     while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
5145       silc_hash_table_del(chl->channel->user_list, chl->client);
5146       silc_hash_table_del(chl->client->channels, chl->channel);
5147       silc_free(chl);
5148     }
5149     silc_hash_table_list_reset(&htl);
5150   }
5151 }
5152
5153 /* Lookups route to the client indicated by the `id_data'. The connection
5154    object and internal data object is returned. Returns NULL if route
5155    could not be found to the client. If the `client_id' is specified then
5156    it is used and the `id_data' is ignored. */
5157
5158 SilcPacketStream
5159 silc_server_get_client_route(SilcServer server,
5160                              unsigned char *id_data,
5161                              SilcUInt32 id_len,
5162                              SilcClientID *client_id,
5163                              SilcIDListData *idata,
5164                              SilcClientEntry *client_entry)
5165 {
5166   SilcClientID *id, clid;
5167   SilcClientEntry client;
5168
5169   SILC_LOG_DEBUG(("Start"));
5170
5171   if (client_entry)
5172     *client_entry = NULL;
5173
5174   /* Decode destination Client ID */
5175   if (!client_id) {
5176     if (!silc_id_str2id(id_data, id_len, SILC_ID_CLIENT, &clid, sizeof(clid)))
5177       return NULL;
5178     id = silc_id_dup(&clid, SILC_ID_CLIENT);
5179   } else {
5180     id = silc_id_dup(client_id, SILC_ID_CLIENT);
5181   }
5182
5183   /* If the destination belongs to our server we don't have to route
5184      the packet anywhere but to send it to the local destination. */
5185   client = silc_idlist_find_client_by_id(server->local_list, id, TRUE, NULL);
5186   if (client) {
5187     silc_free(id);
5188
5189     /* If we are router and the client has router then the client is in
5190        our cell but not directly connected to us. */
5191     if (server->server_type == SILC_ROUTER && client->router) {
5192       /* We are of course in this case the client's router thus the route
5193          to the client is the server who owns the client. So, we will send
5194          the packet to that server. */
5195       if (idata)
5196         *idata = (SilcIDListData)client->router;
5197       return client->router->connection;
5198     }
5199
5200     /* Seems that client really is directly connected to us */
5201     if (idata)
5202       *idata = (SilcIDListData)client;
5203     if (client_entry)
5204       *client_entry = client;
5205     return client->connection;
5206   }
5207
5208   /* Destination belongs to someone not in this server. If we are normal
5209      server our action is to send the packet to our router. */
5210   if (server->server_type != SILC_ROUTER && !server->standalone) {
5211     silc_free(id);
5212     if (idata)
5213       *idata = (SilcIDListData)server->router;
5214     return SILC_PRIMARY_ROUTE(server);
5215   }
5216
5217   /* We are router and we will perform route lookup for the destination
5218      and send the packet to fastest route. */
5219   if (server->server_type == SILC_ROUTER && !server->standalone) {
5220     /* Check first that the ID is valid */
5221     client = silc_idlist_find_client_by_id(server->global_list, id,
5222                                            TRUE, NULL);
5223     if (client) {
5224       SilcPacketStream dst_sock;
5225
5226       dst_sock = silc_server_route_get(server, id, SILC_ID_CLIENT);
5227
5228       silc_free(id);
5229       if (idata && dst_sock)
5230         *idata = silc_packet_get_context(dst_sock);
5231       return dst_sock;
5232     }
5233   }
5234
5235   silc_free(id);
5236   return NULL;
5237 }
5238
5239 /* Encodes and returns channel list of channels the `client' has joined.
5240    Secret channels are not put to the list. */
5241
5242 SilcBuffer silc_server_get_client_channel_list(SilcServer server,
5243                                                SilcClientEntry client,
5244                                                SilcBool get_private,
5245                                                SilcBool get_secret,
5246                                                SilcBuffer *user_mode_list)
5247 {
5248   SilcBuffer buffer = NULL;
5249   SilcChannelEntry channel;
5250   SilcChannelClientEntry chl;
5251   SilcHashTableList htl;
5252   unsigned char cid[32];
5253   SilcUInt32 id_len;
5254   SilcUInt16 name_len;
5255   int len;
5256
5257   if (user_mode_list)
5258     *user_mode_list = NULL;
5259
5260   silc_hash_table_list(client->channels, &htl);
5261   while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
5262     channel = chl->channel;
5263
5264     if (channel->mode & SILC_CHANNEL_MODE_SECRET && !get_secret)
5265       continue;
5266     if (channel->mode & SILC_CHANNEL_MODE_PRIVATE && !get_private)
5267       continue;
5268
5269     silc_id_id2str(channel->id, SILC_ID_CHANNEL, cid, sizeof(cid), &id_len);
5270     name_len = strlen(channel->channel_name);
5271
5272     len = 4 + name_len + id_len + 4;
5273     buffer = silc_buffer_realloc(buffer,
5274                                  (buffer ?
5275                                   silc_buffer_truelen(buffer) + len : len));
5276     silc_buffer_pull_tail(buffer, (buffer->end - buffer->data));
5277     silc_buffer_format(buffer,
5278                        SILC_STR_UI_SHORT(name_len),
5279                        SILC_STR_DATA(channel->channel_name, name_len),
5280                        SILC_STR_UI_SHORT(id_len),
5281                        SILC_STR_DATA(cid, id_len),
5282                        SILC_STR_UI_INT(chl->channel->mode),
5283                        SILC_STR_END);
5284     silc_buffer_pull(buffer, len);
5285
5286     if (user_mode_list) {
5287       *user_mode_list =
5288         silc_buffer_realloc(*user_mode_list,
5289                             (*user_mode_list ?
5290                              silc_buffer_truelen((*user_mode_list)) + 4 : 4));
5291       silc_buffer_pull_tail(*user_mode_list, ((*user_mode_list)->end -
5292                                               (*user_mode_list)->data));
5293       SILC_PUT32_MSB(chl->mode, (*user_mode_list)->data);
5294       silc_buffer_pull(*user_mode_list, 4);
5295     }
5296   }
5297   silc_hash_table_list_reset(&htl);
5298
5299   if (buffer)
5300     silc_buffer_push(buffer, buffer->data - buffer->head);
5301   if (user_mode_list && *user_mode_list)
5302     silc_buffer_push(*user_mode_list, ((*user_mode_list)->data -
5303                                        (*user_mode_list)->head));
5304
5305   return buffer;
5306 }
5307
5308 /* Task callback used to retrieve network statistical information from
5309    router server once in a while. */
5310
5311 SILC_TASK_CALLBACK(silc_server_get_stats)
5312 {
5313   SilcServer server = (SilcServer)context;
5314   SilcBuffer idp, packet;
5315
5316   if (!server->standalone) {
5317     SILC_LOG_DEBUG(("Retrieving stats from router"));
5318     server->stat.commands_sent++;
5319     idp = silc_id_payload_encode(server->router->id, SILC_ID_SERVER);
5320     if (idp) {
5321       packet = silc_command_payload_encode_va(SILC_COMMAND_STATS,
5322                                               ++server->cmd_ident, 1,
5323                                               1, idp->data,
5324                                               silc_buffer_len(idp));
5325       silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
5326                               SILC_PACKET_COMMAND, 0, packet->data,
5327                               silc_buffer_len(packet));
5328       silc_buffer_free(packet);
5329       silc_buffer_free(idp);
5330     }
5331   }
5332
5333   silc_schedule_task_add_timeout(server->schedule, silc_server_get_stats,
5334                                  server, 120, 0);
5335 }