lib/silcclient/client.c

   1 /*
   2
   3   client.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 1997 - 2007 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 "silc.h"
  22 #include "silcclient.h"
  23 #include "client_internal.h"
  24
  25 /************************** Types and definitions ***************************/
  26
  27
  28 /************************ Static utility functions **************************/
  29
  30 /* Connection machine FSM destructor.  This will finish the thread where
  31    the machine was running and deletes the connection context. */
  32
  33 static void silc_client_connection_destructor(SilcFSM fsm,
  34                                               void *fsm_context,
  35                                               void *destructor_context)
  36 {
  37   SilcClientConnection conn = fsm_context;
  38   SilcFSMThread thread = destructor_context;
  39
  40   SILC_LOG_DEBUG(("Connection %p finished", conn));
  41
  42   /* Delete connection */
  43   silc_client_del_connection(conn->client, conn);
  44
  45   /* Finish the thread were this machine was running */
  46   silc_fsm_finish(thread);
  47 }
  48
  49 /* Connection thread FSM destructor.  This was the thread where the connection
  50    machine was running (may be real thread).  From here we notify client
  51    that the connection thread has finished. */
  52
  53 static void silc_client_connection_finished(SilcFSMThread fsm,
  54                                             void *fsm_context,
  55                                             void *destructor_context)
  56 {
  57   SilcClient client = silc_fsm_get_state_context(fsm);
  58
  59   /* Signal client that we have finished */
  60   silc_atomic_sub_int16(&client->internal->conns, 1);
  61   client->internal->connection_closed = TRUE;
  62   SILC_FSM_EVENT_SIGNAL(&client->internal->wait_event);
  63
  64   silc_fsm_free(fsm);
  65 }
  66
  67 /* Packet FSM thread destructor */
  68
  69 static void silc_client_packet_destructor(SilcFSMThread thread,
  70                                           void *thread_context,
  71                                           void *destructor_context)
  72 {
  73   SilcClientConnection conn = thread_context;
  74
  75   /* Add thread back to thread pool */
  76   silc_list_add(conn->internal->thread_pool, thread);
  77   if (silc_list_count(conn->internal->thread_pool) == 1)
  78     silc_list_start(conn->internal->thread_pool);
  79 }
  80
  81 /* Packet engine callback to receive a packet */
  82
  83 static SilcBool silc_client_packet_receive(SilcPacketEngine engine,
  84                                            SilcPacketStream stream,
  85                                            SilcPacket packet,
  86                                            void *callback_context,
  87                                            void *stream_context)
  88 {
  89   SilcClientConnection conn = stream_context;
  90   SilcFSMThread thread;
  91
  92   /* Packets we do not handle */
  93   switch (packet->type) {
  94   case SILC_PACKET_HEARTBEAT:
  95   case SILC_PACKET_SUCCESS:
  96   case SILC_PACKET_FAILURE:
  97   case SILC_PACKET_REJECT:
  98   case SILC_PACKET_KEY_EXCHANGE:
  99   case SILC_PACKET_KEY_EXCHANGE_1:
 100   case SILC_PACKET_KEY_EXCHANGE_2:
 101   case SILC_PACKET_REKEY_DONE:
 102   case SILC_PACKET_CONNECTION_AUTH:
 103     return FALSE;
 104     break;
 105   }
 106
 107   /* Get packet processing thread */
 108   thread = silc_list_get(conn->internal->thread_pool);
 109   if (!thread) {
 110     thread = silc_fsm_thread_alloc(&conn->internal->fsm, conn,
 111                                    silc_client_packet_destructor, NULL, FALSE);
 112     if (!thread)
 113       return FALSE;
 114   } else {
 115     silc_list_del(conn->internal->thread_pool, thread);
 116     silc_fsm_thread_init(thread, &conn->internal->fsm, conn,
 117                          silc_client_packet_destructor, NULL, FALSE);
 118   }
 119
 120   /* Process packet in thread */
 121   silc_fsm_set_state_context(thread, packet);
 122   silc_fsm_start_sync(thread, silc_client_connection_st_packet);
 123
 124   return TRUE;
 125 }
 126
 127 /* Packet engine callback to indicate end of stream */
 128
 129 static void silc_client_packet_eos(SilcPacketEngine engine,
 130                                    SilcPacketStream stream,
 131                                    void *callback_context,
 132                                    void *stream_context)
 133 {
 134   SilcClientConnection conn = stream_context;
 135
 136   SILC_LOG_DEBUG(("Remote disconnected connection"));
 137
 138   /* Signal to close connection */
 139   conn->internal->status = SILC_CLIENT_CONN_DISCONNECTED;
 140   if (!conn->internal->disconnected) {
 141     conn->internal->disconnected = TRUE;
 142     SILC_FSM_EVENT_SIGNAL(&conn->internal->wait_event);
 143   }
 144 }
 145
 146 /* Packet engine callback to indicate error */
 147
 148 static void silc_client_packet_error(SilcPacketEngine engine,
 149                                      SilcPacketStream stream,
 150                                      SilcPacketError error,
 151                                      void *callback_context,
 152                                      void *stream_context)
 153 {
 154   /* Nothing */
 155 }
 156
 157 /* Packet stream callbacks */
 158 static SilcPacketCallbacks silc_client_stream_cbs =
 159 {
 160   silc_client_packet_receive,
 161   silc_client_packet_eos,
 162   silc_client_packet_error
 163 };
 164
 165 /* FSM destructor */
 166
 167 void silc_client_fsm_destructor(SilcFSM fsm, void *fsm_context,
 168                                 void *destructor_context)
 169 {
 170   silc_fsm_free(fsm);
 171 }
 172
 173 /* Connect abort operation */
 174
 175 static void silc_client_connect_abort(SilcAsyncOperation op, void *context)
 176 {
 177   SilcClientConnection conn = context;
 178
 179   SILC_LOG_DEBUG(("Connection %p aborted by application", conn));
 180
 181   /* Connection callback will not be called after user aborted connecting */
 182   conn->callback = NULL;
 183
 184   /* Signal to close connection */
 185   if (!conn->internal->disconnected) {
 186     conn->internal->disconnected = TRUE;
 187     SILC_FSM_EVENT_SIGNAL(&conn->internal->wait_event);
 188   }
 189 }
 190
 191 /************************** Connection's machine ****************************/
 192
 193 /* Start the connection's state machine.  If threads are in use the machine
 194    is always executed in a real thread. */
 195
 196 SILC_FSM_STATE(silc_client_connection_st_start)
 197 {
 198   SilcClientConnection conn = fsm_context;
 199   SilcFSM connfsm;
 200
 201   /* Take scheduler for connection */
 202   conn->internal->schedule = silc_fsm_get_schedule(fsm);
 203
 204   /*** Run connection machine */
 205   connfsm = &conn->internal->fsm;
 206   silc_fsm_init(connfsm, conn, silc_client_connection_destructor,
 207                 fsm, conn->internal->schedule);
 208   silc_fsm_event_init(&conn->internal->wait_event, connfsm);
 209   silc_fsm_start_sync(connfsm, silc_client_connection_st_run);
 210
 211   /* Schedule any events set in initialization */
 212   if (conn->internal->connect)
 213     SILC_FSM_EVENT_SIGNAL(&conn->internal->wait_event);
 214   if (conn->internal->key_exchange)
 215     SILC_FSM_EVENT_SIGNAL(&conn->internal->wait_event);
 216
 217   /* Wait until this thread is terminated from the machine destructor */
 218   return SILC_FSM_WAIT;
 219 }
 220
 221 /* Connection machine main state.  This handles various connection related
 222    events, but not packet processing.  It's done in dedicated packet
 223    processing FSM thread. */
 224
 225 SILC_FSM_STATE(silc_client_connection_st_run)
 226 {
 227   SilcClientConnection conn = fsm_context;
 228   SilcFSMThread thread;
 229
 230   /* Wait for events */
 231   SILC_FSM_EVENT_WAIT(&conn->internal->wait_event);
 232
 233   /* Process events */
 234   thread = &conn->internal->event_thread;
 235
 236   if (conn->internal->connect) {
 237     SILC_LOG_DEBUG(("Event: connect"));
 238     conn->internal->connect = FALSE;
 239     SILC_ASSERT(silc_fsm_is_started(thread) == FALSE);
 240
 241     /*** Event: connect */
 242     silc_fsm_thread_init(thread, &conn->internal->fsm, conn,
 243                          NULL, NULL, FALSE);
 244     silc_fsm_start_sync(thread, silc_client_st_connect);
 245     return SILC_FSM_CONTINUE;
 246   }
 247
 248   if (conn->internal->key_exchange) {
 249     SILC_LOG_DEBUG(("Event: key exchange"));
 250     conn->internal->key_exchange = FALSE;
 251     SILC_ASSERT(silc_fsm_is_started(thread) == FALSE);
 252
 253     /*** Event: key exchange */
 254     silc_fsm_thread_init(thread, &conn->internal->fsm, conn,
 255                          NULL, NULL, FALSE);
 256     silc_fsm_start_sync(thread, silc_client_st_connect_set_stream);
 257     return SILC_FSM_CONTINUE;
 258   }
 259
 260   if (conn->internal->rekeying) {
 261     SILC_LOG_DEBUG(("Event: rekey"));
 262     conn->internal->rekeying = FALSE;
 263     SILC_ASSERT(silc_fsm_is_started(thread) == FALSE);
 264
 265     /*** Event: rekey */
 266     silc_fsm_thread_init(thread, &conn->internal->fsm, conn,
 267                          NULL, NULL, FALSE);
 268     silc_fsm_start_sync(thread, silc_client_st_rekey);
 269     return SILC_FSM_CONTINUE;
 270   }
 271
 272   if (conn->internal->disconnected) {
 273     /** Event: disconnected */
 274     SILC_LOG_DEBUG(("Event: disconnected"));
 275     silc_fsm_next(fsm, silc_client_connection_st_close);
 276     return SILC_FSM_YIELD;
 277   }
 278
 279   /* NOT REACHED */
 280   SILC_ASSERT(FALSE);
 281   return SILC_FSM_CONTINUE;
 282 }
 283
 284 /* Packet processor thread.  Each incoming packet is processed in FSM
 285    thread in this state.  The thread is run in the connection machine. */
 286
 287 SILC_FSM_STATE(silc_client_connection_st_packet)
 288 {
 289   SilcClientConnection conn = fsm_context;
 290   SilcPacket packet = state_context;
 291
 292   SILC_LOG_DEBUG(("Parsing %s packet", silc_get_packet_name(packet->type)));
 293
 294   switch (packet->type) {
 295
 296   case SILC_PACKET_PRIVATE_MESSAGE:
 297     /** Private message */
 298     silc_fsm_next(fsm, silc_client_private_message);
 299     break;
 300
 301   case SILC_PACKET_CHANNEL_MESSAGE:
 302     /** Channel message */
 303     silc_fsm_next(fsm, silc_client_channel_message);
 304     break;
 305
 306   case SILC_PACKET_FTP:
 307     /* File transfer packet */
 308     silc_fsm_next(fsm, silc_client_ftp);
 309     break;
 310
 311   case SILC_PACKET_CHANNEL_KEY:
 312     /** Channel key */
 313     silc_fsm_next(fsm, silc_client_channel_key);
 314     break;
 315
 316   case SILC_PACKET_COMMAND_REPLY:
 317     /** Command reply */
 318     silc_fsm_next(fsm, silc_client_command_reply);
 319     break;
 320
 321   case SILC_PACKET_NOTIFY:
 322     /** Notify */
 323     silc_fsm_next(fsm, silc_client_notify);
 324     break;
 325
 326   case SILC_PACKET_PRIVATE_MESSAGE_KEY:
 327     /* Private message key indicator */
 328     silc_fsm_next(fsm, silc_client_private_message_key);
 329     break;
 330
 331   case SILC_PACKET_DISCONNECT:
 332     /** Disconnect */
 333     silc_fsm_next(fsm, silc_client_disconnect);
 334     break;
 335
 336   case SILC_PACKET_ERROR:
 337     /* Error by server */
 338     silc_fsm_next(fsm, silc_client_error);
 339     break;
 340
 341   case SILC_PACKET_KEY_AGREEMENT:
 342     /** Key agreement */
 343     silc_fsm_next(fsm, silc_client_key_agreement);
 344     break;
 345
 346   case SILC_PACKET_COMMAND:
 347     /** Command packet */
 348     silc_fsm_next(fsm, silc_client_command);
 349     break;
 350
 351   case SILC_PACKET_NEW_ID:
 352     /** New ID */
 353     silc_fsm_next(fsm, silc_client_new_id);
 354     break;
 355
 356   case SILC_PACKET_CONNECTION_AUTH_REQUEST:
 357     /** Connection auth resolve reply */
 358     silc_fsm_next(fsm, silc_client_connect_auth_request);
 359     break;
 360
 361   case SILC_PACKET_REKEY:
 362     /* Signal to start rekey */
 363     conn->internal->rekey_responder = TRUE;
 364     conn->internal->rekeying = TRUE;
 365     SILC_FSM_EVENT_SIGNAL(&conn->internal->wait_event);
 366
 367     silc_packet_free(packet);
 368     return SILC_FSM_FINISH;
 369     break;
 370
 371   default:
 372     silc_packet_free(packet);
 373     return SILC_FSM_FINISH;
 374     break;
 375   }
 376
 377   return SILC_FSM_CONTINUE;
 378 }
 379
 380 /* Disconnection event to close remote connection.  We close the connection
 381    and finish the connection machine in this state.  The connection context
 382    is deleted in the machine destructor.  The connection callback is called
 383    in this state if it is set. */
 384
 385 SILC_FSM_STATE(silc_client_connection_st_close)
 386 {
 387   SilcClientConnection conn = fsm_context;
 388   SilcClientCommandContext cmd;
 389
 390   /* Finish running command threads.  This will also finish waiting packet
 391      thread, as they are always waiting for some command.  If any thread is
 392      waiting something else than command, they must be finished explicitly. */
 393   if (silc_list_count(conn->internal->pending_commands)) {
 394     SILC_LOG_DEBUG(("Finish pending commands"));
 395     silc_list_start(conn->internal->pending_commands);
 396     while ((cmd = silc_list_get(conn->internal->pending_commands))) {
 397       if (silc_fsm_is_started(&cmd->thread)) {
 398         cmd->verbose = FALSE;
 399         silc_fsm_continue_sync(&cmd->thread);
 400       }
 401     }
 402
 403     /* Give threads time to finish */
 404     return SILC_FSM_YIELD;
 405   }
 406
 407   /* Abort ongoing event */
 408   if (conn->internal->op) {
 409     SILC_LOG_DEBUG(("Abort event"));
 410     silc_async_abort(conn->internal->op, NULL, NULL);
 411     conn->internal->op = NULL;
 412   }
 413
 414   /* If event thread is running, finish it. */
 415   if (silc_fsm_is_started(&conn->internal->event_thread)) {
 416     SILC_LOG_DEBUG(("Finish event thread"));
 417     silc_fsm_continue_sync(&conn->internal->event_thread);
 418     return SILC_FSM_YIELD;
 419   }
 420
 421   /* Call the connection callback */
 422   if (conn->callback)
 423     conn->callback(conn->client, conn, conn->internal->status,
 424                    conn->internal->error, conn->internal->disconnect_message,
 425                    conn->callback_context);
 426   silc_free(conn->internal->disconnect_message);
 427
 428   SILC_LOG_DEBUG(("Closing remote connection"));
 429
 430   /* Close connection */
 431   silc_packet_stream_destroy(conn->stream);
 432
 433   SILC_LOG_DEBUG(("Finishing connection machine"));
 434   return SILC_FSM_FINISH;
 435 }
 436
 437 /* Received error packet from server.  Send it to application. */
 438
 439 SILC_FSM_STATE(silc_client_error)
 440 {
 441   SilcClientConnection conn = fsm_context;
 442   SilcClient client = conn->client;
 443   SilcPacket packet = state_context;
 444   char *msg;
 445
 446   msg = silc_memdup(silc_buffer_data(&packet->buffer),
 447                     silc_buffer_len(&packet->buffer));
 448   if (msg)
 449     client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_AUDIT, msg);
 450
 451   silc_free(msg);
 452   silc_packet_free(packet);
 453
 454   return SILC_FSM_FINISH;
 455 }
 456
 457 /* Received disconnect packet from server.  We close the connection and
 458    send the disconnect message to application. */
 459
 460 SILC_FSM_STATE(silc_client_disconnect)
 461 {
 462   SilcClientConnection conn = fsm_context;
 463   SilcPacket packet = state_context;
 464   SilcStatus status;
 465   char *message = NULL;
 466
 467   SILC_LOG_DEBUG(("Server disconnected"));
 468
 469   if (silc_buffer_len(&packet->buffer) < 1) {
 470     silc_packet_free(packet);
 471     return SILC_FSM_FINISH;
 472   }
 473
 474   status = (SilcStatus)packet->buffer.data[0];
 475
 476   silc_buffer_pull(&packet->buffer, 1);
 477   if (silc_buffer_len(&packet->buffer) > 1 &&
 478       silc_utf8_valid(silc_buffer_data(&packet->buffer),
 479                       silc_buffer_len(&packet->buffer)))
 480     message = silc_memdup(silc_buffer_data(&packet->buffer),
 481                           silc_buffer_len(&packet->buffer));
 482
 483   /* Call connection callback */
 484   conn->internal->status = SILC_CLIENT_CONN_DISCONNECTED;
 485   conn->internal->error = status;
 486   conn->internal->disconnect_message = message;
 487
 488   /* Signal to close connection */
 489   if (!conn->internal->disconnected) {
 490     conn->internal->disconnected = TRUE;
 491     SILC_FSM_EVENT_SIGNAL(&conn->internal->wait_event);
 492   }
 493
 494   silc_packet_free(packet);
 495
 496   return SILC_FSM_FINISH;
 497 }
 498
 499 /*************************** Main client machine ****************************/
 500
 501 /* The client's main state where we wait for various events */
 502
 503 SILC_FSM_STATE(silc_client_st_run)
 504 {
 505   SilcClient client = fsm_context;
 506
 507   /* Wait for events */
 508   SILC_FSM_EVENT_WAIT(&client->internal->wait_event);
 509
 510   /* Process events */
 511
 512   if (client->internal->run_callback && client->internal->running) {
 513     /* Call running callbcak back to application */
 514     SILC_LOG_DEBUG(("We are up, call running callback"));
 515     client->internal->run_callback = FALSE;
 516     client->internal->running(client, client->internal->running_context);
 517     return SILC_FSM_CONTINUE;
 518   }
 519
 520   if (client->internal->connection_closed) {
 521     /* A connection finished */
 522     SILC_LOG_DEBUG(("Event: connection closed"));
 523     client->internal->connection_closed = FALSE;
 524     if (silc_atomic_get_int16(&client->internal->conns) == 0 &&
 525         client->internal->stop)
 526       SILC_FSM_EVENT_SIGNAL(&client->internal->wait_event);
 527     return SILC_FSM_CONTINUE;
 528   }
 529
 530   if (client->internal->stop) {
 531     /* Stop client libarry.  If we have running connections, wait until
 532        they finish first. */
 533     SILC_LOG_DEBUG(("Event: stop"));
 534     if (silc_atomic_get_int16(&client->internal->conns) == 0)
 535       silc_fsm_next(fsm, silc_client_st_stop);
 536     return SILC_FSM_CONTINUE;
 537   }
 538
 539   /* NOT REACHED */
 540   SILC_ASSERT(FALSE);
 541   return SILC_FSM_CONTINUE;
 542 }
 543
 544 /* Stop event.  Stops the client library. */
 545
 546 SILC_FSM_STATE(silc_client_st_stop)
 547 {
 548   SilcClient client = fsm_context;
 549
 550   SILC_LOG_DEBUG(("Client stopped"));
 551
 552   /* Stop scheduler */
 553   silc_schedule_stop(client->schedule);
 554   silc_client_commands_unregister(client);
 555
 556   /* Call stopped callback to application */
 557   if (client->internal->running)
 558     client->internal->running(client, client->internal->running_context);
 559
 560   return SILC_FSM_FINISH;
 561 }
 562
 563 /******************************* Private API ********************************/
 564
 565 /* Adds new connection.  Creates the connection context and returns it. */
 566
 567 SilcClientConnection
 568 silc_client_add_connection(SilcClient client,
 569                            SilcConnectionType conn_type,
 570                            SilcBool connect,
 571                            SilcClientConnectionParams *params,
 572                            SilcPublicKey public_key,
 573                            SilcPrivateKey private_key,
 574                            char *remote_host, int port,
 575                            SilcClientConnectCallback callback,
 576                            void *context)
 577 {
 578   SilcClientConnection conn;
 579   SilcFSMThread thread;
 580
 581   if (!callback)
 582     return NULL;
 583
 584   SILC_LOG_DEBUG(("Adding new connection to %s:%d", remote_host, port));
 585
 586   conn = silc_calloc(1, sizeof(*conn));
 587   if (!conn)
 588     return NULL;
 589
 590   conn->client = client;
 591   conn->public_key = public_key;
 592   conn->private_key = private_key;
 593   conn->remote_host = strdup(remote_host);
 594   conn->remote_port = port ? port : 706;
 595   conn->type = conn_type;
 596   conn->callback = callback;
 597   conn->callback_context = context;
 598
 599   conn->internal = silc_calloc(1, sizeof(*conn->internal));
 600   if (!conn->internal) {
 601     silc_free(conn);
 602     return NULL;
 603   }
 604   conn->internal->retry_timer = SILC_CLIENT_RETRY_MIN;
 605   silc_mutex_alloc(&conn->internal->lock);
 606   silc_atomic_init16(&conn->internal->cmd_ident, 0);
 607
 608   if (!silc_hash_alloc("sha1", &conn->internal->sha1hash)) {
 609     silc_free(conn);
 610     silc_free(conn->internal);
 611     return NULL;
 612   }
 613
 614   /* Set parameters */
 615   if (params)
 616     conn->internal->params = *params;
 617   if (!conn->internal->params.rekey_secs)
 618     conn->internal->params.rekey_secs = 3600;
 619 #ifndef SILC_DIST_INPLACE
 620   if (conn->internal->params.rekey_secs < 300)
 621     conn->internal->params.rekey_secs = 300;
 622 #endif /* SILC_DIST_INPLACE */
 623
 624   conn->internal->verbose = TRUE;
 625   silc_list_init(conn->internal->pending_commands,
 626                  struct SilcClientCommandContextStruct, next);
 627   silc_list_init(conn->internal->thread_pool, SilcFSMThreadStruct, next);
 628
 629   /* Allocate client, channel and serve caches */
 630   if (conn_type != SILC_CONN_CLIENT) {
 631     conn->internal->client_cache = silc_idcache_alloc(0, SILC_ID_CLIENT,
 632                                                       NULL, NULL);
 633     conn->internal->channel_cache = silc_idcache_alloc(0, SILC_ID_CHANNEL,
 634                                                        NULL, NULL);
 635     conn->internal->server_cache = silc_idcache_alloc(0, SILC_ID_SERVER,
 636                                                       NULL, NULL);
 637     if (!conn->internal->client_cache || !conn->internal->channel_cache ||
 638         !conn->internal->server_cache) {
 639       silc_client_del_connection(client, conn);
 640       return NULL;
 641     }
 642   }
 643
 644   if (connect) {
 645     /* Initialize our async operation so that application may abort us
 646        while we're connecting. */
 647     conn->internal->cop = silc_async_alloc(silc_client_connect_abort,
 648                                            NULL, conn);
 649     if (!conn->internal->cop) {
 650       silc_client_del_connection(client, conn);
 651       return NULL;
 652     }
 653   }
 654
 655   /* Run the connection state machine.  If threads are in use the connection
 656      machine is always run in a real thread. */
 657   thread = silc_fsm_thread_alloc(&client->internal->fsm, conn,
 658                                  silc_client_connection_finished, NULL,
 659                                  client->internal->params->threads);
 660   if (!thread) {
 661     silc_client_del_connection(client, conn);
 662     return NULL;
 663   }
 664   silc_fsm_set_state_context(thread, client);
 665   silc_fsm_start(thread, silc_client_connection_st_start);
 666
 667   SILC_LOG_DEBUG(("New connection %p", conn));
 668   silc_atomic_add_int16(&client->internal->conns, 1);
 669
 670   return conn;
 671 }
 672
 673 /* Deletes connection.  This is always called from the connection machine
 674    destructor.  Do not call this directly other places. */
 675
 676 void silc_client_del_connection(SilcClient client, SilcClientConnection conn)
 677 {
 678   SilcList list;
 679   SilcIDCacheEntry entry;
 680   SilcFSMThread thread;
 681
 682   SILC_LOG_DEBUG(("Freeing connection %p", conn));
 683
 684   silc_schedule_task_del_by_context(conn->internal->schedule, conn);
 685
 686   /* Free all cache entries */
 687   if (conn->internal->server_cache) {
 688     if (silc_idcache_get_all(conn->internal->server_cache, &list)) {
 689       silc_list_start(list);
 690       while ((entry = silc_list_get(list)))
 691         silc_client_del_server(client, conn, entry->context);
 692     }
 693   }
 694   if (conn->internal->channel_cache) {
 695     if (silc_idcache_get_all(conn->internal->channel_cache, &list)) {
 696       silc_list_start(list);
 697       while ((entry = silc_list_get(list))) {
 698         silc_client_empty_channel(client, conn, entry->context);
 699         silc_client_del_channel(client, conn, entry->context);
 700       }
 701     }
 702   }
 703   if (conn->internal->client_cache) {
 704     if (silc_idcache_get_all(conn->internal->client_cache, &list)) {
 705       silc_list_start(list);
 706       while ((entry = silc_list_get(list)))
 707         silc_client_del_client(client, conn, entry->context);
 708     }
 709   }
 710
 711   /* Free ID caches */
 712   if (conn->internal->client_cache)
 713     silc_idcache_free(conn->internal->client_cache);
 714   if (conn->internal->channel_cache)
 715     silc_idcache_free(conn->internal->channel_cache);
 716   if (conn->internal->server_cache)
 717     silc_idcache_free(conn->internal->server_cache);
 718
 719   /* Free thread pool */
 720   silc_list_start(conn->internal->thread_pool);
 721   while ((thread = silc_list_get(conn->internal->thread_pool)))
 722     silc_fsm_free(thread);
 723
 724   silc_free(conn->remote_host);
 725   silc_buffer_free(conn->internal->local_idp);
 726   silc_buffer_free(conn->internal->remote_idp);
 727   silc_mutex_free(conn->internal->lock);
 728   if (conn->internal->hash)
 729     silc_hash_free(conn->internal->hash);
 730   if (conn->internal->sha1hash)
 731     silc_hash_free(conn->internal->sha1hash);
 732   silc_atomic_uninit16(&conn->internal->cmd_ident);
 733
 734   if (conn->internal->rekey)
 735     silc_ske_free_rekey_material(conn->internal->rekey);
 736
 737   if (conn->internal->cop)
 738     silc_async_free(conn->internal->cop);
 739
 740   silc_free(conn->internal);
 741   memset(conn, 'F', sizeof(*conn));
 742   silc_free(conn);
 743 }
 744
 745 /******************************* Client API *********************************/
 746
 747 /* Connects to remote server.  This is the main routine used to connect
 748    to remote SILC server.  Performs key exchange also.  Returns the
 749    connection context to the connection callback. */
 750
 751 SilcAsyncOperation
 752 silc_client_connect_to_server(SilcClient client,
 753                               SilcClientConnectionParams *params,
 754                               SilcPublicKey public_key,
 755                               SilcPrivateKey private_key,
 756                               char *remote_host, int port,
 757                               SilcClientConnectCallback callback,
 758                               void *context)
 759 {
 760   SilcClientConnection conn;
 761
 762   SILC_LOG_DEBUG(("Connecting to server"));
 763
 764   if (!client || !remote_host)
 765     return NULL;
 766
 767   /* Add new connection */
 768   conn = silc_client_add_connection(client, SILC_CONN_SERVER, TRUE, params,
 769                                     public_key, private_key, remote_host,
 770                                     port, callback, context);
 771   if (!conn) {
 772     callback(client, NULL, SILC_CLIENT_CONN_ERROR, 0, NULL, context);
 773     return NULL;
 774   }
 775
 776   client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_AUDIT,
 777                              "Connecting to port %d of server %s",
 778                              port, remote_host);
 779
 780   /* Signal connection machine to start connecting */
 781   conn->internal->connect = TRUE;
 782   return conn->internal->cop;
 783 }
 784
 785 /* Connects to remote client.  Performs key exchange also.  Returns the
 786    connection context to the connection callback. */
 787
 788 SilcAsyncOperation
 789 silc_client_connect_to_client(SilcClient client,
 790                               SilcClientConnectionParams *params,
 791                               SilcPublicKey public_key,
 792                               SilcPrivateKey private_key,
 793                               char *remote_host, int port,
 794                               SilcClientConnectCallback callback,
 795                               void *context)
 796 {
 797   SilcClientConnection conn;
 798
 799   SILC_LOG_DEBUG(("Connecting to client"));
 800
 801   if (!client || !remote_host)
 802     return NULL;
 803
 804   if (params)
 805     params->no_authentication = TRUE;
 806
 807   /* Add new connection */
 808   conn = silc_client_add_connection(client, SILC_CONN_CLIENT, TRUE, params,
 809                                     public_key, private_key, remote_host,
 810                                     port, callback, context);
 811   if (!conn) {
 812     callback(client, NULL, SILC_CLIENT_CONN_ERROR, 0, NULL, context);
 813     return NULL;
 814   }
 815
 816   /* Signal connection machine to start connecting */
 817   conn->internal->connect = TRUE;
 818   return conn->internal->cop;
 819 }
 820
 821 /* Starts key exchange in the remote stream indicated by `stream'.  This
 822    creates the connection context and returns it in the connection callback. */
 823
 824 SilcAsyncOperation
 825 silc_client_key_exchange(SilcClient client,
 826                          SilcClientConnectionParams *params,
 827                          SilcPublicKey public_key,
 828                          SilcPrivateKey private_key,
 829                          SilcStream stream,
 830                          SilcConnectionType conn_type,
 831                          SilcClientConnectCallback callback,
 832                          void *context)
 833 {
 834   SilcClientConnection conn;
 835   const char *host;
 836   SilcUInt16 port;
 837
 838   SILC_LOG_DEBUG(("Performing key exchange"));
 839
 840   if (!client || !stream)
 841     return NULL;
 842
 843   if (!silc_socket_stream_get_info(stream, NULL, &host, NULL, &port)) {
 844     SILC_LOG_ERROR(("Socket stream does not have remote host name set"));
 845     callback(client, NULL, SILC_CLIENT_CONN_ERROR, 0, NULL, context);
 846     return NULL;
 847   }
 848
 849   /* Add new connection */
 850   conn = silc_client_add_connection(client, conn_type, TRUE, params,
 851                                     public_key, private_key,
 852                                     (char *)host, port, callback, context);
 853   if (!conn) {
 854     callback(client, NULL, SILC_CLIENT_CONN_ERROR, 0, NULL, context);
 855     return NULL;
 856   }
 857   conn->stream = (void *)stream;
 858
 859   /* Signal connection to start key exchange */
 860   conn->internal->key_exchange = TRUE;
 861   return conn->internal->cop;
 862 }
 863
 864 /* Closes remote connection */
 865
 866 void silc_client_close_connection(SilcClient client,
 867                                   SilcClientConnection conn)
 868 {
 869   SILC_LOG_DEBUG(("Closing connection %p", conn));
 870
 871   /* If connection machine is not running, we just delete the connection */
 872   if (!silc_fsm_is_started(&conn->internal->fsm)) {
 873     silc_packet_stream_destroy(conn->stream);
 874     silc_client_del_connection(conn->client, conn);
 875     return;
 876   }
 877
 878   /* Signal to close connection */
 879   conn->internal->status = SILC_CLIENT_CONN_DISCONNECTED;
 880   if (!conn->internal->disconnected) {
 881     conn->internal->disconnected = TRUE;
 882     SILC_FSM_EVENT_SIGNAL(&conn->internal->wait_event);
 883   }
 884 }
 885
 886 /* Allocates new client object. This has to be done before client may
 887    work. After calling this one must call silc_client_init to initialize
 888    the client. The `application' is application specific user data pointer
 889    and caller must free it. */
 890
 891 SilcClient silc_client_alloc(SilcClientOperations *ops,
 892                              SilcClientParams *params,
 893                              void *application,
 894                              const char *version_string)
 895 {
 896   SilcClient new_client;
 897
 898   new_client = silc_calloc(1, sizeof(*new_client));
 899   if (!new_client)
 900     return NULL;
 901   new_client->application = application;
 902
 903   new_client->internal = silc_calloc(1, sizeof(*new_client->internal));
 904   if (!new_client->internal) {
 905     silc_free(new_client);
 906     return NULL;
 907   }
 908   new_client->internal->ops = ops;
 909   new_client->internal->params =
 910     silc_calloc(1, sizeof(*new_client->internal->params));
 911   if (!version_string)
 912     version_string = silc_version_string;
 913   new_client->internal->silc_client_version = strdup(version_string);
 914
 915   if (params)
 916     memcpy(new_client->internal->params, params, sizeof(*params));
 917
 918   new_client->internal->params->
 919     nickname_format[sizeof(new_client->internal->
 920                            params->nickname_format) - 1] = 0;
 921
 922   silc_atomic_init16(&new_client->internal->conns, 0);
 923
 924   return new_client;
 925 }
 926
 927 /* Frees client object and its internals. */
 928
 929 void silc_client_free(SilcClient client)
 930 {
 931   silc_schedule_uninit(client->schedule);
 932
 933   if (client->rng)
 934     silc_rng_free(client->rng);
 935
 936   if (!client->internal->params->dont_register_crypto_library) {
 937     silc_cipher_unregister_all();
 938     silc_pkcs_unregister_all();
 939     silc_hash_unregister_all();
 940     silc_hmac_unregister_all();
 941   }
 942
 943   silc_packet_engine_stop(client->internal->packet_engine);
 944   silc_dlist_uninit(client->internal->ftp_sessions);
 945   silc_atomic_uninit16(&client->internal->conns);
 946   silc_mutex_free(client->internal->lock);
 947   silc_free(client->username);
 948   silc_free(client->hostname);
 949   silc_free(client->realname);
 950   silc_free(client->internal->params);
 951   silc_free(client->internal->silc_client_version);
 952   silc_free(client->internal);
 953   silc_free(client);
 954 }
 955
 956 /* Initializes the client. This makes all the necessary steps to make
 957    the client ready to be run. One must call silc_client_run to run the
 958    client. Returns FALSE if error occured, TRUE otherwise. */
 959
 960 SilcBool silc_client_init(SilcClient client, const char *username,
 961                           const char *hostname, const char *realname,
 962                           SilcClientRunning running, void *context)
 963 {
 964   SILC_LOG_DEBUG(("Initializing client"));
 965
 966   if (!client)
 967     return FALSE;
 968
 969   if (!username || !hostname) {
 970     SILC_LOG_ERROR(("Username and hostname must be given to "
 971                     "silc_client_init"));
 972     return FALSE;
 973   }
 974   if (!realname)
 975     realname = username;
 976
 977   /* Validate essential strings */
 978   if (!silc_identifier_verify(username, strlen(username),
 979                               SILC_STRING_UTF8, 128)) {
 980     SILC_LOG_ERROR(("Malformed username '%s'. Username must be UTF-8 string",
 981                     client->username));
 982     return FALSE;
 983   }
 984   if (!silc_identifier_verify(hostname, strlen(hostname),
 985                               SILC_STRING_UTF8, 256)) {
 986     SILC_LOG_ERROR(("Malformed hostname '%s'. Hostname must be UTF-8 string",
 987                     client->hostname));
 988     return FALSE;
 989   }
 990   if (!silc_utf8_valid(realname, strlen(realname))) {
 991     SILC_LOG_ERROR(("Malformed realname '%s'. Realname must be UTF-8 string",
 992                     client->realname));
 993     return FALSE;
 994   }
 995
 996   /* Take the name strings */
 997   client->username = strdup(username);
 998   client->hostname = strdup(hostname);
 999   client->realname = strdup(realname);
1000   if (!username || !hostname || !realname)
1001     return FALSE;
1002
1003   client->internal->ftp_sessions = silc_dlist_init();
1004   if (!client->internal->ftp_sessions)
1005     return FALSE;
1006
1007   if (!client->internal->params->dont_register_crypto_library) {
1008     /* Initialize the crypto library.  If application has done this already
1009        this has no effect.  Also, we will not be overriding something
1010        application might have registered earlier. */
1011     silc_cipher_register_default();
1012     silc_pkcs_register_default();
1013     silc_hash_register_default();
1014     silc_hmac_register_default();
1015   }
1016
1017   /* Initialize random number generator */
1018   client->rng = silc_rng_alloc();
1019   if (!client->rng)
1020     return FALSE;
1021   silc_rng_init(client->rng);
1022   silc_rng_global_init(client->rng);
1023
1024   /* Initialize the scheduler */
1025   client->schedule = silc_schedule_init(0, client);
1026   if (!client->schedule)
1027     return FALSE;
1028
1029   /* Allocate client lock */
1030   silc_mutex_alloc(&client->internal->lock);
1031
1032   /* Register commands */
1033   silc_client_commands_register(client);
1034
1035   /* Start packet engine */
1036   client->internal->packet_engine =
1037     silc_packet_engine_start(client->rng, FALSE, &silc_client_stream_cbs,
1038                              client);
1039   if (!client->internal->packet_engine)
1040     return FALSE;
1041
1042   /* Initialize and start the client FSM */
1043   client->internal->running = running;
1044   client->internal->running_context = context;
1045   silc_fsm_init(&client->internal->fsm, client, NULL, NULL, client->schedule);
1046   silc_fsm_event_init(&client->internal->wait_event, &client->internal->fsm);
1047   silc_fsm_start_sync(&client->internal->fsm, silc_client_st_run);
1048
1049   /* Signal the application when we are running */
1050   client->internal->run_callback = TRUE;
1051   SILC_FSM_EVENT_SIGNAL(&client->internal->wait_event);
1052
1053   return TRUE;
1054 }
1055
1056 /* Starts the SILC client FSM machine and blocks here.  When this returns
1057    the client has ended. */
1058
1059 void silc_client_run(SilcClient client)
1060 {
1061   SILC_LOG_DEBUG(("Starting SILC client"));
1062
1063   /* Run the scheduler */
1064   silc_schedule(client->schedule);
1065 }
1066
1067 /* Call scheduler one iteration and return. */
1068
1069 void silc_client_run_one(SilcClient client)
1070 {
1071   if (silc_fsm_is_started(&client->internal->fsm))
1072     silc_schedule_one(client->schedule, 0);
1073 }
1074
1075 /* Stops the client. This is called to stop the client and thus to stop
1076    the program. */
1077
1078 void silc_client_stop(SilcClient client, SilcClientStopped stopped,
1079                       void *context)
1080 {
1081   SILC_LOG_DEBUG(("Stopping client"));
1082
1083   client->internal->running = (SilcClientRunning)stopped;
1084   client->internal->running_context = context;
1085
1086   /* Signal to stop */
1087   client->internal->stop = TRUE;
1088   SILC_FSM_EVENT_SIGNAL(&client->internal->wait_event);
1089 }