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