apps/silcd/server.c

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