apps/silcd/server.c

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