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   silc_free(conn->internal);
 735   memset(conn, 'F', sizeof(*conn));
 736   silc_free(conn);
 737 }
 738
 739 /******************************* Client API *********************************/
 740
 741 /* Connects to remote server.  This is the main routine used to connect
 742    to remote SILC server.  Performs key exchange also.  Returns the
 743    connection context to the connection callback. */
 744
 745 SilcAsyncOperation
 746 silc_client_connect_to_server(SilcClient client,
 747                               SilcClientConnectionParams *params,
 748                               SilcPublicKey public_key,
 749                               SilcPrivateKey private_key,
 750                               char *remote_host, int port,
 751                               SilcClientConnectCallback callback,
 752                               void *context)
 753 {
 754   SilcClientConnection conn;
 755
 756   SILC_LOG_DEBUG(("Connecting to server"));
 757
 758   if (!client || !remote_host)
 759     return NULL;
 760
 761   /* Add new connection */
 762   conn = silc_client_add_connection(client, SILC_CONN_SERVER, TRUE, params,
 763                                     public_key, private_key, remote_host,
 764                                     port, callback, context);
 765   if (!conn) {
 766     callback(client, NULL, SILC_CLIENT_CONN_ERROR, 0, NULL, context);
 767     return NULL;
 768   }
 769
 770   client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_AUDIT,
 771                              "Connecting to port %d of server %s",
 772                              port, remote_host);
 773
 774   /* Signal connection machine to start connecting */
 775   conn->internal->connect = TRUE;
 776   return conn->internal->cop;
 777 }
 778
 779 /* Connects to remote client.  Performs key exchange also.  Returns the
 780    connection context to the connection callback. */
 781
 782 SilcAsyncOperation
 783 silc_client_connect_to_client(SilcClient client,
 784                               SilcClientConnectionParams *params,
 785                               SilcPublicKey public_key,
 786                               SilcPrivateKey private_key,
 787                               char *remote_host, int port,
 788                               SilcClientConnectCallback callback,
 789                               void *context)
 790 {
 791   SilcClientConnection conn;
 792
 793   SILC_LOG_DEBUG(("Connecting to client"));
 794
 795   if (!client || !remote_host)
 796     return NULL;
 797
 798   if (params)
 799     params->no_authentication = TRUE;
 800
 801   /* Add new connection */
 802   conn = silc_client_add_connection(client, SILC_CONN_CLIENT, TRUE, params,
 803                                     public_key, private_key, remote_host,
 804                                     port, callback, context);
 805   if (!conn) {
 806     callback(client, NULL, SILC_CLIENT_CONN_ERROR, 0, NULL, context);
 807     return NULL;
 808   }
 809
 810   /* Signal connection machine to start connecting */
 811   conn->internal->connect = TRUE;
 812   return conn->internal->cop;
 813 }
 814
 815 /* Starts key exchange in the remote stream indicated by `stream'.  This
 816    creates the connection context and returns it in the connection callback. */
 817
 818 SilcAsyncOperation
 819 silc_client_key_exchange(SilcClient client,
 820                          SilcClientConnectionParams *params,
 821                          SilcPublicKey public_key,
 822                          SilcPrivateKey private_key,
 823                          SilcStream stream,
 824                          SilcConnectionType conn_type,
 825                          SilcClientConnectCallback callback,
 826                          void *context)
 827 {
 828   SilcClientConnection conn;
 829   const char *host;
 830   SilcUInt16 port;
 831
 832   SILC_LOG_DEBUG(("Performing key exchange"));
 833
 834   if (!client || !stream)
 835     return NULL;
 836
 837   if (!silc_socket_stream_get_info(stream, NULL, &host, NULL, &port)) {
 838     SILC_LOG_ERROR(("Socket stream does not have remote host name set"));
 839     callback(client, NULL, SILC_CLIENT_CONN_ERROR, 0, NULL, context);
 840     return NULL;
 841   }
 842
 843   /* Add new connection */
 844   conn = silc_client_add_connection(client, conn_type, TRUE, params,
 845                                     public_key, private_key,
 846                                     (char *)host, port, callback, context);
 847   if (!conn) {
 848     callback(client, NULL, SILC_CLIENT_CONN_ERROR, 0, NULL, context);
 849     return NULL;
 850   }
 851   conn->stream = (void *)stream;
 852
 853   /* Signal connection to start key exchange */
 854   conn->internal->key_exchange = TRUE;
 855   return conn->internal->cop;
 856 }
 857
 858 /* Closes remote connection */
 859
 860 void silc_client_close_connection(SilcClient client,
 861                                   SilcClientConnection conn)
 862 {
 863   SILC_LOG_DEBUG(("Closing connection %p", conn));
 864
 865   /* If connection machine is not running, we just delete the connection */
 866   if (!silc_fsm_is_started(&conn->internal->fsm)) {
 867     silc_packet_stream_destroy(conn->stream);
 868     silc_client_del_connection(conn->client, conn);
 869     return;
 870   }
 871
 872   /* Signal to close connection */
 873   conn->internal->status = SILC_CLIENT_CONN_DISCONNECTED;
 874   if (!conn->internal->disconnected) {
 875     conn->internal->disconnected = TRUE;
 876     SILC_FSM_EVENT_SIGNAL(&conn->internal->wait_event);
 877   }
 878 }
 879
 880 /* Allocates new client object. This has to be done before client may
 881    work. After calling this one must call silc_client_init to initialize
 882    the client. The `application' is application specific user data pointer
 883    and caller must free it. */
 884
 885 SilcClient silc_client_alloc(SilcClientOperations *ops,
 886                              SilcClientParams *params,
 887                              void *application,
 888                              const char *version_string)
 889 {
 890   SilcClient new_client;
 891
 892   new_client = silc_calloc(1, sizeof(*new_client));
 893   if (!new_client)
 894     return NULL;
 895   new_client->application = application;
 896
 897   new_client->internal = silc_calloc(1, sizeof(*new_client->internal));
 898   if (!new_client->internal) {
 899     silc_free(new_client);
 900     return NULL;
 901   }
 902   new_client->internal->ops = ops;
 903   new_client->internal->params =
 904     silc_calloc(1, sizeof(*new_client->internal->params));
 905   if (!version_string)
 906     version_string = silc_version_string;
 907   new_client->internal->silc_client_version = strdup(version_string);
 908
 909   if (params)
 910     memcpy(new_client->internal->params, params, sizeof(*params));
 911
 912   new_client->internal->params->
 913     nickname_format[sizeof(new_client->internal->
 914                            params->nickname_format) - 1] = 0;
 915
 916   silc_atomic_init16(&new_client->internal->conns, 0);
 917
 918   return new_client;
 919 }
 920
 921 /* Frees client object and its internals. */
 922
 923 void silc_client_free(SilcClient client)
 924 {
 925   silc_schedule_uninit(client->schedule);
 926
 927   if (client->rng)
 928     silc_rng_free(client->rng);
 929
 930   if (!client->internal->params->dont_register_crypto_library) {
 931     silc_cipher_unregister_all();
 932     silc_pkcs_unregister_all();
 933     silc_hash_unregister_all();
 934     silc_hmac_unregister_all();
 935   }
 936
 937   silc_atomic_uninit16(&client->internal->conns);
 938   silc_free(client->username);
 939   silc_free(client->hostname);
 940   silc_free(client->realname);
 941   silc_free(client->internal->params);
 942   silc_free(client->internal->silc_client_version);
 943   silc_free(client->internal);
 944   silc_free(client);
 945 }
 946
 947 /* Initializes the client. This makes all the necessary steps to make
 948    the client ready to be run. One must call silc_client_run to run the
 949    client. Returns FALSE if error occured, TRUE otherwise. */
 950
 951 SilcBool silc_client_init(SilcClient client, const char *username,
 952                           const char *hostname, const char *realname,
 953                           SilcClientRunning running, void *context)
 954 {
 955   SILC_LOG_DEBUG(("Initializing client"));
 956
 957   if (!client)
 958     return FALSE;
 959
 960   if (!username || !hostname) {
 961     SILC_LOG_ERROR(("Username and hostname must be given to "
 962                     "silc_client_init"));
 963     return FALSE;
 964   }
 965   if (!realname)
 966     realname = username;
 967
 968   /* Validate essential strings */
 969   if (!silc_identifier_verify(username, strlen(username),
 970                               SILC_STRING_UTF8, 128)) {
 971     SILC_LOG_ERROR(("Malformed username '%s'. Username must be UTF-8 string",
 972                     client->username));
 973     return FALSE;
 974   }
 975   if (!silc_identifier_verify(hostname, strlen(hostname),
 976                               SILC_STRING_UTF8, 256)) {
 977     SILC_LOG_ERROR(("Malformed hostname '%s'. Hostname must be UTF-8 string",
 978                     client->hostname));
 979     return FALSE;
 980   }
 981   if (!silc_utf8_valid(realname, strlen(realname))) {
 982     SILC_LOG_ERROR(("Malformed realname '%s'. Realname must be UTF-8 string",
 983                     client->realname));
 984     return FALSE;
 985   }
 986
 987   /* Take the name strings */
 988   client->username = strdup(username);
 989   client->hostname = strdup(hostname);
 990   client->realname = strdup(realname);
 991   if (!username || !hostname || !realname)
 992     return FALSE;
 993
 994   client->internal->ftp_sessions = silc_dlist_init();
 995   if (!client->internal->ftp_sessions)
 996     return FALSE;
 997
 998   if (!client->internal->params->dont_register_crypto_library) {
 999     /* Initialize the crypto library.  If application has done this already
1000        this has no effect.  Also, we will not be overriding something
1001        application might have registered earlier. */
1002     silc_cipher_register_default();
1003     silc_pkcs_register_default();
1004     silc_hash_register_default();
1005     silc_hmac_register_default();
1006   }
1007
1008   /* Initialize random number generator */
1009   client->rng = silc_rng_alloc();
1010   if (!client->rng)
1011     return FALSE;
1012   silc_rng_init(client->rng);
1013   silc_rng_global_init(client->rng);
1014
1015   /* Initialize the scheduler */
1016   client->schedule = silc_schedule_init(0, client);
1017   if (!client->schedule)
1018     return FALSE;
1019
1020   /* Allocate client lock */
1021   silc_mutex_alloc(&client->internal->lock);
1022
1023   /* Register commands */
1024   silc_client_commands_register(client);
1025
1026   /* Start packet engine */
1027   client->internal->packet_engine =
1028     silc_packet_engine_start(client->rng, FALSE, &silc_client_stream_cbs,
1029                              client);
1030   if (!client->internal->packet_engine)
1031     return FALSE;
1032
1033   /* Initialize and start the client FSM */
1034   client->internal->running = running;
1035   client->internal->running_context = context;
1036   silc_fsm_init(&client->internal->fsm, client, NULL, NULL, client->schedule);
1037   silc_fsm_event_init(&client->internal->wait_event, &client->internal->fsm);
1038   silc_fsm_start_sync(&client->internal->fsm, silc_client_st_run);
1039
1040   /* Signal the application when we are running */
1041   client->internal->run_callback = TRUE;
1042   SILC_FSM_EVENT_SIGNAL(&client->internal->wait_event);
1043
1044   return TRUE;
1045 }
1046
1047 /* Starts the SILC client FSM machine and blocks here.  When this returns
1048    the client has ended. */
1049
1050 void silc_client_run(SilcClient client)
1051 {
1052   SILC_LOG_DEBUG(("Starting SILC client"));
1053
1054   /* Run the scheduler */
1055   silc_schedule(client->schedule);
1056 }
1057
1058 /* Call scheduler one iteration and return. */
1059
1060 void silc_client_run_one(SilcClient client)
1061 {
1062   if (silc_fsm_is_started(&client->internal->fsm))
1063     silc_schedule_one(client->schedule, 0);
1064 }
1065
1066 /* Stops the client. This is called to stop the client and thus to stop
1067    the program. */
1068
1069 void silc_client_stop(SilcClient client, SilcClientStopped stopped,
1070                       void *context)
1071 {
1072   SILC_LOG_DEBUG(("Stopping client"));
1073
1074   client->internal->running = (SilcClientRunning)stopped;
1075   client->internal->running_context = context;
1076
1077   /* Signal to stop */
1078   client->internal->stop = TRUE;
1079   SILC_FSM_EVENT_SIGNAL(&client->internal->wait_event);
1080 }