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