lib/silcclient/client.c

   1 /*
   2
   3   client.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 1997 - 2003 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 /* $Id$ */
  20
  21 #include "silcincludes.h"
  22 #include "silcclient.h"
  23 #include "client_internal.h"
  24
  25 /* Static task callback prototypes */
  26 SILC_TASK_CALLBACK(silc_client_connect_to_server_start);
  27 SILC_TASK_CALLBACK(silc_client_connect_to_server_second);
  28 SILC_TASK_CALLBACK(silc_client_connect_to_server_final);
  29 SILC_TASK_CALLBACK(silc_client_rekey_final);
  30
  31 static bool silc_client_packet_parse(SilcPacketParserContext *parser_context,
  32                                      void *context);
  33 static void silc_client_packet_parse_type(SilcClient client,
  34                                           SilcSocketConnection sock,
  35                                           SilcPacketContext *packet);
  36 void silc_client_resolve_auth_method(bool success,
  37                                      SilcProtocolAuthMeth auth_meth,
  38                                      const unsigned char *auth_data,
  39                                      SilcUInt32 auth_data_len, void *context);
  40
  41 /* Allocates new client object. This has to be done before client may
  42    work. After calling this one must call silc_client_init to initialize
  43    the client. The `application' is application specific user data pointer
  44    and caller must free it. */
  45
  46 SilcClient silc_client_alloc(SilcClientOperations *ops,
  47                              SilcClientParams *params,
  48                              void *application,
  49                              const char *version_string)
  50 {
  51   SilcClient new_client;
  52
  53   new_client = silc_calloc(1, sizeof(*new_client));
  54   new_client->application = application;
  55
  56   new_client->internal = silc_calloc(1, sizeof(*new_client->internal));
  57   new_client->internal->ops = ops;
  58   new_client->internal->params =
  59     silc_calloc(1, sizeof(*new_client->internal->params));
  60   if (!version_string)
  61     version_string = silc_version_string;
  62   new_client->internal->silc_client_version = strdup(version_string);
  63
  64   if (params)
  65     memcpy(new_client->internal->params, params, sizeof(*params));
  66
  67   if (!new_client->internal->params->task_max)
  68     new_client->internal->params->task_max = 200;
  69
  70   if (!new_client->internal->params->rekey_secs)
  71     new_client->internal->params->rekey_secs = 3600;
  72
  73   if (!new_client->internal->params->connauth_request_secs)
  74     new_client->internal->params->connauth_request_secs = 2;
  75
  76   new_client->internal->params->
  77     nickname_format[sizeof(new_client->internal->
  78                            params->nickname_format) - 1] = 0;
  79
  80   return new_client;
  81 }
  82
  83 /* Frees client object and its internals. */
  84
  85 void silc_client_free(SilcClient client)
  86 {
  87   if (client) {
  88     if (client->rng)
  89       silc_rng_free(client->rng);
  90
  91     silc_cipher_unregister_all();
  92     silc_pkcs_unregister_all();
  93     silc_hash_unregister_all();
  94     silc_hmac_unregister_all();
  95
  96     silc_hash_free(client->md5hash);
  97     silc_hash_free(client->sha1hash);
  98     silc_hmac_free(client->internal->md5hmac);
  99     silc_hmac_free(client->internal->sha1hmac);
 100     silc_cipher_free(client->internal->none_cipher);
 101     silc_free(client->internal->params);
 102     silc_free(client->internal->silc_client_version);
 103     silc_free(client->internal);
 104     silc_free(client);
 105   }
 106 }
 107
 108 /* Initializes the client. This makes all the necessary steps to make
 109    the client ready to be run. One must call silc_client_run to run the
 110    client. Returns FALSE if error occured, TRUE otherwise. */
 111
 112 bool silc_client_init(SilcClient client)
 113 {
 114   SILC_LOG_DEBUG(("Initializing client"));
 115
 116   assert(client);
 117   assert(client->username);
 118   assert(client->hostname);
 119   assert(client->realname);
 120
 121   /* Initialize the crypto library.  If application has done this already
 122      this has no effect.  Also, we will not be overriding something
 123      application might have registered earlier. */
 124   silc_cipher_register_default();
 125   silc_pkcs_register_default();
 126   silc_hash_register_default();
 127   silc_hmac_register_default();
 128
 129   /* Initialize hash functions for client to use */
 130   silc_hash_alloc("md5", &client->md5hash);
 131   silc_hash_alloc("sha1", &client->sha1hash);
 132
 133   /* Initialize none cipher */
 134   silc_cipher_alloc("none", &client->internal->none_cipher);
 135
 136   /* Initialize random number generator */
 137   client->rng = silc_rng_alloc();
 138   silc_rng_init(client->rng);
 139   silc_rng_global_init(client->rng);
 140
 141   /* Register protocols */
 142   silc_client_protocols_register();
 143
 144   /* Initialize the scheduler */
 145   client->schedule =
 146     silc_schedule_init(client->internal->params->task_max ?
 147                        client->internal->params->task_max : 200, client);
 148   if (!client->schedule)
 149     return FALSE;
 150
 151   /* Register commands */
 152   silc_client_commands_register(client);
 153
 154   return TRUE;
 155 }
 156
 157 /* Stops the client. This is called to stop the client and thus to stop
 158    the program. */
 159
 160 void silc_client_stop(SilcClient client)
 161 {
 162   SILC_LOG_DEBUG(("Stopping client"));
 163
 164   silc_schedule_stop(client->schedule);
 165   silc_schedule_uninit(client->schedule);
 166
 167   silc_client_protocols_unregister();
 168   silc_client_commands_unregister(client);
 169
 170   SILC_LOG_DEBUG(("Client stopped"));
 171 }
 172
 173 /* Runs the client. This starts the scheduler from the utility library.
 174    When this functions returns the execution of the appliation is over. */
 175
 176 void silc_client_run(SilcClient client)
 177 {
 178   SILC_LOG_DEBUG(("Running client"));
 179
 180   assert(client);
 181   assert(client->pkcs);
 182   assert(client->public_key);
 183   assert(client->private_key);
 184
 185   /* Start the scheduler, the heart of the SILC client. When this returns
 186      the program will be terminated. */
 187   silc_schedule(client->schedule);
 188 }
 189
 190 /* Runs the client and returns immeadiately. This function is used when
 191    the SILC Client object indicated by the `client' is run under some
 192    other scheduler, or event loop or main loop.  On GUI applications,
 193    for example this may be desired to use to run the client under the
 194    GUI application's main loop.  Typically the GUI application would
 195    register an idle task that calls this function multiple times in
 196    a second to quickly process the SILC specific data. */
 197
 198 void silc_client_run_one(SilcClient client)
 199 {
 200   /* Run the scheduler once. */
 201   silc_schedule_one(client->schedule, 0);
 202 }
 203
 204 static void silc_client_entry_destructor(SilcIDCache cache,
 205                                          SilcIDCacheEntry entry)
 206 {
 207   silc_free(entry->name);
 208 }
 209
 210 /* Allocates and adds new connection to the client. This adds the allocated
 211    connection to the connection table and returns a pointer to it. A client
 212    can have multiple connections to multiple servers. Every connection must
 213    be added to the client using this function. User data `context' may
 214    be sent as argument. This function is normally used only if the
 215    application performed the connecting outside the library. The library
 216    however may use this internally. */
 217
 218 SilcClientConnection
 219 silc_client_add_connection(SilcClient client,
 220                            SilcClientConnectionParams *params,
 221                            char *hostname, int port, void *context)
 222 {
 223   SilcClientConnection conn;
 224   int i;
 225
 226   SILC_LOG_DEBUG(("Adding new connection to %s:%d", hostname, port));
 227
 228   conn = silc_calloc(1, sizeof(*conn));
 229   conn->internal = silc_calloc(1, sizeof(*conn->internal));
 230
 231   /* Initialize ID caches */
 232   conn->client = client;
 233   conn->remote_host = strdup(hostname);
 234   conn->remote_port = port;
 235   conn->context = context;
 236   conn->internal->client_cache =
 237     silc_idcache_alloc(0, SILC_ID_CLIENT, silc_client_entry_destructor);
 238   conn->internal->channel_cache = silc_idcache_alloc(0, SILC_ID_CHANNEL, NULL);
 239   conn->internal->server_cache = silc_idcache_alloc(0, SILC_ID_SERVER, NULL);
 240   conn->internal->pending_commands = silc_dlist_init();
 241   conn->internal->ftp_sessions = silc_dlist_init();
 242
 243   if (params) {
 244     if (params->detach_data)
 245       conn->internal->params.detach_data =
 246         silc_memdup(params->detach_data,
 247                     params->detach_data_len);
 248     conn->internal->params.detach_data_len = params->detach_data_len;
 249   }
 250
 251   /* Add the connection to connections table */
 252   for (i = 0; i < client->internal->conns_count; i++)
 253     if (client->internal->conns && !client->internal->conns[i]) {
 254       client->internal->conns[i] = conn;
 255       return conn;
 256     }
 257
 258   client->internal->conns =
 259     silc_realloc(client->internal->conns, sizeof(*client->internal->conns)
 260                  * (client->internal->conns_count + 1));
 261   client->internal->conns[client->internal->conns_count] = conn;
 262   client->internal->conns_count++;
 263
 264   return conn;
 265 }
 266
 267 /* Removes connection from client. Frees all memory. */
 268
 269 void silc_client_del_connection(SilcClient client, SilcClientConnection conn)
 270 {
 271   int i;
 272
 273   for (i = 0; i < client->internal->conns_count; i++)
 274     if (client->internal->conns[i] == conn) {
 275       /* Free all cache entries */
 276       SilcIDCacheList list;
 277       SilcIDCacheEntry entry;
 278       SilcClientCommandPending *r;
 279       bool ret;
 280
 281       if (silc_idcache_get_all(conn->internal->client_cache, &list)) {
 282         ret = silc_idcache_list_first(list, &entry);
 283         while (ret) {
 284           silc_client_del_client(client, conn, entry->context);
 285           ret = silc_idcache_list_next(list, &entry);
 286         }
 287         silc_idcache_list_free(list);
 288       }
 289
 290       if (silc_idcache_get_all(conn->internal->channel_cache, &list)) {
 291         ret = silc_idcache_list_first(list, &entry);
 292         while (ret) {
 293           silc_client_del_channel(client, conn, entry->context);
 294           ret = silc_idcache_list_next(list, &entry);
 295         }
 296         silc_idcache_list_free(list);
 297       }
 298
 299       if (silc_idcache_get_all(conn->internal->server_cache, &list)) {
 300         ret = silc_idcache_list_first(list, &entry);
 301         while (ret) {
 302           silc_client_del_server(client, conn, entry->context);
 303           ret = silc_idcache_list_next(list, &entry);
 304         }
 305         silc_idcache_list_free(list);
 306       }
 307
 308       /* Clear ID caches */
 309       if (conn->internal->client_cache)
 310         silc_idcache_free(conn->internal->client_cache);
 311       if (conn->internal->channel_cache)
 312         silc_idcache_free(conn->internal->channel_cache);
 313       if (conn->internal->server_cache)
 314         silc_idcache_free(conn->internal->server_cache);
 315
 316       /* Free data (my ID is freed in above silc_client_del_client).
 317          conn->nickname is freed when freeing the local_entry->nickname. */
 318       silc_free(conn->remote_host);
 319       silc_free(conn->local_id_data);
 320       if (conn->internal->send_key)
 321         silc_cipher_free(conn->internal->send_key);
 322       if (conn->internal->receive_key)
 323         silc_cipher_free(conn->internal->receive_key);
 324       if (conn->internal->hmac_send)
 325         silc_hmac_free(conn->internal->hmac_send);
 326       if (conn->internal->hmac_receive)
 327         silc_hmac_free(conn->internal->hmac_receive);
 328       silc_free(conn->internal->rekey);
 329
 330       if (conn->internal->active_session) {
 331         if (conn->sock)
 332           conn->sock->user_data = NULL;
 333         silc_client_ftp_session_free(conn->internal->active_session);
 334         conn->internal->active_session = NULL;
 335       }
 336
 337       silc_client_ftp_free_sessions(client, conn);
 338
 339       if (conn->internal->pending_commands) {
 340         silc_dlist_start(conn->internal->pending_commands);
 341         while ((r = silc_dlist_get(conn->internal->pending_commands))
 342                != SILC_LIST_END)
 343           silc_dlist_del(conn->internal->pending_commands, r);
 344         silc_dlist_uninit(conn->internal->pending_commands);
 345       }
 346
 347       silc_free(conn->internal);
 348       memset(conn, 0, sizeof(*conn));
 349       silc_free(conn);
 350
 351       client->internal->conns[i] = NULL;
 352     }
 353 }
 354
 355 /* Adds listener socket to the listener sockets table. This function is
 356    used to add socket objects that are listeners to the client.  This should
 357    not be used to add other connection objects. */
 358
 359 void silc_client_add_socket(SilcClient client, SilcSocketConnection sock)
 360 {
 361   int i;
 362
 363   if (!client->internal->sockets) {
 364     client->internal->sockets =
 365       silc_calloc(1, sizeof(*client->internal->sockets));
 366     client->internal->sockets[0] = silc_socket_dup(sock);
 367     client->internal->sockets_count = 1;
 368     return;
 369   }
 370
 371   for (i = 0; i < client->internal->sockets_count; i++) {
 372     if (client->internal->sockets[i] == NULL) {
 373       client->internal->sockets[i] = silc_socket_dup(sock);
 374       return;
 375     }
 376   }
 377
 378   client->internal->sockets =
 379     silc_realloc(client->internal->sockets,
 380                  sizeof(*client->internal->sockets) *
 381                  (client->internal->sockets_count + 1));
 382   client->internal->sockets[client->internal->sockets_count] =
 383     silc_socket_dup(sock);
 384   client->internal->sockets_count++;
 385 }
 386
 387 /* Deletes listener socket from the listener sockets table. */
 388
 389 void silc_client_del_socket(SilcClient client, SilcSocketConnection sock)
 390 {
 391   int i;
 392
 393   if (!client->internal->sockets)
 394     return;
 395
 396   for (i = 0; i < client->internal->sockets_count; i++) {
 397     if (client->internal->sockets[i] == sock) {
 398       silc_socket_free(sock);
 399       client->internal->sockets[i] = NULL;
 400       return;
 401     }
 402   }
 403 }
 404
 405 static int
 406 silc_client_connect_to_server_internal(SilcClientInternalConnectContext *ctx)
 407 {
 408   int sock;
 409
 410   /* XXX In the future we should give up this non-blocking connect all
 411      together and use threads instead. */
 412   /* Create connection to server asynchronously */
 413   sock = silc_net_create_connection_async(NULL, ctx->port, ctx->host);
 414   if (sock < 0)
 415     return -1;
 416
 417   /* Register task that will receive the async connect and will
 418      read the result. */
 419   ctx->task = silc_schedule_task_add(ctx->client->schedule, sock,
 420                                      silc_client_connect_to_server_start,
 421                                      (void *)ctx, 0, 0,
 422                                      SILC_TASK_FD,
 423                                      SILC_TASK_PRI_NORMAL);
 424   silc_schedule_set_listen_fd(ctx->client->schedule, sock, SILC_TASK_WRITE,
 425                               FALSE);
 426
 427   ctx->sock = sock;
 428
 429   return sock;
 430 }
 431
 432 /* Connects to remote server. This is the main routine used to connect
 433    to SILC server. Returns -1 on error and the created socket otherwise.
 434    The `context' is user context that is saved into the SilcClientConnection
 435    that is created after the connection is created. Note that application
 436    may handle the connecting process outside the library. If this is the
 437    case then this function is not used at all. When the connecting is
 438    done the `connect' client operation is called. */
 439
 440 int silc_client_connect_to_server(SilcClient client,
 441                                   SilcClientConnectionParams *params,
 442                                   int port, char *host, void *context)
 443 {
 444   SilcClientInternalConnectContext *ctx;
 445   SilcClientConnection conn;
 446   int sock;
 447
 448   SILC_LOG_DEBUG(("Connecting to port %d of server %s",
 449                   port, host));
 450
 451   conn = silc_client_add_connection(client, params, host, port, context);
 452
 453   client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_AUDIT,
 454                              "Connecting to port %d of server %s", port, host);
 455
 456   /* Allocate internal context for connection process. This is
 457      needed as we are doing async connecting. */
 458   ctx = silc_calloc(1, sizeof(*ctx));
 459   ctx->client = client;
 460   ctx->conn = conn;
 461   ctx->host = strdup(host);
 462   ctx->port = port ? port : 706;
 463   ctx->tries = 0;
 464
 465   /* Do the actual connecting process */
 466   sock = silc_client_connect_to_server_internal(ctx);
 467   if (sock == -1)
 468     silc_client_del_connection(client, conn);
 469   return sock;
 470 }
 471
 472 /* Socket hostname and IP lookup callback that is called before actually
 473    starting the key exchange.  The lookup is called from the function
 474    silc_client_start_key_exchange. */
 475
 476 static void silc_client_start_key_exchange_cb(SilcSocketConnection sock,
 477                                               void *context)
 478 {
 479   SilcClientConnection conn = (SilcClientConnection)context;
 480   SilcClient client = conn->client;
 481   SilcProtocol protocol;
 482   SilcClientKEInternalContext *proto_ctx;
 483
 484   SILC_LOG_DEBUG(("Start"));
 485
 486   if (conn->sock->hostname) {
 487     silc_free(conn->remote_host);
 488     conn->remote_host = strdup(conn->sock->hostname);
 489   } else {
 490     conn->sock->hostname = strdup(conn->remote_host);
 491   }
 492   if (!conn->sock->ip)
 493     conn->sock->ip = strdup(conn->sock->hostname);
 494   conn->sock->port = conn->remote_port;
 495
 496   /* Allocate internal Key Exchange context. This is sent to the
 497      protocol as context. */
 498   proto_ctx = silc_calloc(1, sizeof(*proto_ctx));
 499   proto_ctx->client = (void *)client;
 500   proto_ctx->sock = silc_socket_dup(conn->sock);
 501   proto_ctx->rng = client->rng;
 502   proto_ctx->responder = FALSE;
 503   proto_ctx->send_packet = silc_client_protocol_ke_send_packet;
 504   proto_ctx->verify = silc_client_protocol_ke_verify_key;
 505
 506   /* Perform key exchange protocol. silc_client_connect_to_server_final
 507      will be called after the protocol is finished. */
 508   silc_protocol_alloc(SILC_PROTOCOL_CLIENT_KEY_EXCHANGE,
 509                       &protocol, (void *)proto_ctx,
 510                       silc_client_connect_to_server_second);
 511   if (!protocol) {
 512     client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_ERROR,
 513                                "Error: Could not start key exchange protocol");
 514     silc_net_close_connection(conn->sock->sock);
 515     client->internal->ops->connected(client, conn, SILC_CLIENT_CONN_ERROR);
 516     return;
 517   }
 518   conn->sock->protocol = protocol;
 519
 520   /* Register the connection for network input and output. This sets
 521      that scheduler will listen for incoming packets for this connection
 522      and sets that outgoing packets may be sent to this connection as well.
 523      However, this doesn't set the scheduler for outgoing traffic, it will
 524      be set separately by calling SILC_CLIENT_SET_CONNECTION_FOR_OUTPUT,
 525      later when outgoing data is available. */
 526   context = (void *)client;
 527   SILC_CLIENT_REGISTER_CONNECTION_FOR_IO(conn->sock->sock);
 528
 529   /* Execute the protocol */
 530   silc_protocol_execute(protocol, client->schedule, 0, 0);
 531 }
 532
 533 /* Start SILC Key Exchange (SKE) protocol to negotiate shared secret
 534    key material between client and server.  This function can be called
 535    directly if application is performing its own connecting and does not
 536    use the connecting provided by this library. This function is normally
 537    used only if the application performed the connecting outside the library.
 538    The library however may use this internally. */
 539
 540 void silc_client_start_key_exchange(SilcClient client,
 541                                     SilcClientConnection conn,
 542                                     int fd)
 543 {
 544   assert(client->pkcs);
 545   assert(client->public_key);
 546   assert(client->private_key);
 547
 548   /* Allocate new socket connection object */
 549   silc_socket_alloc(fd, SILC_SOCKET_TYPE_SERVER, (void *)conn, &conn->sock);
 550
 551   /* Sometimes when doing quick reconnects the new socket may be same as
 552      the old one and there might be pending stuff for the old socket.
 553      If new one is same then those pending sutff might cause problems.
 554      Make sure they do not do that. */
 555   silc_schedule_task_del_by_fd(client->schedule, fd);
 556
 557   conn->nickname = (client->nickname ? strdup(client->nickname) :
 558                     strdup(client->username));
 559
 560   /* Resolve the remote hostname and IP address for our socket connection */
 561   silc_socket_host_lookup(conn->sock, FALSE, silc_client_start_key_exchange_cb,
 562                           conn, client->schedule);
 563 }
 564
 565 /* Callback called when error has occurred during connecting (KE) to
 566    the server.  The `connect' client operation will be called. */
 567
 568 SILC_TASK_CALLBACK(silc_client_connect_failure)
 569 {
 570   SilcClientKEInternalContext *ctx =
 571     (SilcClientKEInternalContext *)context;
 572   SilcClient client = (SilcClient)ctx->client;
 573
 574   client->internal->ops->connected(client, ctx->sock->user_data,
 575                                    SILC_CLIENT_CONN_ERROR);
 576   if (ctx->packet)
 577     silc_packet_context_free(ctx->packet);
 578   silc_free(ctx);
 579 }
 580
 581 /* Callback called when error has occurred during connecting (auth) to
 582    the server.  The `connect' client operation will be called. */
 583
 584 SILC_TASK_CALLBACK(silc_client_connect_failure_auth)
 585 {
 586   SilcClientConnAuthInternalContext *ctx =
 587     (SilcClientConnAuthInternalContext *)context;
 588   SilcClient client = (SilcClient)ctx->client;
 589
 590   client->internal->ops->connected(client, ctx->sock->user_data,
 591                                    SILC_CLIENT_CONN_ERROR);
 592   silc_free(ctx);
 593 }
 594
 595 /* Start of the connection to the remote server. This is called after
 596    succesful TCP/IP connection has been established to the remote host. */
 597
 598 SILC_TASK_CALLBACK(silc_client_connect_to_server_start)
 599 {
 600   SilcClientInternalConnectContext *ctx =
 601     (SilcClientInternalConnectContext *)context;
 602   SilcClient client = ctx->client;
 603   SilcClientConnection conn = ctx->conn;
 604   int opt, opt_len = sizeof(opt);
 605
 606   SILC_LOG_DEBUG(("Start"));
 607
 608   /* Check the socket status as it might be in error */
 609   silc_net_get_socket_opt(fd, SOL_SOCKET, SO_ERROR, &opt, &opt_len);
 610   if (opt != 0) {
 611     if (ctx->tries < 2) {
 612       /* Connection failed but lets try again */
 613       client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_ERROR,
 614                                  "Could not connect to server %s: %s",
 615                                  ctx->host, strerror(opt));
 616       client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_AUDIT,
 617                                  "Connecting to port %d of server %s resumed",
 618                                  ctx->port, ctx->host);
 619
 620       /* Unregister old connection try */
 621       silc_schedule_unset_listen_fd(client->schedule, fd);
 622       silc_net_close_connection(fd);
 623       silc_schedule_task_del(client->schedule, ctx->task);
 624
 625       /* Try again */
 626       silc_client_connect_to_server_internal(ctx);
 627       ctx->tries++;
 628     } else {
 629       /* Connection failed and we won't try anymore */
 630       client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_ERROR,
 631                                  "Could not connect to server %s: %s",
 632                                  ctx->host, strerror(opt));
 633       silc_schedule_unset_listen_fd(client->schedule, fd);
 634       silc_net_close_connection(fd);
 635       silc_schedule_task_del(client->schedule, ctx->task);
 636       silc_free(ctx);
 637
 638       /* Notify application of failure */
 639       client->internal->ops->connected(client, conn, SILC_CLIENT_CONN_ERROR);
 640     }
 641     return;
 642   }
 643
 644   silc_schedule_unset_listen_fd(client->schedule, fd);
 645   silc_schedule_task_del(client->schedule, ctx->task);
 646   silc_free(ctx);
 647
 648   silc_client_start_key_exchange(client, conn, fd);
 649 }
 650
 651 /* Second part of the connecting to the server. This executed
 652    authentication protocol. */
 653
 654 SILC_TASK_CALLBACK(silc_client_connect_to_server_second)
 655 {
 656   SilcProtocol protocol = (SilcProtocol)context;
 657   SilcClientKEInternalContext *ctx =
 658     (SilcClientKEInternalContext *)protocol->context;
 659   SilcClient client = (SilcClient)ctx->client;
 660   SilcSocketConnection sock = NULL;
 661   SilcClientConnAuthInternalContext *proto_ctx;
 662
 663   SILC_LOG_DEBUG(("Start"));
 664
 665   if (protocol->state == SILC_PROTOCOL_STATE_ERROR ||
 666       protocol->state == SILC_PROTOCOL_STATE_FAILURE) {
 667     /* Error occured during protocol */
 668     SILC_LOG_DEBUG(("Error during KE protocol"));
 669     silc_protocol_free(protocol);
 670     silc_ske_free_key_material(ctx->keymat);
 671     if (ctx->ske)
 672       silc_ske_free(ctx->ske);
 673     if (ctx->dest_id)
 674       silc_free(ctx->dest_id);
 675     ctx->sock->protocol = NULL;
 676     silc_socket_free(ctx->sock);
 677
 678     /* Notify application of failure */
 679     silc_schedule_task_add(client->schedule, ctx->sock->sock,
 680                            silc_client_connect_failure, ctx,
 681                            0, 1, SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
 682     return;
 683   }
 684
 685   /* We now have the key material as the result of the key exchange
 686      protocol. Take the key material into use. Free the raw key material
 687      as soon as we've set them into use. */
 688   silc_client_protocol_ke_set_keys(ctx->ske, ctx->sock, ctx->keymat,
 689                                    ctx->ske->prop->cipher,
 690                                    ctx->ske->prop->pkcs,
 691                                    ctx->ske->prop->hash,
 692                                    ctx->ske->prop->hmac,
 693                                    ctx->ske->prop->group,
 694                                    ctx->responder);
 695   silc_ske_free_key_material(ctx->keymat);
 696
 697   /* Allocate internal context for the authentication protocol. This
 698      is sent as context for the protocol. */
 699   proto_ctx = silc_calloc(1, sizeof(*proto_ctx));
 700   proto_ctx->client = (void *)client;
 701   proto_ctx->sock = sock = ctx->sock;
 702   proto_ctx->ske = ctx->ske;    /* Save SKE object from previous protocol */
 703   proto_ctx->dest_id_type = ctx->dest_id_type;
 704   proto_ctx->dest_id = ctx->dest_id;
 705
 706   /* Free old protocol as it is finished now */
 707   silc_protocol_free(protocol);
 708   if (ctx->packet)
 709     silc_packet_context_free(ctx->packet);
 710   ctx->packet = NULL;
 711   silc_free(ctx);
 712   sock->protocol = NULL;
 713
 714   /* Resolve the authentication method to be used in this connection. The
 715      completion callback is called after the application has resolved
 716      the authentication method. */
 717   client->internal->ops->get_auth_method(client, sock->user_data,
 718                                          sock->hostname,
 719                                          sock->port,
 720                                          silc_client_resolve_auth_method,
 721                                          proto_ctx);
 722 }
 723
 724 /* Authentication method resolving callback. Application calls this function
 725    after we've called the client->internal->ops->get_auth_method
 726    client operation to resolve the authentication method. We will continue
 727    the executiong of the protocol in this function. */
 728
 729 void silc_client_resolve_auth_method(bool success,
 730                                      SilcProtocolAuthMeth auth_meth,
 731                                      const unsigned char *auth_data,
 732                                      SilcUInt32 auth_data_len, void *context)
 733 {
 734   SilcClientConnAuthInternalContext *proto_ctx =
 735     (SilcClientConnAuthInternalContext *)context;
 736   SilcClient client = (SilcClient)proto_ctx->client;
 737
 738   if (!success)
 739     auth_meth = SILC_AUTH_NONE;
 740
 741   proto_ctx->auth_meth = auth_meth;
 742
 743   if (success && auth_data && auth_data_len) {
 744
 745     /* Passphrase must be UTF-8 encoded, if it isn't encode it */
 746     if (auth_meth == SILC_AUTH_PASSWORD &&
 747         !silc_utf8_valid(auth_data, auth_data_len)) {
 748       int payload_len = 0;
 749       unsigned char *autf8 = NULL;
 750       payload_len = silc_utf8_encoded_len(auth_data, auth_data_len,
 751                                           SILC_STRING_ASCII);
 752       autf8 = silc_calloc(payload_len, sizeof(*autf8));
 753       auth_data_len = silc_utf8_encode(auth_data, auth_data_len,
 754                                        SILC_STRING_ASCII, autf8, payload_len);
 755       auth_data = autf8;
 756     }
 757
 758     proto_ctx->auth_data = silc_memdup(auth_data, auth_data_len);
 759     proto_ctx->auth_data_len = auth_data_len;
 760   }
 761
 762   /* Allocate the authenteication protocol and execute it. */
 763   silc_protocol_alloc(SILC_PROTOCOL_CLIENT_CONNECTION_AUTH,
 764                       &proto_ctx->sock->protocol, (void *)proto_ctx,
 765                       silc_client_connect_to_server_final);
 766
 767   /* Execute the protocol */
 768   silc_protocol_execute(proto_ctx->sock->protocol, client->schedule, 0, 0);
 769 }
 770
 771 /* Finalizes the connection to the remote SILC server. This is called
 772    after authentication protocol has been completed. This send our
 773    user information to the server to receive our client ID from
 774    server. */
 775
 776 SILC_TASK_CALLBACK(silc_client_connect_to_server_final)
 777 {
 778   SilcProtocol protocol = (SilcProtocol)context;
 779   SilcClientConnAuthInternalContext *ctx =
 780     (SilcClientConnAuthInternalContext *)protocol->context;
 781   SilcClient client = (SilcClient)ctx->client;
 782   SilcClientConnection conn = (SilcClientConnection)ctx->sock->user_data;
 783   SilcBuffer packet;
 784
 785   SILC_LOG_DEBUG(("Start"));
 786
 787   if (protocol->state == SILC_PROTOCOL_STATE_ERROR ||
 788       protocol->state == SILC_PROTOCOL_STATE_FAILURE) {
 789     /* Error occured during protocol */
 790     SILC_LOG_DEBUG(("Error during authentication protocol"));
 791     goto err;
 792   }
 793
 794   if (conn->internal->params.detach_data) {
 795     /* Send RESUME_CLIENT packet to the server, which is used to resume
 796        old detached session back. */
 797     SilcBuffer auth;
 798     SilcClientID *old_client_id;
 799     unsigned char *old_id;
 800     SilcUInt16 old_id_len;
 801
 802     if (!silc_client_process_detach_data(client, conn, &old_id, &old_id_len))
 803       goto err;
 804
 805     old_client_id = silc_id_str2id(old_id, old_id_len, SILC_ID_CLIENT);
 806     if (!old_client_id) {
 807       silc_free(old_id);
 808       goto err;
 809     }
 810
 811     /* Generate authentication data that server will verify */
 812     auth = silc_auth_public_key_auth_generate(client->public_key,
 813                                               client->private_key,
 814                                               client->rng,
 815                                               conn->internal->hash,
 816                                               old_client_id, SILC_ID_CLIENT);
 817     if (!auth) {
 818       silc_free(old_client_id);
 819       silc_free(old_id);
 820       goto err;
 821     }
 822
 823     packet = silc_buffer_alloc_size(2 + old_id_len + auth->len);
 824     silc_buffer_format(packet,
 825                        SILC_STR_UI_SHORT(old_id_len),
 826                        SILC_STR_UI_XNSTRING(old_id, old_id_len),
 827                        SILC_STR_UI_XNSTRING(auth->data, auth->len),
 828                        SILC_STR_END);
 829
 830     /* Send the packet */
 831     silc_client_packet_send(client, ctx->sock, SILC_PACKET_RESUME_CLIENT,
 832                             NULL, 0, NULL, NULL,
 833                             packet->data, packet->len, TRUE);
 834     silc_buffer_free(packet);
 835     silc_buffer_free(auth);
 836     silc_free(old_client_id);
 837     silc_free(old_id);
 838   } else {
 839     /* Send NEW_CLIENT packet to the server. We will become registered
 840        to the SILC network after sending this packet and we will receive
 841        client ID from the server. */
 842     packet = silc_buffer_alloc(2 + 2 + strlen(client->username) +
 843                                strlen(client->realname));
 844     silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
 845     silc_buffer_format(packet,
 846                        SILC_STR_UI_SHORT(strlen(client->username)),
 847                        SILC_STR_UI_XNSTRING(client->username,
 848                                             strlen(client->username)),
 849                        SILC_STR_UI_SHORT(strlen(client->realname)),
 850                        SILC_STR_UI_XNSTRING(client->realname,
 851                                             strlen(client->realname)),
 852                        SILC_STR_END);
 853
 854     /* Send the packet */
 855     silc_client_packet_send(client, ctx->sock, SILC_PACKET_NEW_CLIENT,
 856                             NULL, 0, NULL, NULL,
 857                             packet->data, packet->len, TRUE);
 858     silc_buffer_free(packet);
 859   }
 860
 861   /* Save remote ID. */
 862   conn->remote_id = ctx->dest_id;
 863   conn->remote_id_data = silc_id_id2str(ctx->dest_id, SILC_ID_SERVER);
 864   conn->remote_id_data_len = silc_id_get_len(ctx->dest_id, SILC_ID_SERVER);
 865
 866   /* Register re-key timeout */
 867   conn->internal->rekey->timeout = client->internal->params->rekey_secs;
 868   conn->internal->rekey->context = (void *)client;
 869   silc_schedule_task_add(client->schedule, conn->sock->sock,
 870                          silc_client_rekey_callback,
 871                          (void *)conn->sock, conn->internal->rekey->timeout, 0,
 872                          SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
 873
 874   silc_protocol_free(protocol);
 875   silc_free(ctx->auth_data);
 876   if (ctx->ske)
 877     silc_ske_free(ctx->ske);
 878   silc_socket_free(ctx->sock);
 879   silc_free(ctx);
 880   conn->sock->protocol = NULL;
 881   return;
 882
 883  err:
 884   silc_protocol_free(protocol);
 885   silc_free(ctx->auth_data);
 886   silc_free(ctx->dest_id);
 887   if (ctx->ske)
 888     silc_ske_free(ctx->ske);
 889   conn->sock->protocol = NULL;
 890   silc_socket_free(ctx->sock);
 891
 892   /* Notify application of failure */
 893   silc_schedule_task_add(client->schedule, ctx->sock->sock,
 894                          silc_client_connect_failure_auth, ctx,
 895                          0, 1, SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
 896 }
 897
 898 /* Internal routine that sends packet or marks packet to be sent. This
 899    is used directly only in special cases. Normal cases should use
 900    silc_server_packet_send. Returns < 0 on error. */
 901
 902 int silc_client_packet_send_real(SilcClient client,
 903                                  SilcSocketConnection sock,
 904                                  bool force_send)
 905 {
 906   int ret;
 907
 908   /* If rekey protocol is active we must assure that all packets are
 909      sent through packet queue. */
 910   if (SILC_CLIENT_IS_REKEY(sock))
 911     force_send = FALSE;
 912
 913   /* If outbound data is already pending do not force send */
 914   if (SILC_IS_OUTBUF_PENDING(sock))
 915     force_send = FALSE;
 916
 917   /* Send the packet */
 918   ret = silc_packet_send(sock, force_send);
 919   if (ret != -2)
 920     return ret;
 921
 922   /* Mark that there is some outgoing data available for this connection.
 923      This call sets the connection both for input and output (the input
 924      is set always and this call keeps the input setting, actually).
 925      Actual data sending is performed by silc_client_packet_process. */
 926   SILC_CLIENT_SET_CONNECTION_FOR_OUTPUT(client->schedule, sock->sock);
 927
 928   /* Mark to socket that data is pending in outgoing buffer. This flag
 929      is needed if new data is added to the buffer before the earlier
 930      put data is sent to the network. */
 931   SILC_SET_OUTBUF_PENDING(sock);
 932
 933   return 0;
 934 }
 935
 936 /* Packet processing callback. This is used to send and receive packets
 937    from network. This is generic task. */
 938
 939 SILC_TASK_CALLBACK_GLOBAL(silc_client_packet_process)
 940 {
 941   SilcClient client = (SilcClient)context;
 942   SilcSocketConnection sock = NULL;
 943   SilcClientConnection conn;
 944   int ret;
 945
 946   SILC_LOG_DEBUG(("Processing packet"));
 947
 948   SILC_CLIENT_GET_SOCK(client, fd, sock);
 949   if (sock == NULL)
 950     return;
 951
 952   conn = (SilcClientConnection)sock->user_data;
 953
 954   /* Packet sending */
 955   if (type == SILC_TASK_WRITE) {
 956     /* Do not send data to disconnected connection */
 957     if (SILC_IS_DISCONNECTED(sock))
 958       return;
 959
 960     ret = silc_packet_send(sock, TRUE);
 961
 962     /* If returned -2 could not write to connection now, will do
 963        it later. */
 964     if (ret == -2)
 965       return;
 966
 967     /* Error */
 968     if (ret == -1)
 969       return;
 970
 971     /* The packet has been sent and now it is time to set the connection
 972        back to only for input. When there is again some outgoing data
 973        available for this connection it will be set for output as well.
 974        This call clears the output setting and sets it only for input. */
 975     SILC_CLIENT_SET_CONNECTION_FOR_INPUT(client->schedule, fd);
 976     SILC_UNSET_OUTBUF_PENDING(sock);
 977
 978     silc_buffer_clear(sock->outbuf);
 979     return;
 980   }
 981
 982   /* Packet receiving */
 983   if (type == SILC_TASK_READ) {
 984     /* Read data from network */
 985     ret = silc_packet_receive(sock);
 986     if (ret < 0)
 987       return;
 988
 989     /* EOF */
 990     if (ret == 0) {
 991       SILC_LOG_DEBUG(("Read EOF"));
 992
 993       /* If connection is disconnecting already we will finally
 994          close the connection */
 995       if (SILC_IS_DISCONNECTING(sock)) {
 996         if (sock == conn->sock && sock->type != SILC_SOCKET_TYPE_CLIENT)
 997           client->internal->ops->disconnected(client, conn, 0, NULL);
 998         silc_client_close_connection_real(client, sock, conn);
 999         return;
1000       }
1001
1002       SILC_LOG_DEBUG(("EOF from connection %d", sock->sock));
1003       if (sock == conn->sock && sock->type != SILC_SOCKET_TYPE_CLIENT)
1004         client->internal->ops->disconnected(client, conn, 0, NULL);
1005       silc_client_close_connection_real(client, sock, conn);
1006       return;
1007     }
1008
1009     /* Process the packet. This will call the parser that will then
1010        decrypt and parse the packet. */
1011     if (sock->type != SILC_SOCKET_TYPE_UNKNOWN)
1012       silc_packet_receive_process(sock, FALSE, conn->internal->receive_key,
1013                                   conn->internal->hmac_receive,
1014                                   conn->internal->psn_receive,
1015                                   silc_client_packet_parse, client);
1016     else
1017       silc_packet_receive_process(sock, FALSE, NULL, NULL, 0,
1018                                   silc_client_packet_parse, client);
1019   }
1020 }
1021
1022 /* Parser callback called by silc_packet_receive_process. Thie merely
1023    registers timeout that will handle the actual parsing when appropriate. */
1024
1025 static bool silc_client_packet_parse(SilcPacketParserContext *parser_context,
1026                                      void *context)
1027 {
1028   SilcClient client = (SilcClient)context;
1029   SilcSocketConnection sock = parser_context->sock;
1030   SilcClientConnection conn = (SilcClientConnection)sock->user_data;
1031   SilcPacketContext *packet = parser_context->packet;
1032   SilcPacketType ret;
1033
1034   if (conn && conn->internal->hmac_receive && conn->sock == sock)
1035     conn->internal->psn_receive = parser_context->packet->sequence + 1;
1036
1037   /* Parse the packet immediately */
1038   if (parser_context->normal)
1039     ret = silc_packet_parse(packet, conn->internal->receive_key);
1040   else
1041     ret = silc_packet_parse_special(packet, conn->internal->receive_key);
1042
1043   if (ret == SILC_PACKET_NONE) {
1044     silc_packet_context_free(packet);
1045     silc_socket_free(parser_context->sock);
1046     silc_free(parser_context);
1047     return FALSE;
1048   }
1049
1050   /* If protocol for this connection is key exchange or rekey then we'll
1051      process all packets synchronously, since there might be packets in
1052      queue that we are not able to decrypt without first processing the
1053      packets before them. */
1054   if (sock->protocol && sock->protocol->protocol &&
1055       (sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_KEY_EXCHANGE ||
1056        sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_REKEY)) {
1057
1058     /* Parse the incoming packet type */
1059     silc_client_packet_parse_type(client, sock, packet);
1060
1061     /* Reprocess the buffer since we'll return FALSE. This is because
1062        the `conn->internal->receive_key' might have become valid by processing
1063        the previous packet */
1064     if (sock->type != SILC_SOCKET_TYPE_UNKNOWN)
1065       silc_packet_receive_process(sock, FALSE, conn->internal->receive_key,
1066                                   conn->internal->hmac_receive,
1067                                   conn->internal->psn_receive,
1068                                   silc_client_packet_parse, client);
1069     else
1070       silc_packet_receive_process(sock, FALSE, NULL, NULL, 0,
1071                                   silc_client_packet_parse, client);
1072
1073     silc_packet_context_free(packet);
1074     silc_socket_free(parser_context->sock);
1075     silc_free(parser_context);
1076
1077     return FALSE;
1078   }
1079
1080   /* Parse the incoming packet type */
1081   silc_client_packet_parse_type(client, sock, packet);
1082   silc_packet_context_free(packet);
1083   silc_socket_free(parser_context->sock);
1084   silc_free(parser_context);
1085   return TRUE;
1086 }
1087
1088 /* Parses the packet type and calls what ever routines the packet type
1089    requires. This is done for all incoming packets. */
1090
1091 void silc_client_packet_parse_type(SilcClient client,
1092                                    SilcSocketConnection sock,
1093                                    SilcPacketContext *packet)
1094 {
1095   SilcBuffer buffer = packet->buffer;
1096   SilcPacketType type = packet->type;
1097
1098   SILC_LOG_DEBUG(("Parsing %s packet", silc_get_packet_name(type)));
1099
1100   /* Parse the packet type */
1101   switch(type) {
1102
1103   case SILC_PACKET_DISCONNECT:
1104     silc_client_disconnected_by_server(client, sock, buffer);
1105     break;
1106
1107   case SILC_PACKET_SUCCESS:
1108     /*
1109      * Success received for something. For now we can have only
1110      * one protocol for connection executing at once hence this
1111      * success message is for whatever protocol is executing currently.
1112      */
1113     if (sock->protocol)
1114       silc_protocol_execute(sock->protocol, client->schedule, 0, 0);
1115     break;
1116
1117   case SILC_PACKET_FAILURE:
1118     /*
1119      * Failure received for some protocol. Set the protocol state to
1120      * error and call the protocol callback. This fill cause error on
1121      * protocol and it will call the final callback.
1122      */
1123     silc_client_process_failure(client, sock, packet);
1124     break;
1125
1126   case SILC_PACKET_REJECT:
1127     break;
1128
1129   case SILC_PACKET_NOTIFY:
1130     /*
1131      * Received notify message
1132      */
1133     silc_client_notify_by_server(client, sock, packet);
1134     break;
1135
1136   case SILC_PACKET_ERROR:
1137     /*
1138      * Received error message
1139      */
1140     silc_client_error_by_server(client, sock, buffer);
1141     break;
1142
1143   case SILC_PACKET_CHANNEL_MESSAGE:
1144     /*
1145      * Received message to (from, actually) a channel
1146      */
1147     silc_client_channel_message(client, sock, packet);
1148     break;
1149
1150   case SILC_PACKET_CHANNEL_KEY:
1151     /*
1152      * Received key for a channel. By receiving this key the client will be
1153      * able to talk to the channel it has just joined. This can also be
1154      * a new key for existing channel as keys expire peridiocally.
1155      */
1156     silc_client_receive_channel_key(client, sock, buffer);
1157     break;
1158
1159   case SILC_PACKET_PRIVATE_MESSAGE:
1160     /*
1161      * Received private message
1162      */
1163     silc_client_private_message(client, sock, packet);
1164     break;
1165
1166   case SILC_PACKET_PRIVATE_MESSAGE_KEY:
1167     /*
1168      * Received private message key
1169      */
1170     break;
1171
1172   case SILC_PACKET_COMMAND:
1173     /*
1174      * Received command packet, a special case since normally client
1175      * does not receive commands.
1176      */
1177     silc_client_command_process(client, sock, packet);
1178     break;
1179
1180   case SILC_PACKET_COMMAND_REPLY:
1181     /*
1182      * Recived reply for a command
1183      */
1184     silc_client_command_reply_process(client, sock, packet);
1185     break;
1186
1187   case SILC_PACKET_KEY_EXCHANGE:
1188     if (sock->protocol && sock->protocol->protocol &&
1189         sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_KEY_EXCHANGE) {
1190       SilcClientKEInternalContext *proto_ctx =
1191         (SilcClientKEInternalContext *)sock->protocol->context;
1192
1193       proto_ctx->packet = silc_packet_context_dup(packet);
1194       proto_ctx->dest_id_type = packet->src_id_type;
1195       proto_ctx->dest_id = silc_id_str2id(packet->src_id, packet->src_id_len,
1196                                           packet->src_id_type);
1197       if (!proto_ctx->dest_id)
1198         break;
1199
1200       /* Let the protocol handle the packet */
1201       silc_protocol_execute(sock->protocol, client->schedule, 0, 0);
1202     } else {
1203       SILC_LOG_ERROR(("Received Key Exchange packet but no key exchange "
1204                       "protocol active, packet dropped."));
1205     }
1206     break;
1207
1208   case SILC_PACKET_KEY_EXCHANGE_1:
1209     if (sock->protocol && sock->protocol->protocol &&
1210         (sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_KEY_EXCHANGE ||
1211          sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_REKEY)) {
1212
1213       if (sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_REKEY) {
1214         SilcClientRekeyInternalContext *proto_ctx =
1215           (SilcClientRekeyInternalContext *)sock->protocol->context;
1216
1217         if (proto_ctx->packet)
1218           silc_packet_context_free(proto_ctx->packet);
1219
1220         proto_ctx->packet = silc_packet_context_dup(packet);
1221
1222         /* Let the protocol handle the packet */
1223         silc_protocol_execute(sock->protocol, client->schedule, 0, 0);
1224       } else {
1225         SilcClientKEInternalContext *proto_ctx =
1226           (SilcClientKEInternalContext *)sock->protocol->context;
1227
1228         if (proto_ctx->packet)
1229           silc_packet_context_free(proto_ctx->packet);
1230
1231         proto_ctx->packet = silc_packet_context_dup(packet);
1232         proto_ctx->dest_id_type = packet->src_id_type;
1233         proto_ctx->dest_id = silc_id_str2id(packet->src_id, packet->src_id_len,
1234                                             packet->src_id_type);
1235         if (!proto_ctx->dest_id)
1236           break;
1237
1238         /* Let the protocol handle the packet */
1239         silc_protocol_execute(sock->protocol, client->schedule, 0, 0);
1240       }
1241     } else {
1242       SILC_LOG_ERROR(("Received Key Exchange 1 packet but no key exchange "
1243                       "protocol active, packet dropped."));
1244     }
1245     break;
1246
1247   case SILC_PACKET_KEY_EXCHANGE_2:
1248     if (sock->protocol && sock->protocol->protocol &&
1249         (sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_KEY_EXCHANGE ||
1250          sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_REKEY)) {
1251
1252       if (sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_REKEY) {
1253         SilcClientRekeyInternalContext *proto_ctx =
1254           (SilcClientRekeyInternalContext *)sock->protocol->context;
1255
1256         if (proto_ctx->packet)
1257           silc_packet_context_free(proto_ctx->packet);
1258
1259         proto_ctx->packet = silc_packet_context_dup(packet);
1260
1261         /* Let the protocol handle the packet */
1262         silc_protocol_execute(sock->protocol, client->schedule, 0, 0);
1263       } else {
1264         SilcClientKEInternalContext *proto_ctx =
1265           (SilcClientKEInternalContext *)sock->protocol->context;
1266
1267         if (proto_ctx->packet)
1268           silc_packet_context_free(proto_ctx->packet);
1269         if (proto_ctx->dest_id)
1270           silc_free(proto_ctx->dest_id);
1271         proto_ctx->packet = silc_packet_context_dup(packet);
1272         proto_ctx->dest_id_type = packet->src_id_type;
1273         proto_ctx->dest_id = silc_id_str2id(packet->src_id, packet->src_id_len,
1274                                             packet->src_id_type);
1275         if (!proto_ctx->dest_id)
1276           break;
1277
1278         /* Let the protocol handle the packet */
1279         silc_protocol_execute(sock->protocol, client->schedule, 0, 0);
1280       }
1281     } else {
1282       SILC_LOG_ERROR(("Received Key Exchange 2 packet but no key exchange "
1283                       "protocol active, packet dropped."));
1284     }
1285     break;
1286
1287   case SILC_PACKET_NEW_ID:
1288     {
1289       /*
1290        * Received new ID from server. This packet is received at
1291        * the connection to the server.  New ID is also received when
1292        * user changes nickname but in that case the new ID is received
1293        * as command reply and not as this packet type.
1294        */
1295       SilcIDPayload idp;
1296
1297       idp = silc_id_payload_parse(buffer->data, buffer->len);
1298       if (!idp)
1299         break;
1300       if (silc_id_payload_get_type(idp) != SILC_ID_CLIENT)
1301         break;
1302
1303       silc_client_receive_new_id(client, sock, idp);
1304       silc_id_payload_free(idp);
1305       break;
1306     }
1307
1308   case SILC_PACKET_HEARTBEAT:
1309     /*
1310      * Received heartbeat packet
1311      */
1312     SILC_LOG_DEBUG(("Heartbeat packet"));
1313     break;
1314
1315   case SILC_PACKET_KEY_AGREEMENT:
1316     /*
1317      * Received key agreement packet
1318      */
1319     SILC_LOG_DEBUG(("Key agreement packet"));
1320     silc_client_key_agreement(client, sock, packet);
1321     break;
1322
1323   case SILC_PACKET_REKEY:
1324     SILC_LOG_DEBUG(("Re-key packet"));
1325     /* We ignore this for now */
1326     break;
1327
1328   case SILC_PACKET_REKEY_DONE:
1329     SILC_LOG_DEBUG(("Re-key done packet"));
1330
1331     if (sock->protocol && sock->protocol->protocol &&
1332         sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_REKEY) {
1333
1334       SilcClientRekeyInternalContext *proto_ctx =
1335         (SilcClientRekeyInternalContext *)sock->protocol->context;
1336
1337       if (proto_ctx->packet)
1338         silc_packet_context_free(proto_ctx->packet);
1339
1340       proto_ctx->packet = silc_packet_context_dup(packet);
1341
1342       /* Let the protocol handle the packet */
1343       if (proto_ctx->responder == FALSE)
1344         silc_protocol_execute(sock->protocol, client->schedule, 0, 0);
1345       else
1346         /* Let the protocol handle the packet */
1347         silc_protocol_execute(sock->protocol, client->schedule,
1348                               0, 100000);
1349     } else {
1350       SILC_LOG_ERROR(("Received Re-key done packet but no re-key "
1351                       "protocol active, packet dropped."));
1352     }
1353     break;
1354
1355   case SILC_PACKET_CONNECTION_AUTH_REQUEST:
1356     /*
1357      * Reveived reply to our connection authentication method request
1358      * packet. This is used to resolve the authentication method for the
1359      * current session from the server if the client does not know it.
1360      */
1361     silc_client_connection_auth_request(client, sock, packet);
1362     break;
1363
1364   case SILC_PACKET_FTP:
1365     /* Received file transfer packet. */
1366     silc_client_ftp(client, sock, packet);
1367     break;
1368
1369   default:
1370     SILC_LOG_DEBUG(("Incorrect packet type %d, packet dropped", type));
1371     break;
1372   }
1373 }
1374
1375 /* Sends packet. This doesn't actually send the packet instead it assembles
1376    it and marks it to be sent. However, if force_send is TRUE the packet
1377    is sent immediately. if dst_id, cipher and hmac are NULL those parameters
1378    will be derived from sock argument. Otherwise the valid arguments sent
1379    are used. */
1380
1381 void silc_client_packet_send(SilcClient client,
1382                              SilcSocketConnection sock,
1383                              SilcPacketType type,
1384                              void *dst_id,
1385                              SilcIdType dst_id_type,
1386                              SilcCipher cipher,
1387                              SilcHmac hmac,
1388                              unsigned char *data,
1389                              SilcUInt32 data_len,
1390                              bool force_send)
1391 {
1392   SilcPacketContext packetdata;
1393   const SilcBufferStruct packet;
1394   int block_len;
1395   SilcUInt32 sequence = 0;
1396
1397   if (!sock)
1398     return;
1399
1400   SILC_LOG_DEBUG(("Sending packet, type %d", type));
1401
1402   /* Get data used in the packet sending, keys and stuff */
1403   if ((!cipher || !hmac || !dst_id) && sock->user_data) {
1404     if (!cipher && ((SilcClientConnection)sock->user_data)->internal->send_key)
1405       cipher = ((SilcClientConnection)sock->user_data)->internal->send_key;
1406
1407     if (!hmac && ((SilcClientConnection)sock->user_data)->internal->hmac_send)
1408       hmac = ((SilcClientConnection)sock->user_data)->internal->hmac_send;
1409
1410     if (!dst_id && ((SilcClientConnection)sock->user_data)->remote_id) {
1411       dst_id = ((SilcClientConnection)sock->user_data)->remote_id;
1412       dst_id_type = SILC_ID_SERVER;
1413     }
1414
1415     if (hmac)
1416       sequence = ((SilcClientConnection)sock->user_data)->internal->psn_send++;
1417
1418     /* Check for mandatory rekey */
1419     if (sequence == SILC_CLIENT_REKEY_THRESHOLD)
1420       silc_schedule_task_add(client->schedule, sock->sock,
1421                              silc_client_rekey_callback, sock, 0, 1,
1422                              SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
1423   }
1424
1425   block_len = cipher ? silc_cipher_get_block_len(cipher) : 0;
1426
1427   /* Set the packet context pointers */
1428   packetdata.flags = 0;
1429   packetdata.type = type;
1430   if (sock->user_data &&
1431       ((SilcClientConnection)sock->user_data)->local_id_data) {
1432     packetdata.src_id = ((SilcClientConnection)sock->user_data)->local_id_data;
1433     packetdata.src_id_len =
1434       silc_id_get_len(((SilcClientConnection)sock->user_data)->local_id,
1435                       SILC_ID_CLIENT);
1436   } else {
1437     packetdata.src_id = silc_calloc(SILC_ID_CLIENT_LEN, sizeof(unsigned char));
1438     packetdata.src_id_len = SILC_ID_CLIENT_LEN;
1439   }
1440   packetdata.src_id_type = SILC_ID_CLIENT;
1441   if (dst_id) {
1442     packetdata.dst_id = silc_id_id2str(dst_id, dst_id_type);
1443     packetdata.dst_id_len = silc_id_get_len(dst_id, dst_id_type);
1444     packetdata.dst_id_type = dst_id_type;
1445   } else {
1446     packetdata.dst_id = NULL;
1447     packetdata.dst_id_len = 0;
1448     packetdata.dst_id_type = SILC_ID_NONE;
1449   }
1450   data_len = SILC_PACKET_DATALEN(data_len, (SILC_PACKET_HEADER_LEN +
1451                                             packetdata.src_id_len +
1452                                             packetdata.dst_id_len));
1453   packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
1454     packetdata.src_id_len + packetdata.dst_id_len;
1455   if (type == SILC_PACKET_CONNECTION_AUTH)
1456     SILC_PACKET_PADLEN_MAX(packetdata.truelen, block_len, packetdata.padlen);
1457   else
1458     SILC_PACKET_PADLEN(packetdata.truelen, block_len, packetdata.padlen);
1459
1460   /* Create the outgoing packet */
1461   if (!silc_packet_assemble(&packetdata, client->rng, cipher, hmac, sock,
1462                             data, data_len, (const SilcBuffer)&packet)) {
1463     SILC_LOG_ERROR(("Error assembling packet"));
1464     return;
1465   }
1466
1467   /* Encrypt the packet */
1468   if (cipher)
1469     silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&packet,
1470                         packet.len);
1471
1472   SILC_LOG_HEXDUMP(("Packet (%d), len %d", sequence, packet.len),
1473                    packet.data, packet.len);
1474
1475   /* Now actually send the packet */
1476   silc_client_packet_send_real(client, sock, force_send);
1477 }
1478
1479 /* Packet sending routine for application.  This is the only routine that
1480    is provided for application to send SILC packets. */
1481
1482 bool silc_client_send_packet(SilcClient client,
1483                              SilcClientConnection conn,
1484                              SilcPacketType type,
1485                              const unsigned char *data,
1486                              SilcUInt32 data_len)
1487 {
1488
1489   assert(client);
1490   if (!conn)
1491     return FALSE;
1492
1493   silc_client_packet_send(client, conn->sock, type, NULL, 0, NULL, NULL,
1494                           (unsigned char *)data, data_len, TRUE);
1495   return TRUE;
1496 }
1497
1498 void silc_client_packet_queue_purge(SilcClient client,
1499                                     SilcSocketConnection sock)
1500 {
1501   if (sock && SILC_IS_OUTBUF_PENDING(sock) &&
1502       !(SILC_IS_DISCONNECTED(sock))) {
1503     int ret;
1504
1505     ret = silc_packet_send(sock, TRUE);
1506     if (ret == -2) {
1507       if (sock->outbuf && sock->outbuf->len > 0) {
1508         /* Couldn't send all data, put the queue back up, we'll send
1509            rest later. */
1510         SILC_CLIENT_SET_CONNECTION_FOR_OUTPUT(client->schedule, sock->sock);
1511         SILC_SET_OUTBUF_PENDING(sock);
1512         return;
1513       }
1514     }
1515
1516     /* Purged all data */
1517     SILC_UNSET_OUTBUF_PENDING(sock);
1518     SILC_CLIENT_SET_CONNECTION_FOR_INPUT(client->schedule, sock->sock);
1519     silc_buffer_clear(sock->outbuf);
1520   }
1521 }
1522
1523 /* Closes connection to remote end. Free's all allocated data except
1524    for some information such as nickname etc. that are valid at all time.
1525    If the `sock' is NULL then the conn->sock will be used.  If `sock' is
1526    provided it will be checked whether the sock and `conn->sock' are the
1527    same (they can be different, ie. a socket can use `conn' as its
1528    connection but `conn->sock' might be actually a different connection
1529    than the `sock'). */
1530
1531 void silc_client_close_connection_real(SilcClient client,
1532                                        SilcSocketConnection sock,
1533                                        SilcClientConnection conn)
1534 {
1535   int del = FALSE;
1536
1537   SILC_LOG_DEBUG(("Start"));
1538
1539   if (!sock && !conn)
1540     return;
1541
1542   if (!sock || (sock && conn->sock == sock))
1543     del = TRUE;
1544   if (!sock)
1545     sock = conn->sock;
1546
1547   if (!sock) {
1548     if (del && conn)
1549       silc_client_del_connection(client, conn);
1550     return;
1551   }
1552
1553   /* We won't listen for this connection anymore */
1554   silc_schedule_unset_listen_fd(client->schedule, sock->sock);
1555
1556   /* Unregister all tasks */
1557   silc_schedule_task_del_by_fd(client->schedule, sock->sock);
1558
1559   /* Close the actual connection */
1560   silc_net_close_connection(sock->sock);
1561
1562   /* Cancel any active protocol */
1563   if (sock->protocol) {
1564     if (sock->protocol->protocol->type ==
1565         SILC_PROTOCOL_CLIENT_KEY_EXCHANGE ||
1566         sock->protocol->protocol->type ==
1567         SILC_PROTOCOL_CLIENT_CONNECTION_AUTH) {
1568       sock->protocol->state = SILC_PROTOCOL_STATE_ERROR;
1569       silc_protocol_execute_final(sock->protocol, client->schedule);
1570       /* The application will recall this function with these protocols
1571          (the ops->connected client operation). */
1572       return;
1573     } else {
1574       sock->protocol->state = SILC_PROTOCOL_STATE_ERROR;
1575       silc_protocol_execute_final(sock->protocol, client->schedule);
1576       sock->protocol = NULL;
1577     }
1578   }
1579
1580   /* Free everything */
1581   if (del && sock->user_data)
1582     silc_client_del_connection(client, conn);
1583
1584   silc_socket_free(sock);
1585 }
1586
1587 /* Closes the connection to the remote end */
1588
1589 void silc_client_close_connection(SilcClient client,
1590                                   SilcClientConnection conn)
1591 {
1592   silc_client_close_connection_real(client, NULL, conn);
1593 }
1594
1595 /* Called when we receive disconnection packet from server. This
1596    closes our end properly and displays the reason of the disconnection
1597    on the screen. */
1598
1599 SILC_TASK_CALLBACK(silc_client_disconnected_by_server_later)
1600 {
1601   SilcClient client = (SilcClient)context;
1602   SilcSocketConnection sock;
1603
1604   SILC_CLIENT_GET_SOCK(client, fd, sock);
1605   if (sock == NULL)
1606     return;
1607
1608   silc_client_close_connection_real(client, sock, sock->user_data);
1609 }
1610
1611 /* Called when we receive disconnection packet from server. This
1612    closes our end properly and displays the reason of the disconnection
1613    on the screen. */
1614
1615 void silc_client_disconnected_by_server(SilcClient client,
1616                                         SilcSocketConnection sock,
1617                                         SilcBuffer packet)
1618 {
1619   SilcClientConnection conn;
1620   SilcStatus status;
1621   char *message = NULL;
1622
1623   SILC_LOG_DEBUG(("Server disconnected us, sock %d", sock->sock));
1624
1625   if (packet->len < 1)
1626     return;
1627
1628   status = (SilcStatus)packet->data[0];
1629
1630   if (packet->len > 1 &&
1631       silc_utf8_valid(packet->data + 1, packet->len - 1))
1632     message = silc_memdup(packet->data + 1, packet->len - 1);
1633
1634   conn = (SilcClientConnection)sock->user_data;
1635   if (sock == conn->sock && sock->type != SILC_SOCKET_TYPE_CLIENT)
1636     client->internal->ops->disconnected(client, conn, status, message);
1637
1638   silc_free(message);
1639
1640   SILC_SET_DISCONNECTED(sock);
1641
1642   /* Close connection through scheduler. */
1643   silc_schedule_task_add(client->schedule, sock->sock,
1644                          silc_client_disconnected_by_server_later,
1645                          client, 0, 1, SILC_TASK_TIMEOUT,
1646                          SILC_TASK_PRI_NORMAL);
1647 }
1648
1649 /* Received error message from server. Display it on the screen.
1650    We don't take any action what so ever of the error message. */
1651
1652 void silc_client_error_by_server(SilcClient client,
1653                                  SilcSocketConnection sock,
1654                                  SilcBuffer message)
1655 {
1656   char *msg;
1657
1658   msg = silc_memdup(message->data, message->len);
1659   client->internal->ops->say(client, sock->user_data,
1660                              SILC_CLIENT_MESSAGE_AUDIT, msg);
1661   silc_free(msg);
1662 }
1663
1664 /* Auto-nicking callback to send NICK command to server. */
1665
1666 SILC_TASK_CALLBACK(silc_client_send_auto_nick)
1667 {
1668   SilcClientConnection conn = (SilcClientConnection)context;
1669   SilcClient client = conn->client;
1670   if (client)
1671     silc_client_command_send(client, conn, SILC_COMMAND_NICK,
1672                              ++conn->cmd_ident, 1, 1,
1673                              client->nickname, strlen(client->nickname));
1674 }
1675
1676 /* Client session resuming callback.  If the session was resumed
1677    this callback is called after the resuming is completed.  This
1678    will call the `connect' client operation to the application
1679    since it has not been called yet. */
1680
1681 static void silc_client_resume_session_cb(SilcClient client,
1682                                           SilcClientConnection conn,
1683                                           bool success,
1684                                           void *context)
1685 {
1686   SilcBuffer sidp;
1687
1688   /* Notify application that connection is created to server */
1689   client->internal->ops->connected(client, conn, success ?
1690                                    SILC_CLIENT_CONN_SUCCESS_RESUME :
1691                                    SILC_CLIENT_CONN_ERROR);
1692
1693   if (success) {
1694     /* Issue INFO command to fetch the real server name and server
1695        information and other stuff. */
1696     silc_client_command_register(client, SILC_COMMAND_INFO, NULL, NULL,
1697                                  silc_client_command_reply_info_i, 0,
1698                                  ++conn->cmd_ident);
1699     sidp = silc_id_payload_encode(conn->remote_id, SILC_ID_SERVER);
1700     silc_client_command_send(client, conn, SILC_COMMAND_INFO,
1701                              conn->cmd_ident, 1, 2, sidp->data, sidp->len);
1702     silc_buffer_free(sidp);
1703   }
1704 }
1705
1706 /* Processes the received new Client ID from server. Old Client ID is
1707    deleted from cache and new one is added. */
1708
1709 void silc_client_receive_new_id(SilcClient client,
1710                                 SilcSocketConnection sock,
1711                                 SilcIDPayload idp)
1712 {
1713   SilcClientConnection conn = (SilcClientConnection)sock->user_data;
1714   int connecting = FALSE;
1715   SilcClientID *client_id = silc_id_payload_get_id(idp);
1716
1717   if (!conn->local_entry)
1718     connecting = TRUE;
1719
1720   /* Delete old ID from ID cache */
1721   if (conn->local_id) {
1722     /* Check whether they are different */
1723     if (SILC_ID_CLIENT_COMPARE(conn->local_id, client_id)) {
1724       silc_free(client_id);
1725       return;
1726     }
1727
1728     silc_idcache_del_by_context(conn->internal->client_cache,
1729                                 conn->local_entry);
1730     silc_free(conn->local_id);
1731   }
1732
1733   /* Save the new ID */
1734
1735   if (conn->local_id_data)
1736     silc_free(conn->local_id_data);
1737
1738   conn->local_id = client_id;
1739   conn->local_id_data = silc_id_payload_get_data(idp);
1740   conn->local_id_data_len = silc_id_payload_get_len(idp);;
1741
1742   if (!conn->local_entry)
1743     conn->local_entry = silc_calloc(1, sizeof(*conn->local_entry));
1744
1745   conn->local_entry->nickname = conn->nickname;
1746   if (!conn->local_entry->username)
1747     conn->local_entry->username = strdup(client->username);
1748   if (!conn->local_entry->server)
1749     conn->local_entry->server = strdup(conn->remote_host);
1750   conn->local_entry->id = conn->local_id;
1751   conn->local_entry->valid = TRUE;
1752   if (!conn->local_entry->channels)
1753     conn->local_entry->channels = silc_hash_table_alloc(1, silc_hash_ptr,
1754                                                         NULL, NULL,
1755                                                         NULL, NULL, NULL,
1756                                                         TRUE);
1757
1758   /* Put it to the ID cache */
1759   silc_idcache_add(conn->internal->client_cache,
1760                    strdup(conn->nickname), conn->local_id,
1761                    (void *)conn->local_entry, 0, NULL);
1762
1763   if (connecting) {
1764     SilcBuffer sidp;
1765
1766     /* Issue IDENTIFY command for itself to get resolved hostname
1767        correctly from server. */
1768     silc_client_command_register(client, SILC_COMMAND_IDENTIFY, NULL, NULL,
1769                                  silc_client_command_reply_identify_i, 0,
1770                                  ++conn->cmd_ident);
1771     sidp = silc_id_payload_encode(conn->local_entry->id, SILC_ID_CLIENT);
1772     silc_client_command_send(client, conn, SILC_COMMAND_IDENTIFY,
1773                              conn->cmd_ident, 1, 5, sidp->data, sidp->len);
1774     silc_buffer_free(sidp);
1775
1776     if (!conn->internal->params.detach_data) {
1777       /* Send NICK command if the nickname was set by the application (and is
1778          not same as the username). Send this with little timeout. */
1779       if (client->nickname && strcmp(client->nickname, client->username))
1780         silc_schedule_task_add(client->schedule, 0,
1781                                silc_client_send_auto_nick, conn,
1782                                1, 0, SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
1783
1784       /* Notify application of successful connection. We do it here now that
1785          we've received the Client ID and are allowed to send traffic. */
1786       client->internal->ops->connected(client, conn, SILC_CLIENT_CONN_SUCCESS);
1787
1788       /* Issue INFO command to fetch the real server name and server
1789          information and other stuff. */
1790       silc_client_command_register(client, SILC_COMMAND_INFO, NULL, NULL,
1791                                    silc_client_command_reply_info_i, 0,
1792                                    ++conn->cmd_ident);
1793       sidp = silc_id_payload_encode(conn->remote_id, SILC_ID_SERVER);
1794       silc_client_command_send(client, conn, SILC_COMMAND_INFO,
1795                                conn->cmd_ident, 1, 2, sidp->data, sidp->len);
1796       silc_buffer_free(sidp);
1797     } else {
1798       /* We are resuming session.  Start resolving informations from the
1799          server we need to set the client libary in the state before
1800          detaching the session.  The connect client operation is called
1801          after this is successfully completed */
1802       silc_client_resume_session(client, conn, silc_client_resume_session_cb,
1803                                  NULL);
1804     }
1805   }
1806 }
1807
1808 /* Removes a client entry from all channels it has joined. */
1809
1810 void silc_client_remove_from_channels(SilcClient client,
1811                                       SilcClientConnection conn,
1812                                       SilcClientEntry client_entry)
1813 {
1814   SilcHashTableList htl;
1815   SilcChannelUser chu;
1816
1817   silc_hash_table_list(client_entry->channels, &htl);
1818   while (silc_hash_table_get(&htl, NULL, (void **)&chu)) {
1819     silc_hash_table_del(chu->client->channels, chu->channel);
1820     silc_hash_table_del(chu->channel->user_list, chu->client);
1821     silc_free(chu);
1822   }
1823
1824   silc_hash_table_list_reset(&htl);
1825 }
1826
1827 /* Replaces `old' client entries from all channels to `new' client entry.
1828    This can be called for example when nickname changes and old ID entry
1829    is replaced from ID cache with the new one. If the old ID entry is only
1830    updated, then this fucntion needs not to be called. */
1831
1832 void silc_client_replace_from_channels(SilcClient client,
1833                                        SilcClientConnection conn,
1834                                        SilcClientEntry old,
1835                                        SilcClientEntry new)
1836 {
1837   SilcHashTableList htl;
1838   SilcChannelUser chu;
1839
1840   silc_hash_table_list(old->channels, &htl);
1841   while (silc_hash_table_get(&htl, NULL, (void **)&chu)) {
1842     /* Replace client entry */
1843     silc_hash_table_del(chu->client->channels, chu->channel);
1844     silc_hash_table_del(chu->channel->user_list, chu->client);
1845
1846     chu->client = new;
1847     silc_hash_table_add(chu->channel->user_list, chu->client, chu);
1848     silc_hash_table_add(chu->client->channels, chu->channel, chu);
1849   }
1850   silc_hash_table_list_reset(&htl);
1851 }
1852
1853 /* Registers failure timeout to process the received failure packet
1854    with timeout. */
1855
1856 void silc_client_process_failure(SilcClient client,
1857                                  SilcSocketConnection sock,
1858                                  SilcPacketContext *packet)
1859 {
1860   SilcUInt32 failure = 0;
1861
1862   if (sock->protocol) {
1863     if (packet->buffer->len >= 4)
1864       SILC_GET32_MSB(failure, packet->buffer->data);
1865
1866     /* Notify application */
1867     client->internal->ops->failure(client, sock->user_data, sock->protocol,
1868                                    (void *)failure);
1869   }
1870 }
1871
1872 /* A timeout callback for the re-key. We will be the initiator of the
1873    re-key protocol. */
1874
1875 SILC_TASK_CALLBACK_GLOBAL(silc_client_rekey_callback)
1876 {
1877   SilcSocketConnection sock = (SilcSocketConnection)context;
1878   SilcClientConnection conn = (SilcClientConnection)sock->user_data;
1879   SilcClient client = (SilcClient)conn->internal->rekey->context;
1880   SilcProtocol protocol;
1881   SilcClientRekeyInternalContext *proto_ctx;
1882
1883   SILC_LOG_DEBUG(("Start"));
1884
1885   /* If rekey protocol is active already wait for it to finish */
1886   if (sock->protocol && sock->protocol->protocol &&
1887       sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_REKEY)
1888     return;
1889
1890   /* Allocate internal protocol context. This is sent as context
1891      to the protocol. */
1892   proto_ctx = silc_calloc(1, sizeof(*proto_ctx));
1893   proto_ctx->client = (void *)client;
1894   proto_ctx->sock = silc_socket_dup(sock);
1895   proto_ctx->responder = FALSE;
1896   proto_ctx->pfs = conn->internal->rekey->pfs;
1897
1898   /* Perform rekey protocol. Will call the final callback after the
1899      protocol is over. */
1900   silc_protocol_alloc(SILC_PROTOCOL_CLIENT_REKEY,
1901                       &protocol, proto_ctx, silc_client_rekey_final);
1902   sock->protocol = protocol;
1903
1904   /* Run the protocol */
1905   silc_protocol_execute(protocol, client->schedule, 0, 0);
1906 }
1907
1908 /* The final callback for the REKEY protocol. This will actually take the
1909    new key material into use. */
1910
1911 SILC_TASK_CALLBACK(silc_client_rekey_final)
1912 {
1913   SilcProtocol protocol = (SilcProtocol)context;
1914   SilcClientRekeyInternalContext *ctx =
1915     (SilcClientRekeyInternalContext *)protocol->context;
1916   SilcClient client = (SilcClient)ctx->client;
1917   SilcSocketConnection sock = ctx->sock;
1918   SilcClientConnection conn = (SilcClientConnection)sock->user_data;
1919
1920   SILC_LOG_DEBUG(("Start"));
1921
1922   if (protocol->state == SILC_PROTOCOL_STATE_ERROR ||
1923       protocol->state == SILC_PROTOCOL_STATE_FAILURE) {
1924     /* Error occured during protocol */
1925     silc_protocol_cancel(protocol, client->schedule);
1926     silc_protocol_free(protocol);
1927     sock->protocol = NULL;
1928     if (ctx->packet)
1929       silc_packet_context_free(ctx->packet);
1930     if (ctx->ske)
1931       silc_ske_free(ctx->ske);
1932     silc_socket_free(ctx->sock);
1933     silc_free(ctx);
1934     return;
1935   }
1936
1937   /* Purge the outgoing data queue to assure that all rekey packets really
1938      go to the network before we quit the protocol. */
1939   silc_client_packet_queue_purge(client, sock);
1940
1941   /* Re-register re-key timeout */
1942   if (ctx->responder == FALSE)
1943     silc_schedule_task_add(client->schedule, sock->sock,
1944                            silc_client_rekey_callback,
1945                            sock, conn->internal->rekey->timeout, 0,
1946                            SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
1947
1948   /* Cleanup */
1949   silc_protocol_free(protocol);
1950   sock->protocol = NULL;
1951   if (ctx->packet)
1952     silc_packet_context_free(ctx->packet);
1953   if (ctx->ske)
1954     silc_ske_free(ctx->ske);
1955   silc_socket_free(ctx->sock);
1956   silc_free(ctx);
1957 }
1958
1959 /* Processes incoming connection authentication method request packet.
1960    It is a reply to our previously sent request. The packet can be used
1961    to resolve the authentication method for the current session if the
1962    client does not know it beforehand. */
1963
1964 void silc_client_connection_auth_request(SilcClient client,
1965                                          SilcSocketConnection sock,
1966                                          SilcPacketContext *packet)
1967 {
1968   SilcClientConnection conn = (SilcClientConnection)sock->user_data;
1969   SilcUInt16 conn_type, auth_meth;
1970   int ret;
1971
1972   /* If we haven't send our request then ignore this one. */
1973   if (!conn->internal->connauth)
1974     return;
1975
1976   /* Parse the payload */
1977   ret = silc_buffer_unformat(packet->buffer,
1978                              SILC_STR_UI_SHORT(&conn_type),
1979                              SILC_STR_UI_SHORT(&auth_meth),
1980                              SILC_STR_END);
1981   if (ret == -1)
1982     auth_meth = SILC_AUTH_NONE;
1983
1984   /* Call the request callback to notify application for received
1985      authentication method information. */
1986   if (conn->internal->connauth->callback)
1987     (*conn->internal->connauth->callback)(client, conn, auth_meth,
1988                                           conn->internal->connauth->context);
1989
1990   silc_schedule_task_del(client->schedule, conn->internal->connauth->timeout);
1991
1992   silc_free(conn->internal->connauth);
1993   conn->internal->connauth = NULL;
1994 }
1995
1996 /* Timeout task callback called if the server does not reply to our
1997    connection authentication method request in the specified time interval. */
1998
1999 SILC_TASK_CALLBACK(silc_client_request_authentication_method_timeout)
2000 {
2001   SilcClientConnection conn = (SilcClientConnection)context;
2002   SilcClient client = conn->client;
2003
2004   if (!conn->internal->connauth)
2005     return;
2006
2007   /* Call the request callback to notify application */
2008   if (conn->internal->connauth->callback)
2009     (*conn->internal->connauth->callback)(client, conn, SILC_AUTH_NONE,
2010                                           conn->internal->connauth->context);
2011
2012   silc_free(conn->internal->connauth);
2013   conn->internal->connauth = NULL;
2014 }
2015
2016 /* This function can be used to request the current authentication method
2017    from the server. This may be called when connecting to the server
2018    and the client library requests the authentication data from the
2019    application. If the application does not know the current authentication
2020    method it can request it from the server using this function.
2021    The `callback' with `context' will be called after the server has
2022    replied back with the current authentication method. */
2023
2024 void
2025 silc_client_request_authentication_method(SilcClient client,
2026                                           SilcClientConnection conn,
2027                                           SilcConnectionAuthRequest callback,
2028                                           void *context)
2029 {
2030   SilcClientConnAuthRequest connauth;
2031   SilcBuffer packet;
2032
2033   assert(client && conn);
2034   connauth = silc_calloc(1, sizeof(*connauth));
2035   connauth->callback = callback;
2036   connauth->context = context;
2037
2038   if (conn->internal->connauth)
2039     silc_free(conn->internal->connauth);
2040
2041   conn->internal->connauth = connauth;
2042
2043   /* Assemble the request packet and send it to the server */
2044   packet = silc_buffer_alloc(4);
2045   silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
2046   silc_buffer_format(packet,
2047                      SILC_STR_UI_SHORT(SILC_SOCKET_TYPE_CLIENT),
2048                      SILC_STR_UI_SHORT(SILC_AUTH_NONE),
2049                      SILC_STR_END);
2050   silc_client_packet_send(client, conn->sock,
2051                           SILC_PACKET_CONNECTION_AUTH_REQUEST,
2052                           NULL, 0, NULL, NULL,
2053                           packet->data, packet->len, FALSE);
2054   silc_buffer_free(packet);
2055
2056   /* Register a timeout in case server does not reply anything back. */
2057   connauth->timeout =
2058     silc_schedule_task_add(client->schedule, conn->sock->sock,
2059                            silc_client_request_authentication_method_timeout,
2060                            conn,
2061                            client->internal->params->connauth_request_secs, 0,
2062                            SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
2063 }