apps/silcd/server.c

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