lib/silcclient/command_reply.c

   1 /*
   2
   3   command_reply.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 /* Calls error command reply callback back to command sender. */
  28 #define ERROR_CALLBACK(err)                                     \
  29 do {                                                            \
  30   void *arg1 = NULL, *arg2 = NULL;                              \
  31   if (cmd->status != SILC_STATUS_OK)                            \
  32     silc_status_get_args(cmd->status, args, &arg1, &arg2);      \
  33   else                                                          \
  34     cmd->status = cmd->error = err;                             \
  35   SILC_LOG_DEBUG(("Error in command reply: %s",                 \
  36                  silc_get_status_message(cmd->status)));        \
  37   silc_client_command_callback(cmd, arg1, arg2);                \
  38 } while(0)
  39
  40 /* Check for error */
  41 #define CHECK_STATUS(msg)                                               \
  42   SILC_LOG_DEBUG(("%s", silc_get_command_name(cmd->cmd)));              \
  43   if (cmd->error != SILC_STATUS_OK) {                                   \
  44     if (cmd->verbose)                                                   \
  45       SAY(cmd->conn->client, cmd->conn, SILC_CLIENT_MESSAGE_COMMAND_ERROR, \
  46           msg "%s", silc_get_status_message(cmd->error));               \
  47     ERROR_CALLBACK(cmd->error);                                         \
  48     silc_client_command_process_error(cmd, state_context, cmd->error);  \
  49     silc_fsm_next(fsm, silc_client_command_reply_processed);            \
  50     return SILC_FSM_CONTINUE;                                           \
  51   }
  52
  53 /* Check for correct arguments */
  54 #define CHECK_ARGS(min, max)                                    \
  55   if (silc_argument_get_arg_num(args) < min ||                  \
  56       silc_argument_get_arg_num(args) > max) {                  \
  57     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);          \
  58     silc_fsm_next(fsm, silc_client_command_reply_processed);    \
  59     return SILC_FSM_CONTINUE;                                   \
  60   }
  61
  62 #define SAY cmd->conn->client->internal->ops->say
  63
  64 /************************ Static utility functions **************************/
  65
  66 /* Delivers the command reply back to application */
  67
  68 static inline void
  69 silc_client_command_callback(SilcClientCommandContext cmd, ...)
  70 {
  71   SilcClientCommandReplyCallback cb;
  72   SilcList list;
  73   va_list ap, cp;
  74
  75   va_start(ap, cmd);
  76
  77   /* Default reply callback */
  78   if (cmd->called) {
  79     silc_va_copy(cp, ap);
  80     cmd->conn->client->internal->ops->command_reply(
  81                        cmd->conn->client, cmd->conn, cmd->cmd, cmd->status,
  82                        cmd->error, cp);
  83     va_end(cp);
  84   }
  85
  86   /* Reply callback */
  87   list = cmd->reply_callbacks;
  88   silc_list_start(list);
  89   while ((cb = silc_list_get(list)))
  90     if (!cb->do_not_call) {
  91       silc_va_copy(cp, ap);
  92       cb->do_not_call = !cb->reply(cmd->conn->client, cmd->conn, cmd->cmd,
  93                                    cmd->status, cmd->error, cb->context, cp);
  94       va_end(cp);
  95     }
  96
  97   va_end(ap);
  98 }
  99
 100 /* Handles common error status types. */
 101
 102 static void silc_client_command_process_error(SilcClientCommandContext cmd,
 103                                               SilcCommandPayload payload,
 104                                               SilcStatus error)
 105 {
 106   SilcClient client = cmd->conn->client;
 107   SilcClientConnection conn = cmd->conn;
 108   SilcArgumentPayload args = silc_command_get_args(payload);
 109   SilcID id;
 110
 111   if (cmd->error == SILC_STATUS_ERR_NO_SUCH_CLIENT_ID) {
 112     SilcClientEntry client_entry;
 113
 114     /* Remove unknown client entry from cache */
 115     if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL))
 116       return;
 117
 118     client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
 119     if (client_entry) {
 120       silc_client_remove_from_channels(client, conn, client_entry);
 121       silc_client_del_client(client, conn, client_entry);
 122       silc_client_unref_client(client, conn, client_entry);
 123     }
 124     return;
 125   }
 126
 127   if (cmd->error == SILC_STATUS_ERR_NO_SUCH_CHANNEL_ID) {
 128     SilcChannelEntry channel;
 129
 130     /* Remove unknown channel entry from cache */
 131     if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL))
 132       return;
 133
 134     channel = silc_client_get_channel_by_id(client, conn, &id.u.channel_id);
 135     if (channel) {
 136       silc_client_empty_channel(client, conn, channel);
 137       silc_client_del_channel(client, conn, channel);
 138       silc_client_unref_channel(client, conn, channel);
 139     }
 140     return;
 141   }
 142
 143   if (cmd->error == SILC_STATUS_ERR_NO_SUCH_SERVER_ID) {
 144     SilcServerEntry server_entry;
 145
 146     /* Remove unknown server entry from cache */
 147     if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL))
 148       return;
 149
 150     server_entry = silc_client_get_server_by_id(client, conn, &id.u.server_id);
 151     if (server_entry) {
 152       silc_client_del_server(client, conn, server_entry);
 153       silc_client_unref_server(client, conn, server_entry);
 154     }
 155     return;
 156   }
 157 }
 158
 159 /***************************** Command Reply ********************************/
 160
 161 /* Process received command reply packet */
 162
 163 SILC_FSM_STATE(silc_client_command_reply)
 164 {
 165   SilcClientConnection conn = fsm_context;
 166   SilcPacket packet = state_context;
 167   SilcClientCommandContext cmd;
 168   SilcCommandPayload payload;
 169   SilcCommand command;
 170   SilcUInt16 cmd_ident;
 171
 172   /* Get command reply payload from packet */
 173   payload = silc_command_payload_parse(silc_buffer_datalen(&packet->buffer));
 174   silc_packet_free(packet);
 175   if (!payload) {
 176     SILC_LOG_DEBUG(("Bad command reply packet"));
 177     return SILC_FSM_FINISH;
 178   }
 179
 180   cmd_ident = silc_command_get_ident(payload);
 181   command = silc_command_get(payload);
 182
 183   /* Find the command pending reply */
 184   silc_mutex_lock(conn->internal->lock);
 185   silc_list_start(conn->internal->pending_commands);
 186   while ((cmd = silc_list_get(conn->internal->pending_commands))) {
 187     if ((cmd->cmd == command || cmd->cmd == SILC_COMMAND_NONE)
 188         && cmd->cmd_ident == cmd_ident) {
 189       silc_list_del(conn->internal->pending_commands, cmd);
 190       break;
 191     }
 192   }
 193   silc_mutex_unlock(conn->internal->lock);
 194
 195   if (!cmd) {
 196     SILC_LOG_DEBUG(("Unknown command reply %s, ident %d",
 197                     silc_get_command_name(command), cmd_ident));
 198     silc_command_payload_free(payload);
 199     return SILC_FSM_FINISH;
 200   }
 201
 202   /* Signal command thread that command reply has arrived.  We continue
 203      command reply processing synchronously because we save the command
 204      payload into state context.  No other reply may arrive to this command
 205      while we're processing this reply. */
 206   silc_fsm_set_state_context(&cmd->thread, payload);
 207   silc_fsm_next(&cmd->thread, silc_client_command_reply_process);
 208   silc_fsm_continue_sync(&cmd->thread);
 209
 210   return SILC_FSM_FINISH;
 211 }
 212
 213 /* Wait here for command reply to arrive from remote host */
 214
 215 SILC_FSM_STATE(silc_client_command_reply_wait)
 216 {
 217   SilcClientCommandContext cmd = fsm_context;
 218
 219   SILC_LOG_DEBUG(("Wait for command reply"));
 220
 221   /** Wait for command reply */
 222   silc_fsm_set_state_context(fsm, NULL);
 223   silc_fsm_next_later(fsm, silc_client_command_reply_timeout,
 224                       cmd->cmd != SILC_COMMAND_PING ? 40 : 60, 0);
 225   return SILC_FSM_WAIT;
 226 }
 227
 228 /* Timeout occurred while waiting command reply */
 229
 230 SILC_FSM_STATE(silc_client_command_reply_timeout)
 231 {
 232   SilcClientCommandContext cmd = fsm_context;
 233   SilcClientConnection conn = cmd->conn;
 234   SilcArgumentPayload args = NULL;
 235
 236   if (conn->internal->disconnected) {
 237     SILC_LOG_DEBUG(("Command %s canceled", silc_get_command_name(cmd->cmd)));
 238     silc_list_del(conn->internal->pending_commands, cmd);
 239     if (!cmd->called)
 240       ERROR_CALLBACK(SILC_STATUS_ERR_TIMEDOUT);
 241     return SILC_FSM_FINISH;
 242   }
 243
 244   SILC_LOG_DEBUG(("Command %s timeout", silc_get_command_name(cmd->cmd)));
 245
 246   /* Timeout, reply not received in timely fashion */
 247   silc_list_del(conn->internal->pending_commands, cmd);
 248   ERROR_CALLBACK(SILC_STATUS_ERR_TIMEDOUT);
 249   return SILC_FSM_FINISH;
 250 }
 251
 252 /* Process received command reply payload */
 253
 254 SILC_FSM_STATE(silc_client_command_reply_process)
 255 {
 256   SilcClientCommandContext cmd = fsm_context;
 257   SilcCommandPayload payload = state_context;
 258
 259   silc_command_get_status(payload, &cmd->status, &cmd->error);
 260
 261   switch (cmd->cmd) {
 262   case SILC_COMMAND_WHOIS:
 263     /** WHOIS */
 264     silc_fsm_next(fsm, silc_client_command_reply_whois);
 265     break;
 266   case SILC_COMMAND_WHOWAS:
 267     /** WHOWAS */
 268     silc_fsm_next(fsm, silc_client_command_reply_whowas);
 269     break;
 270   case SILC_COMMAND_IDENTIFY:
 271     /** IDENTIFY */
 272     silc_fsm_next(fsm, silc_client_command_reply_identify);
 273     break;
 274   case SILC_COMMAND_NICK:
 275     /** NICK */
 276     silc_fsm_next(fsm, silc_client_command_reply_nick);
 277     break;
 278   case SILC_COMMAND_LIST:
 279     /** LIST */
 280     silc_fsm_next(fsm, silc_client_command_reply_list);
 281     break;
 282   case SILC_COMMAND_TOPIC:
 283     /** TOPIC */
 284     silc_fsm_next(fsm, silc_client_command_reply_topic);
 285     break;
 286   case SILC_COMMAND_INVITE:
 287     /** INVITE */
 288     silc_fsm_next(fsm, silc_client_command_reply_invite);
 289     break;
 290   case SILC_COMMAND_QUIT:
 291     /** QUIT */
 292     silc_fsm_next(fsm, silc_client_command_reply_quit);
 293     break;
 294   case SILC_COMMAND_KILL:
 295     /** KILL */
 296     silc_fsm_next(fsm, silc_client_command_reply_kill);
 297     break;
 298   case SILC_COMMAND_INFO:
 299     /** INFO */
 300     silc_fsm_next(fsm, silc_client_command_reply_info);
 301     break;
 302   case SILC_COMMAND_STATS:
 303     /** STATS */
 304     silc_fsm_next(fsm, silc_client_command_reply_stats);
 305     break;
 306   case SILC_COMMAND_PING:
 307     /** PING */
 308     silc_fsm_next(fsm, silc_client_command_reply_ping);
 309     break;
 310   case SILC_COMMAND_OPER:
 311     /** OPER */
 312     silc_fsm_next(fsm, silc_client_command_reply_oper);
 313     break;
 314   case SILC_COMMAND_JOIN:
 315     /** JOIN */
 316     silc_fsm_next(fsm, silc_client_command_reply_join);
 317     break;
 318   case SILC_COMMAND_MOTD:
 319     /** MOTD */
 320     silc_fsm_next(fsm, silc_client_command_reply_motd);
 321     break;
 322   case SILC_COMMAND_UMODE:
 323     /** UMODE */
 324     silc_fsm_next(fsm, silc_client_command_reply_umode);
 325     break;
 326   case SILC_COMMAND_CMODE:
 327     /** CMODE */
 328     silc_fsm_next(fsm, silc_client_command_reply_cmode);
 329     break;
 330   case SILC_COMMAND_CUMODE:
 331     /** CUMODE */
 332     silc_fsm_next(fsm, silc_client_command_reply_cumode);
 333     break;
 334   case SILC_COMMAND_KICK:
 335     /** KICK */
 336     silc_fsm_next(fsm, silc_client_command_reply_kick);
 337     break;
 338   case SILC_COMMAND_BAN:
 339     /** BAN */
 340     silc_fsm_next(fsm, silc_client_command_reply_ban);
 341     break;
 342   case SILC_COMMAND_DETACH:
 343     /** DETACH */
 344     silc_fsm_next(fsm, silc_client_command_reply_detach);
 345     break;
 346   case SILC_COMMAND_WATCH:
 347     /** WATCH */
 348     silc_fsm_next(fsm, silc_client_command_reply_watch);
 349     break;
 350   case SILC_COMMAND_SILCOPER:
 351     /** SILCOPER */
 352     silc_fsm_next(fsm, silc_client_command_reply_silcoper);
 353     break;
 354   case SILC_COMMAND_LEAVE:
 355     /** LEAVE */
 356     silc_fsm_next(fsm, silc_client_command_reply_leave);
 357     break;
 358   case SILC_COMMAND_USERS:
 359     /** USERS */
 360     silc_fsm_next(fsm, silc_client_command_reply_users);
 361     break;
 362   case SILC_COMMAND_GETKEY:
 363     /** GETKEY */
 364     silc_fsm_next(fsm, silc_client_command_reply_getkey);
 365     break;
 366   case SILC_COMMAND_SERVICE:
 367     /** SERVICE */
 368     silc_fsm_next(fsm, silc_client_command_reply_service);
 369     break;
 370   default:
 371     return SILC_FSM_FINISH;
 372   }
 373
 374   return SILC_FSM_CONTINUE;
 375 }
 376
 377 /* Completes command reply processing */
 378
 379 SILC_FSM_STATE(silc_client_command_reply_processed)
 380 {
 381   SilcClientCommandContext cmd = fsm_context;
 382   SilcClientConnection conn = cmd->conn;
 383   SilcCommandPayload payload = state_context;
 384
 385   silc_command_payload_free(payload);
 386
 387   if (cmd->status == SILC_STATUS_OK || cmd->status == SILC_STATUS_LIST_END ||
 388       SILC_STATUS_IS_ERROR(cmd->status))
 389     return SILC_FSM_FINISH;
 390
 391   /* Add back to pending command reply list */
 392   silc_mutex_lock(conn->internal->lock);
 393   cmd->resolved = FALSE;
 394   silc_list_add(conn->internal->pending_commands, cmd);
 395   silc_mutex_unlock(conn->internal->lock);
 396
 397   /** Wait more command payloads */
 398   silc_fsm_next(fsm, silc_client_command_reply_wait);
 399   return SILC_FSM_CONTINUE;
 400 }
 401
 402 /******************************** WHOIS *************************************/
 403
 404 /* Received reply for WHOIS command. */
 405
 406 SILC_FSM_STATE(silc_client_command_reply_whois)
 407 {
 408   SilcClientCommandContext cmd = fsm_context;
 409   SilcClientConnection conn = cmd->conn;
 410   SilcClient client = conn->client;
 411   SilcCommandPayload payload = state_context;
 412   SilcArgumentPayload args = silc_command_get_args(payload);
 413   SilcClientEntry client_entry = NULL;
 414   SilcUInt32 idle = 0, mode = 0, fingerprint_len, len, *umodes = NULL;
 415   SilcBufferStruct channels, ch_user_modes;
 416   SilcBool has_channels = FALSE;
 417   SilcDList channel_list = NULL;
 418   SilcID id;
 419   char *nickname = NULL, *username = NULL, *realname = NULL;
 420   unsigned char *fingerprint, *tmp;
 421
 422   CHECK_STATUS("WHOIS: ");
 423   CHECK_ARGS(5, 11);
 424
 425   /* Get Client ID */
 426   if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL)) {
 427     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 428     goto out;
 429   }
 430
 431   /* Get names */
 432   nickname = silc_argument_get_arg_type(args, 3, NULL);
 433   username = silc_argument_get_arg_type(args, 4, NULL);
 434   realname = silc_argument_get_arg_type(args, 5, NULL);
 435   if (!nickname || !username || !realname) {
 436     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 437     goto out;
 438   }
 439
 440   /* Get joined channel list */
 441   memset(&channels, 0, sizeof(channels));
 442   tmp = silc_argument_get_arg_type(args, 6, &len);
 443   if (tmp) {
 444     has_channels = TRUE;
 445     silc_buffer_set(&channels, tmp, len);
 446
 447     /* Get channel user mode list */
 448     tmp = silc_argument_get_arg_type(args, 10, &len);
 449     if (!tmp) {
 450       ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 451       goto out;
 452     }
 453     silc_buffer_set(&ch_user_modes, tmp, len);
 454   }
 455
 456   /* Get user mode */
 457   tmp = silc_argument_get_arg_type(args, 7, &len);
 458   if (tmp)
 459     SILC_GET32_MSB(mode, tmp);
 460
 461   /* Get idle time */
 462   tmp = silc_argument_get_arg_type(args, 8, &len);
 463   if (tmp)
 464     SILC_GET32_MSB(idle, tmp);
 465
 466   /* Get fingerprint */
 467   fingerprint = silc_argument_get_arg_type(args, 9, &fingerprint_len);
 468
 469   /* Check if we have this client cached already. */
 470   client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
 471   if (!client_entry) {
 472     SILC_LOG_DEBUG(("Adding new client entry (WHOIS)"));
 473     client_entry =
 474       silc_client_add_client(client, conn, nickname, username, realname,
 475                              &id.u.client_id, mode);
 476     if (!client_entry) {
 477       ERROR_CALLBACK(SILC_STATUS_ERR_RESOURCE_LIMIT);
 478       goto out;
 479     }
 480     silc_client_ref_client(client, conn, client_entry);
 481   } else {
 482     silc_client_update_client(client, conn, client_entry,
 483                               nickname, username, realname, mode);
 484   }
 485
 486   silc_rwlock_wrlock(client_entry->internal.lock);
 487
 488   if (fingerprint && fingerprint_len == sizeof(client_entry->fingerprint))
 489     memcpy(client_entry->fingerprint, fingerprint, fingerprint_len);
 490
 491   /* Get user attributes */
 492   tmp = silc_argument_get_arg_type(args, 11, &len);
 493   if (tmp) {
 494     if (client_entry->attrs)
 495       silc_attribute_payload_list_free(client_entry->attrs);
 496     client_entry->attrs = silc_attribute_payload_parse(tmp, len);
 497   }
 498
 499   silc_rwlock_unlock(client_entry->internal.lock);
 500
 501   /* Parse channel and channel user mode list */
 502   if (has_channels) {
 503     channel_list = silc_channel_payload_parse_list(silc_buffer_data(&channels),
 504                                                    silc_buffer_len(&channels));
 505     if (channel_list)
 506       silc_get_mode_list(&ch_user_modes, silc_dlist_count(channel_list),
 507                          &umodes);
 508   }
 509
 510   /* Notify application */
 511   silc_client_command_callback(cmd, client_entry, nickname, username,
 512                                realname, channel_list, mode, idle, fingerprint,
 513                                umodes, client_entry->attrs);
 514
 515   silc_client_unref_client(client, conn, client_entry);
 516   if (has_channels) {
 517     silc_channel_payload_list_free(channel_list);
 518     silc_free(umodes);
 519   }
 520
 521  out:
 522   silc_fsm_next(fsm, silc_client_command_reply_processed);
 523   return SILC_FSM_CONTINUE;
 524 }
 525
 526 /******************************** WHOWAS ************************************/
 527
 528 /* Received reply for WHOWAS command. */
 529
 530 SILC_FSM_STATE(silc_client_command_reply_whowas)
 531 {
 532   SilcClientCommandContext cmd = fsm_context;
 533   SilcClientConnection conn = cmd->conn;
 534   SilcClient client = conn->client;
 535   SilcCommandPayload payload = state_context;
 536   SilcArgumentPayload args = silc_command_get_args(payload);
 537   SilcClientEntry client_entry = NULL;
 538   SilcID id;
 539   char *nickname, *username;
 540   char *realname = NULL;
 541
 542   CHECK_STATUS("WHOWAS: ");
 543   CHECK_ARGS(4, 5);
 544
 545   /* Get Client ID */
 546   if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL)) {
 547     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 548     goto out;
 549   }
 550
 551   /* Get the client entry */
 552   client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
 553
 554   /* Get names */
 555   nickname = silc_argument_get_arg_type(args, 3, NULL);
 556   username = silc_argument_get_arg_type(args, 4, NULL);
 557   realname = silc_argument_get_arg_type(args, 5, NULL);
 558   if (!nickname || !username) {
 559     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 560     goto out;
 561   }
 562
 563   /* Notify application. We don't save any history information to any
 564      cache. Just pass the data to the application. */
 565   silc_client_command_callback(cmd, client_entry, nickname, username,
 566                                realname);
 567
 568  out:
 569   silc_client_unref_client(client, conn, client_entry);
 570   silc_fsm_next(fsm, silc_client_command_reply_processed);
 571   return SILC_FSM_CONTINUE;
 572 }
 573
 574 /******************************** IDENTIFY **********************************/
 575
 576 /* Received reply for IDENTIFY command. */
 577
 578 SILC_FSM_STATE(silc_client_command_reply_identify)
 579 {
 580   SilcClientCommandContext cmd = fsm_context;
 581   SilcClientConnection conn = cmd->conn;
 582   SilcClient client = conn->client;
 583   SilcCommandPayload payload = state_context;
 584   SilcArgumentPayload args = silc_command_get_args(payload);
 585   SilcClientEntry client_entry;
 586   SilcServerEntry server_entry;
 587   SilcChannelEntry channel_entry;
 588   SilcUInt32 len;
 589   SilcID id;
 590   char *name = NULL, *info = NULL;
 591
 592   CHECK_STATUS("IDENTIFY: ");
 593   CHECK_ARGS(2, 4);
 594
 595   /* Get the ID */
 596   if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL)) {
 597     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 598     goto out;
 599   }
 600
 601   /* Get names */
 602   name = silc_argument_get_arg_type(args, 3, &len);
 603   info = silc_argument_get_arg_type(args, 4, &len);
 604
 605   switch (id.type) {
 606   case SILC_ID_CLIENT:
 607     SILC_LOG_DEBUG(("Received client information"));
 608
 609     /* Check if we have this client cached already. */
 610     client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
 611     if (!client_entry) {
 612       SILC_LOG_DEBUG(("Adding new client entry (IDENTIFY)"));
 613       client_entry =
 614         silc_client_add_client(client, conn, name, info, NULL,
 615                                &id.u.client_id, 0);
 616       if (!client_entry) {
 617         ERROR_CALLBACK(SILC_STATUS_ERR_RESOURCE_LIMIT);
 618         goto out;
 619       }
 620       silc_client_ref_client(client, conn, client_entry);
 621     } else {
 622       silc_client_update_client(client, conn, client_entry,
 623                                 name, info, NULL, 0);
 624     }
 625
 626     /* Notify application */
 627     silc_client_command_callback(cmd, client_entry, name, info);
 628     silc_client_unref_client(client, conn, client_entry);
 629     break;
 630
 631   case SILC_ID_SERVER:
 632     SILC_LOG_DEBUG(("Received server information"));
 633
 634     /* Check if we have this server cached already. */
 635     server_entry = silc_client_get_server_by_id(client, conn, &id.u.server_id);
 636     if (!server_entry) {
 637       SILC_LOG_DEBUG(("Adding new server entry (IDENTIFY)"));
 638       server_entry = silc_client_add_server(client, conn, name, info,
 639                                             &id.u.server_id);
 640       if (!server_entry) {
 641         ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 642         goto out;
 643       }
 644       silc_client_ref_server(client, conn, server_entry);
 645     } else {
 646       silc_client_update_server(client, conn, server_entry, name, info);
 647     }
 648     server_entry->internal.resolve_cmd_ident = 0;
 649
 650     /* Notify application */
 651     silc_client_command_callback(cmd, server_entry, name, info);
 652     silc_client_unref_server(client, conn, server_entry);
 653     break;
 654
 655   case SILC_ID_CHANNEL:
 656     SILC_LOG_DEBUG(("Received channel information"));
 657
 658     /* Check if we have this channel cached already. */
 659     channel_entry = silc_client_get_channel_by_id(client, conn,
 660                                                   &id.u.channel_id);
 661     if (!channel_entry) {
 662       SILC_LOG_DEBUG(("Adding new channel entry (IDENTIFY)"));
 663
 664       if (!name) {
 665         ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 666         goto out;
 667       }
 668
 669       /* Add new channel entry */
 670       channel_entry = silc_client_add_channel(client, conn, name, 0,
 671                                               &id.u.channel_id);
 672       if (!channel_entry) {
 673         ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 674         goto out;
 675       }
 676       silc_client_ref_channel(client, conn, channel_entry);
 677     }
 678
 679     /* Notify application */
 680     silc_client_command_callback(cmd, channel_entry,
 681                                  channel_entry->channel_name, info);
 682     silc_client_unref_channel(client, conn, channel_entry);
 683     break;
 684   }
 685
 686  out:
 687   silc_fsm_next(fsm, silc_client_command_reply_processed);
 688   return SILC_FSM_CONTINUE;
 689 }
 690
 691 /********************************** NICK ************************************/
 692
 693 /* Received reply for command NICK. */
 694
 695 SILC_FSM_STATE(silc_client_command_reply_nick)
 696 {
 697   SilcClientCommandContext cmd = fsm_context;
 698   SilcClientConnection conn = cmd->conn;
 699   SilcClient client = conn->client;
 700   SilcCommandPayload payload = state_context;
 701   SilcArgumentPayload args = silc_command_get_args(payload);
 702   unsigned char *nick, *idp;
 703   SilcUInt32 len, idp_len;
 704   SilcClientID old_client_id;
 705   SilcID id;
 706
 707   /* Sanity checks */
 708   CHECK_STATUS("Cannot set nickname: ");
 709   CHECK_ARGS(2, 3);
 710
 711   /* Take received Client ID */
 712   idp = silc_argument_get_arg_type(args, 2, &idp_len);
 713   if (!idp) {
 714     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 715     goto out;
 716   }
 717   if (!silc_id_payload_parse_id(idp, idp_len, &id)) {
 718     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 719     goto out;
 720   }
 721
 722   /* Take the new nickname */
 723   nick = silc_argument_get_arg_type(args, 3, &len);
 724   if (!nick) {
 725     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 726     goto out;
 727   }
 728
 729   silc_rwlock_wrlock(conn->local_entry->internal.lock);
 730
 731   /* Change the nickname */
 732   old_client_id = *conn->local_id;
 733   if (!silc_client_change_nickname(client, conn, conn->local_entry,
 734                                    nick, &id.u.client_id, idp, idp_len)) {
 735     ERROR_CALLBACK(SILC_STATUS_ERR_BAD_NICKNAME);
 736     silc_rwlock_unlock(conn->local_entry->internal.lock);
 737     goto out;
 738   }
 739
 740   silc_rwlock_unlock(conn->local_entry->internal.lock);
 741
 742   /* Notify application */
 743   silc_client_command_callback(cmd, conn->local_entry,
 744                                conn->local_entry->nickname, &old_client_id);
 745
 746  out:
 747   silc_fsm_next(fsm, silc_client_command_reply_processed);
 748   return SILC_FSM_CONTINUE;
 749 }
 750
 751 /********************************** LIST ************************************/
 752
 753 /* Received reply to the LIST command. */
 754
 755 SILC_FSM_STATE(silc_client_command_reply_list)
 756 {
 757   SilcClientCommandContext cmd = fsm_context;
 758   SilcClientConnection conn = cmd->conn;
 759   SilcClient client = conn->client;
 760   SilcCommandPayload payload = state_context;
 761   SilcArgumentPayload args = silc_command_get_args(payload);
 762   unsigned char *tmp, *name, *topic;
 763   SilcUInt32 usercount = 0;
 764   SilcChannelEntry channel_entry = NULL;
 765   SilcID id;
 766
 767   /* Sanity checks */
 768   CHECK_STATUS("Cannot list channels: ");
 769
 770   if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL)) {
 771     /* There were no channels in the network. */
 772     silc_client_command_callback(cmd, NULL, NULL, NULL, 0);
 773     silc_fsm_next(fsm, silc_client_command_reply_processed);
 774     return SILC_FSM_CONTINUE;
 775   }
 776
 777   CHECK_ARGS(3, 5);
 778
 779   name = silc_argument_get_arg_type(args, 3, NULL);
 780   if (!name) {
 781     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 782     goto out;
 783   }
 784
 785   topic = silc_argument_get_arg_type(args, 4, NULL);
 786   tmp = silc_argument_get_arg_type(args, 5, NULL);
 787   if (tmp)
 788     SILC_GET32_MSB(usercount, tmp);
 789
 790   /* Check whether the channel exists, and add it to cache if it doesn't. */
 791   channel_entry = silc_client_get_channel_by_id(client, conn,
 792                                                 &id.u.channel_id);
 793   if (!channel_entry) {
 794     /* Add new channel entry */
 795     channel_entry = silc_client_add_channel(client, conn, name, 0,
 796                                             &id.u.channel_id);
 797     if (!channel_entry) {
 798       ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 799       goto out;
 800     }
 801     silc_client_ref_channel(client, conn, channel_entry);
 802   }
 803
 804   /* Notify application */
 805   silc_client_command_callback(cmd, channel_entry, channel_entry->channel_name,
 806                                topic, usercount);
 807
 808  out:
 809   silc_client_unref_channel(client, conn, channel_entry);
 810   silc_fsm_next(fsm, silc_client_command_reply_processed);
 811   return SILC_FSM_CONTINUE;
 812 }
 813
 814 /********************************* TOPIC ************************************/
 815
 816 /* Received reply to topic command. */
 817
 818 SILC_FSM_STATE(silc_client_command_reply_topic)
 819 {
 820   SilcClientCommandContext cmd = fsm_context;
 821   SilcClientConnection conn = cmd->conn;
 822   SilcClient client = conn->client;
 823   SilcCommandPayload payload = state_context;
 824   SilcArgumentPayload args = silc_command_get_args(payload);
 825   SilcChannelEntry channel = NULL;
 826   char *topic;
 827   SilcUInt32 len;
 828   SilcID id;
 829
 830   /* Sanity checks */
 831   CHECK_STATUS("Cannot set topic: ");
 832   CHECK_ARGS(2, 3);
 833
 834   /* Take Channel ID */
 835   if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL)) {
 836     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 837     goto out;
 838   }
 839
 840   /* Get the channel entry */
 841   channel = silc_client_get_channel_by_id(client, conn, &id.u.channel_id);
 842   if (!channel) {
 843     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 844     goto out;
 845   }
 846
 847   silc_rwlock_wrlock(channel->internal.lock);
 848
 849   /* Take topic */
 850   topic = silc_argument_get_arg_type(args, 3, &len);
 851   if (topic) {
 852     silc_free(channel->topic);
 853     channel->topic = silc_memdup(topic, len);
 854   }
 855
 856   silc_rwlock_unlock(channel->internal.lock);
 857
 858   /* Notify application */
 859   silc_client_command_callback(cmd, channel, channel->topic);
 860
 861  out:
 862   silc_client_unref_channel(client, conn, channel);
 863   silc_fsm_next(fsm, silc_client_command_reply_processed);
 864   return SILC_FSM_CONTINUE;
 865 }
 866
 867 /********************************* INVITE ***********************************/
 868
 869 /* Received reply to invite command. */
 870
 871 SILC_FSM_STATE(silc_client_command_reply_invite)
 872 {
 873   SilcClientCommandContext cmd = fsm_context;
 874   SilcClientConnection conn = cmd->conn;
 875   SilcClient client = conn->client;
 876   SilcCommandPayload payload = state_context;
 877   SilcArgumentPayload args = silc_command_get_args(payload);
 878   SilcChannelEntry channel = NULL;
 879   unsigned char *tmp;
 880   SilcUInt32 len;
 881   SilcArgumentPayload invite_args = NULL;
 882   SilcID id;
 883
 884   /* Sanity checks */
 885   CHECK_STATUS("Cannot invite: ");
 886   CHECK_ARGS(2, 3);
 887
 888   /* Take Channel ID */
 889   if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL)) {
 890     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 891     goto out;
 892   }
 893
 894   /* Get the channel entry */
 895   channel = silc_client_get_channel_by_id(client, conn, &id.u.channel_id);
 896   if (!channel) {
 897     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 898     goto out;
 899   }
 900
 901   /* Get the invite list */
 902   tmp = silc_argument_get_arg_type(args, 3, &len);
 903   if (tmp)
 904     invite_args = silc_argument_list_parse(tmp, len);
 905
 906   /* Notify application */
 907   silc_client_command_callback(cmd, channel, invite_args);
 908
 909   if (invite_args)
 910     silc_argument_payload_free(invite_args);
 911
 912  out:
 913   silc_client_unref_channel(client, conn, channel);
 914   silc_fsm_next(fsm, silc_client_command_reply_processed);
 915   return SILC_FSM_CONTINUE;
 916 }
 917
 918 /********************************** KILL ************************************/
 919
 920 /* Received reply to the KILL command. */
 921
 922 SILC_FSM_STATE(silc_client_command_reply_kill)
 923 {
 924   SilcClientCommandContext cmd = fsm_context;
 925   SilcClientConnection conn = cmd->conn;
 926   SilcClient client = conn->client;
 927   SilcCommandPayload payload = state_context;
 928   SilcArgumentPayload args = silc_command_get_args(payload);
 929   SilcClientEntry client_entry;
 930   SilcID id;
 931
 932   /* Sanity checks */
 933   CHECK_STATUS("Cannot kill: ");
 934   CHECK_ARGS(2, 2);
 935
 936   if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL)) {
 937     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 938     goto out;
 939   }
 940
 941   /* Get the client entry, if exists */
 942   client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
 943
 944   /* Notify application */
 945   silc_client_command_callback(cmd, client_entry);
 946
 947   /* Remove the client */
 948   if (client_entry) {
 949     silc_client_remove_from_channels(client, conn, client_entry);
 950     silc_client_del_client(client, conn, client_entry);
 951     silc_client_unref_client(client, conn, client_entry);
 952   }
 953
 954  out:
 955   silc_fsm_next(fsm, silc_client_command_reply_processed);
 956   return SILC_FSM_CONTINUE;
 957 }
 958
 959 /********************************** INFO ************************************/
 960
 961 /* Received reply to INFO command. We receive the server ID and some
 962    information about the server user requested. */
 963
 964 SILC_FSM_STATE(silc_client_command_reply_info)
 965 {
 966   SilcClientCommandContext cmd = fsm_context;
 967   SilcClientConnection conn = cmd->conn;
 968   SilcClient client = conn->client;
 969   SilcCommandPayload payload = state_context;
 970   SilcArgumentPayload args = silc_command_get_args(payload);
 971   SilcServerEntry server;
 972   char *server_name, *server_info;
 973   SilcID id;
 974
 975   /* Sanity checks */
 976   CHECK_STATUS("Cannot get info: ");
 977   CHECK_ARGS(4, 4);
 978
 979   /* Get server ID */
 980   if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL)) {
 981     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 982     goto out;
 983   }
 984
 985   /* Get server name */
 986   server_name = silc_argument_get_arg_type(args, 3, NULL);
 987   if (!server_name) {
 988     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 989     goto out;
 990   }
 991
 992   /* Get server info */
 993   server_info = silc_argument_get_arg_type(args, 4, NULL);
 994   if (!server_info) {
 995     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
 996     goto out;
 997   }
 998
 999   /* See whether we have this server cached. If not create it. */
1000   server = silc_client_get_server_by_id(client, conn, &id.u.server_id);
1001   if (!server) {
1002     SILC_LOG_DEBUG(("Add new server entry (INFO)"));
1003     server = silc_client_add_server(client, conn, server_name,
1004                                     server_info, &id.u.server_id);
1005     if (!server)
1006       goto out;
1007     silc_client_ref_server(client, conn, server);
1008   }
1009
1010   /* Notify application */
1011   silc_client_command_callback(cmd, server, server->server_name,
1012                                server->server_info);
1013   silc_client_unref_server(client, conn, server);
1014
1015  out:
1016   silc_fsm_next(fsm, silc_client_command_reply_processed);
1017   return SILC_FSM_CONTINUE;
1018 }
1019
1020 /********************************** STATS ***********************************/
1021
1022 /* Received reply to STATS command. */
1023
1024 SILC_FSM_STATE(silc_client_command_reply_stats)
1025 {
1026   SilcClientCommandContext cmd = fsm_context;
1027   SilcCommandPayload payload = state_context;
1028   SilcArgumentPayload args = silc_command_get_args(payload);
1029   SilcClientStats stats;
1030   unsigned char *buf = NULL;
1031   SilcUInt32 buf_len = 0;
1032   SilcBufferStruct b;
1033   SilcID id;
1034
1035   /* Sanity checks */
1036   CHECK_STATUS("Cannot get stats: ");
1037   CHECK_ARGS(2, 3);
1038
1039   /* Get server ID */
1040   if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL)) {
1041     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1042     goto out;
1043   }
1044
1045   /* Get statistics structure */
1046   memset(&stats, 0, sizeof(stats));
1047   buf = silc_argument_get_arg_type(args, 3, &buf_len);
1048   if (buf) {
1049     silc_buffer_set(&b, buf, buf_len);
1050     silc_buffer_unformat(&b,
1051                          SILC_STR_UI_INT(&stats.starttime),
1052                          SILC_STR_UI_INT(&stats.uptime),
1053                          SILC_STR_UI_INT(&stats.my_clients),
1054                          SILC_STR_UI_INT(&stats.my_channels),
1055                          SILC_STR_UI_INT(&stats.my_server_ops),
1056                          SILC_STR_UI_INT(&stats.my_router_ops),
1057                          SILC_STR_UI_INT(&stats.cell_clients),
1058                          SILC_STR_UI_INT(&stats.cell_channels),
1059                          SILC_STR_UI_INT(&stats.cell_servers),
1060                          SILC_STR_UI_INT(&stats.clients),
1061                          SILC_STR_UI_INT(&stats.channels),
1062                          SILC_STR_UI_INT(&stats.servers),
1063                          SILC_STR_UI_INT(&stats.routers),
1064                          SILC_STR_UI_INT(&stats.server_ops),
1065                          SILC_STR_UI_INT(&stats.router_ops),
1066                          SILC_STR_END);
1067   }
1068
1069   /* Notify application */
1070   silc_client_command_callback(cmd, &stats);
1071
1072  out:
1073   silc_fsm_next(fsm, silc_client_command_reply_processed);
1074   return SILC_FSM_CONTINUE;
1075 }
1076
1077 /********************************** PING ************************************/
1078
1079 /* Received reply to PING command. */
1080
1081 SILC_FSM_STATE(silc_client_command_reply_ping)
1082 {
1083   SilcClientCommandContext cmd = fsm_context;
1084   SilcClientConnection conn = cmd->conn;
1085   SilcClient client = conn->client;
1086   SilcInt64 diff;
1087
1088   diff = silc_time() - SILC_PTR_TO_64(cmd->context);
1089   if (cmd->verbose)
1090     SAY(client, conn, SILC_CLIENT_MESSAGE_INFO,
1091         "Ping reply from %s: %d second%s", conn->remote_host,
1092         (int)diff, diff == 1 ? "" : "s");
1093
1094   /* Notify application */
1095   silc_client_command_callback(cmd);
1096
1097   silc_fsm_next(fsm, silc_client_command_reply_processed);
1098   return SILC_FSM_CONTINUE;
1099 }
1100
1101 /********************************** JOIN ************************************/
1102
1103 /* Continue JOIN command reply processing after resolving unknown users */
1104
1105 static void
1106 silc_client_command_reply_join_resolved(SilcClient client,
1107                                         SilcClientConnection conn,
1108                                         SilcStatus status,
1109                                         SilcDList clients,
1110                                         void *context)
1111 {
1112   SilcClientCommandContext cmd = context;
1113   SilcChannelEntry channel = cmd->context;
1114
1115   channel->internal.resolve_cmd_ident = 0;
1116   silc_client_unref_channel(client, conn, channel);
1117
1118   SILC_FSM_CALL_CONTINUE(&cmd->thread);
1119 }
1120
1121
1122 /* Received reply for JOIN command. */
1123
1124 SILC_FSM_STATE(silc_client_command_reply_join)
1125 {
1126   SilcClientCommandContext cmd = fsm_context;
1127   SilcClientConnection conn = cmd->conn;
1128   SilcClient client = conn->client;
1129   SilcCommandPayload payload = state_context;
1130   SilcArgumentPayload args = silc_command_get_args(payload);
1131   SilcChannelEntry channel;
1132   SilcUInt32 mode = 0, len, list_count;
1133   char *topic, *tmp, *channel_name = NULL, *hmac;
1134   const char *cipher;
1135   SilcBufferStruct client_id_list, client_mode_list, keyp;
1136   SilcHashTableList htl;
1137   SilcID id;
1138   int i;
1139
1140   /* Sanity checks */
1141   CHECK_STATUS("Cannot join channel: ");
1142   CHECK_ARGS(9, 17);
1143
1144   /* Get channel name */
1145   channel_name = silc_argument_get_arg_type(args, 2, NULL);
1146   if (!channel_name) {
1147     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1148     goto out;
1149   }
1150
1151   /* Get Channel ID */
1152   if (!silc_argument_get_decoded(args, 3, SILC_ARGUMENT_ID, &id, NULL)) {
1153     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1154     goto out;
1155   }
1156
1157   /* Check whether we have this channel entry already. */
1158   channel = silc_client_get_channel(client, conn, channel_name);
1159   if (channel) {
1160     if (!SILC_ID_CHANNEL_COMPARE(&channel->id, &id.u.channel_id))
1161       silc_client_replace_channel_id(client, conn, channel, &id.u.channel_id);
1162   } else {
1163     /* Create new channel entry */
1164     channel = silc_client_add_channel(client, conn, channel_name,
1165                                       mode, &id.u.channel_id);
1166     if (!channel) {
1167       ERROR_CALLBACK(SILC_STATUS_ERR_BAD_CHANNEL);
1168       goto out;
1169     }
1170     silc_client_ref_channel(client, conn, channel);
1171   }
1172
1173   /* Get the list count */
1174   tmp = silc_argument_get_arg_type(args, 12, &len);
1175   if (!tmp) {
1176     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1177     goto out;
1178   }
1179   SILC_GET32_MSB(list_count, tmp);
1180
1181   /* Get Client ID list */
1182   tmp = silc_argument_get_arg_type(args, 13, &len);
1183   if (!tmp) {
1184     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1185     goto out;
1186   }
1187   silc_buffer_set(&client_id_list, tmp, len);
1188
1189   /* Resolve users we do not know about */
1190   if (!cmd->resolved) {
1191     cmd->resolved = TRUE;
1192     cmd->context = channel;
1193     SILC_FSM_CALL(channel->internal.resolve_cmd_ident =
1194                   silc_client_get_clients_by_list(
1195                           client, conn, list_count, &client_id_list,
1196                           silc_client_command_reply_join_resolved, cmd));
1197     /* NOT REACHED */
1198   }
1199
1200   /* Get client mode list */
1201   tmp = silc_argument_get_arg_type(args, 14, &len);
1202   if (!tmp) {
1203     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1204     goto out;
1205   }
1206   silc_buffer_set(&client_mode_list, tmp, len);
1207
1208   silc_rwlock_wrlock(channel->internal.lock);
1209
1210   /* Add clients we received in the reply to the channel */
1211   for (i = 0; i < list_count; i++) {
1212     SilcUInt16 idp_len;
1213     SilcUInt32 mode;
1214     SilcID id;
1215     SilcClientEntry client_entry;
1216
1217     /* Client ID */
1218     SILC_GET16_MSB(idp_len, client_id_list.data + 2);
1219     idp_len += 4;
1220     if (!silc_id_payload_parse_id(client_id_list.data, idp_len, &id))
1221       continue;
1222
1223     /* Mode */
1224     SILC_GET32_MSB(mode, client_mode_list.data);
1225
1226     /* Get client entry */
1227     client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
1228     if (client_entry && client_entry->internal.valid) {
1229       /* Join client to the channel */
1230       silc_rwlock_wrlock(client_entry->internal.lock);
1231       silc_client_add_to_channel(client, conn, channel, client_entry, mode);
1232       silc_rwlock_unlock(client_entry->internal.lock);
1233     }
1234     silc_client_unref_client(client, conn, client_entry);
1235
1236     if (!silc_buffer_pull(&client_id_list, idp_len)) {
1237       silc_rwlock_unlock(channel->internal.lock);
1238       goto out;
1239     }
1240     if (!silc_buffer_pull(&client_mode_list, 4)) {
1241       silc_rwlock_unlock(channel->internal.lock);
1242       goto out;
1243     }
1244   }
1245
1246   /* Get hmac */
1247   hmac = silc_argument_get_arg_type(args, 11, NULL);
1248   if (hmac) {
1249     if (!silc_hmac_alloc(hmac, NULL, &channel->internal.hmac)) {
1250       if (cmd->verbose)
1251         SAY(client, conn, SILC_CLIENT_MESSAGE_COMMAND_ERROR,
1252             "Cannot join channel: Unsupported HMAC `%s'", hmac);
1253       ERROR_CALLBACK(SILC_STATUS_ERR_UNKNOWN_ALGORITHM);
1254       silc_rwlock_unlock(channel->internal.lock);
1255       goto out;
1256     }
1257   }
1258
1259   /* Get channel mode */
1260   tmp = silc_argument_get_arg_type(args, 5, &len);
1261   if (tmp && len == 4)
1262     SILC_GET32_MSB(mode, tmp);
1263   channel->mode = mode;
1264
1265   /* Get channel key and save it */
1266   tmp = silc_argument_get_arg_type(args, 7, &len);
1267   if (tmp) {
1268     silc_buffer_set(&keyp, tmp, len);
1269     silc_client_save_channel_key(client, conn, &keyp, channel);
1270   }
1271
1272   /* Get topic */
1273   topic = silc_argument_get_arg_type(args, 10, NULL);
1274   if (topic) {
1275     silc_free(channel->topic);
1276     channel->topic = silc_memdup(topic, strlen(topic));
1277   }
1278
1279   /* Get founder key */
1280   tmp = silc_argument_get_arg_type(args, 15, &len);
1281   if (tmp) {
1282     if (channel->founder_key)
1283       silc_pkcs_public_key_free(channel->founder_key);
1284     channel->founder_key = NULL;
1285     silc_public_key_payload_decode(tmp, len, &channel->founder_key);
1286   }
1287
1288   /* Get user limit */
1289   tmp = silc_argument_get_arg_type(args, 17, &len);
1290   if (tmp && len == 4)
1291     SILC_GET32_MSB(channel->user_limit, tmp);
1292   if (!(channel->mode & SILC_CHANNEL_MODE_ULIMIT))
1293     channel->user_limit = 0;
1294
1295   /* Get channel public key list */
1296   tmp = silc_argument_get_arg_type(args, 16, &len);
1297   if (tmp)
1298     silc_client_channel_save_public_keys(channel, tmp, len, FALSE);
1299
1300   /* Set current channel */
1301   conn->current_channel = channel;
1302
1303   silc_rwlock_unlock(channel->internal.lock);
1304
1305   cipher = (channel->internal.send_key ?
1306             silc_cipher_get_name(channel->internal.send_key) : NULL);
1307   silc_hash_table_list(channel->user_list, &htl);
1308
1309   /* Notify application */
1310   silc_client_command_callback(cmd, channel->channel_name, channel, mode, &htl,
1311                                topic, cipher, hmac, channel->founder_key,
1312                                channel->channel_pubkeys, channel->user_limit);
1313
1314   silc_hash_table_list_reset(&htl);
1315   silc_client_unref_channel(client, conn, channel);
1316
1317  out:
1318   silc_fsm_next(fsm, silc_client_command_reply_processed);
1319   return SILC_FSM_CONTINUE;
1320 }
1321
1322 /********************************** MOTD ************************************/
1323
1324 /* Received reply for MOTD command */
1325
1326 SILC_FSM_STATE(silc_client_command_reply_motd)
1327 {
1328   SilcClientCommandContext cmd = fsm_context;
1329   SilcClientConnection conn = cmd->conn;
1330   SilcClient client = conn->client;
1331   SilcCommandPayload payload = state_context;
1332   SilcArgumentPayload args = silc_command_get_args(payload);
1333   SilcUInt32 i;
1334   char *motd = NULL, *cp, line[256];
1335
1336   /* Sanity checks */
1337   CHECK_STATUS("Cannot get motd: ");
1338   CHECK_ARGS(2, 3);
1339
1340   if (silc_argument_get_arg_num(args) == 3) {
1341     motd = silc_argument_get_arg_type(args, 3, NULL);
1342     if (!motd) {
1343       ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1344       goto out;
1345     }
1346
1347     i = 0;
1348     cp = motd;
1349     while(cp[i] != 0) {
1350       if (cp[i++] == '\n') {
1351         memset(line, 0, sizeof(line));
1352         silc_strncat(line, sizeof(line), cp, i - 1);
1353         cp += i;
1354
1355         if (i == 2)
1356           line[0] = ' ';
1357
1358         if (cmd->verbose)
1359           SAY(client, conn, SILC_CLIENT_MESSAGE_INFO, "%s", line);
1360
1361         if (!strlen(cp))
1362           break;
1363         i = 0;
1364       }
1365     }
1366   }
1367
1368   /* Notify application */
1369   silc_client_command_callback(cmd, motd);
1370
1371  out:
1372   silc_fsm_next(fsm, silc_client_command_reply_processed);
1373   return SILC_FSM_CONTINUE;
1374 }
1375
1376 /********************************** UMODE ***********************************/
1377
1378 /* Received reply to the UMODE command. Save the current user mode */
1379
1380 SILC_FSM_STATE(silc_client_command_reply_umode)
1381 {
1382   SilcClientCommandContext cmd = fsm_context;
1383   SilcClientConnection conn = cmd->conn;
1384   SilcCommandPayload payload = state_context;
1385   SilcArgumentPayload args = silc_command_get_args(payload);
1386   unsigned char *tmp;
1387   SilcUInt32 mode, len;
1388
1389   /* Sanity checks */
1390   CHECK_STATUS("Cannot change mode: ");
1391   CHECK_ARGS(2, 2);
1392
1393   tmp = silc_argument_get_arg_type(args, 2, &len);
1394   if (!tmp || len != 4) {
1395     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1396     goto out;
1397   }
1398
1399   SILC_GET32_MSB(mode, tmp);
1400   silc_rwlock_wrlock(conn->local_entry->internal.lock);
1401   conn->local_entry->mode = mode;
1402   silc_rwlock_unlock(conn->local_entry->internal.lock);
1403
1404   /* Notify application */
1405   silc_client_command_callback(cmd, mode);
1406
1407  out:
1408   silc_fsm_next(fsm, silc_client_command_reply_processed);
1409   return SILC_FSM_CONTINUE;
1410 }
1411
1412 /********************************** CMODE ***********************************/
1413
1414 /* Received reply for CMODE command. */
1415
1416 SILC_FSM_STATE(silc_client_command_reply_cmode)
1417 {
1418   SilcClientCommandContext cmd = fsm_context;
1419   SilcClientConnection conn = cmd->conn;
1420   SilcClient client = conn->client;
1421   SilcCommandPayload payload = state_context;
1422   SilcArgumentPayload args = silc_command_get_args(payload);
1423   unsigned char *tmp;
1424   SilcUInt32 mode;
1425   SilcChannelEntry channel = NULL;
1426   SilcUInt32 len;
1427   SilcPublicKey public_key = NULL;
1428   SilcID id;
1429
1430   /* Sanity checks */
1431   CHECK_STATUS("Cannot change mode: ");
1432   CHECK_ARGS(3, 6);
1433
1434   /* Take Channel ID */
1435   if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL)) {
1436     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1437     goto out;
1438   }
1439
1440   /* Get the channel entry */
1441   channel = silc_client_get_channel_by_id(client, conn, &id.u.channel_id);
1442   if (!channel) {
1443     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1444     goto out;
1445   }
1446
1447   /* Get founder public key */
1448   tmp = silc_argument_get_arg_type(args, 4, &len);
1449   if (tmp)
1450     silc_public_key_payload_decode(tmp, len, &public_key);
1451
1452   /* Get channel mode */
1453   tmp = silc_argument_get_arg_type(args, 3, &len);
1454   if (!tmp || len != 4) {
1455     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1456     goto out;
1457   }
1458   SILC_GET32_MSB(mode, tmp);
1459
1460   silc_rwlock_wrlock(channel->internal.lock);
1461
1462   /* Get user limit */
1463   tmp = silc_argument_get_arg_type(args, 6, &len);
1464   if (tmp && len == 4)
1465     SILC_GET32_MSB(channel->user_limit, tmp);
1466   if (!(channel->mode & SILC_CHANNEL_MODE_ULIMIT))
1467     channel->user_limit = 0;
1468
1469   /* Get channel public key(s) */
1470   tmp = silc_argument_get_arg_type(args, 5, &len);
1471   if (tmp)
1472     silc_client_channel_save_public_keys(channel, tmp, len, FALSE);
1473   else if (channel->mode & SILC_CHANNEL_MODE_CHANNEL_AUTH)
1474     silc_client_channel_save_public_keys(channel, NULL, 0, TRUE);
1475
1476   /* Save the mode */
1477   channel->mode = mode;
1478
1479   silc_rwlock_unlock(channel->internal.lock);
1480
1481   /* Notify application */
1482   silc_client_command_callback(cmd, channel, mode, public_key,
1483                                channel->channel_pubkeys, channel->user_limit);
1484
1485  out:
1486   silc_client_unref_channel(client, conn, channel);
1487   if (public_key)
1488     silc_pkcs_public_key_free(public_key);
1489   silc_fsm_next(fsm, silc_client_command_reply_processed);
1490   return SILC_FSM_CONTINUE;
1491 }
1492
1493 /********************************** CUMODE **********************************/
1494
1495 /* Received reply for CUMODE command */
1496
1497 SILC_FSM_STATE(silc_client_command_reply_cumode)
1498 {
1499   SilcClientCommandContext cmd = fsm_context;
1500   SilcClientConnection conn = cmd->conn;
1501   SilcClient client = conn->client;
1502   SilcCommandPayload payload = state_context;
1503   SilcArgumentPayload args = silc_command_get_args(payload);
1504   SilcClientEntry client_entry;
1505   SilcChannelEntry channel = NULL;
1506   SilcChannelUser chu;
1507   unsigned char *modev;
1508   SilcUInt32 len, mode;
1509   SilcID id;
1510
1511   /* Sanity checks */
1512   CHECK_STATUS("Cannot change mode: ");
1513   CHECK_ARGS(4, 4);
1514
1515   /* Get channel mode */
1516   modev = silc_argument_get_arg_type(args, 2, &len);
1517   if (!modev || len != 4) {
1518     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1519     goto out;
1520   }
1521   SILC_GET32_MSB(mode, modev);
1522
1523   /* Take Channel ID */
1524   if (!silc_argument_get_decoded(args, 3, SILC_ARGUMENT_ID, &id, NULL)) {
1525     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1526     goto out;
1527   }
1528
1529   /* Get the channel entry */
1530   channel = silc_client_get_channel_by_id(client, conn, &id.u.channel_id);
1531   if (!channel) {
1532     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1533     goto out;
1534   }
1535
1536   /* Get Client ID */
1537   if (!silc_argument_get_decoded(args, 4, SILC_ARGUMENT_ID, &id, NULL)) {
1538     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1539     goto out;
1540   }
1541
1542   /* Get client entry */
1543   client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
1544   if (!client_entry) {
1545     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1546     goto out;
1547   }
1548
1549   /* Save the mode */
1550   silc_rwlock_wrlock(channel->internal.lock);
1551   chu = silc_client_on_channel(channel, client_entry);
1552   if (chu)
1553     chu->mode = mode;
1554   silc_rwlock_unlock(channel->internal.lock);
1555
1556   /* Notify application */
1557   silc_client_command_callback(cmd, mode, channel, client_entry);
1558
1559   silc_client_unref_client(client, conn, client_entry);
1560
1561  out:
1562   silc_client_unref_channel(client, conn, channel);
1563   silc_fsm_next(fsm, silc_client_command_reply_processed);
1564   return SILC_FSM_CONTINUE;
1565 }
1566
1567 /********************************** KICK ************************************/
1568
1569 SILC_FSM_STATE(silc_client_command_reply_kick)
1570 {
1571   SilcClientCommandContext cmd = fsm_context;
1572   SilcClientConnection conn = cmd->conn;
1573   SilcClient client = conn->client;
1574   SilcCommandPayload payload = state_context;
1575   SilcArgumentPayload args = silc_command_get_args(payload);
1576   SilcClientEntry client_entry;
1577   SilcChannelEntry channel = NULL;
1578   SilcID id;
1579
1580   /* Sanity checks */
1581   CHECK_STATUS("Cannot kick: ");
1582   CHECK_ARGS(3, 3);
1583
1584   /* Take Channel ID */
1585   if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL)) {
1586     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1587     goto out;
1588   }
1589
1590   /* Get the channel entry */
1591   channel = silc_client_get_channel_by_id(client, conn, &id.u.channel_id);
1592   if (!channel) {
1593     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1594     goto out;
1595   }
1596
1597   /* Get Client ID */
1598   if (!silc_argument_get_decoded(args, 3, SILC_ARGUMENT_ID, &id, NULL)) {
1599     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1600     goto out;
1601   }
1602
1603   /* Get client entry */
1604   client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
1605   if (!client_entry) {
1606     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1607     goto out;
1608   }
1609
1610   /* Notify application */
1611   silc_client_command_callback(cmd, channel, client_entry);
1612
1613   silc_client_unref_client(client, conn, client_entry);
1614
1615  out:
1616   silc_client_unref_channel(client, conn, channel);
1617   silc_fsm_next(fsm, silc_client_command_reply_processed);
1618   return SILC_FSM_CONTINUE;
1619 }
1620
1621 /******************************** SILCOPER **********************************/
1622
1623 SILC_FSM_STATE(silc_client_command_reply_silcoper)
1624 {
1625   SilcClientCommandContext cmd = fsm_context;
1626   SilcCommandPayload payload = state_context;
1627   SilcArgumentPayload args = silc_command_get_args(payload);
1628
1629   /* Sanity checks */
1630   CHECK_STATUS("Cannot change mode: ");
1631   CHECK_ARGS(1, 1);
1632
1633   /* Set user mode */
1634   cmd->conn->local_entry->mode |= SILC_UMODE_ROUTER_OPERATOR;
1635
1636   /* Notify application */
1637   silc_client_command_callback(cmd);
1638
1639   silc_fsm_next(fsm, silc_client_command_reply_processed);
1640   return SILC_FSM_CONTINUE;
1641 }
1642
1643 /********************************** OPER ************************************/
1644
1645 SILC_FSM_STATE(silc_client_command_reply_oper)
1646 {
1647   SilcClientCommandContext cmd = fsm_context;
1648   SilcCommandPayload payload = state_context;
1649   SilcArgumentPayload args = silc_command_get_args(payload);
1650
1651   /* Sanity checks */
1652   CHECK_STATUS("Cannot change mode: ");
1653   CHECK_ARGS(1, 1);
1654
1655   /* Set user mode */
1656   cmd->conn->local_entry->mode |= SILC_UMODE_SERVER_OPERATOR;
1657
1658   /* Notify application */
1659   silc_client_command_callback(cmd);
1660
1661   silc_fsm_next(fsm, silc_client_command_reply_processed);
1662   return SILC_FSM_CONTINUE;
1663 }
1664
1665 /********************************* DETACH ***********************************/
1666
1667 SILC_FSM_STATE(silc_client_command_reply_detach)
1668 {
1669   SilcClientCommandContext cmd = fsm_context;
1670   SilcClientConnection conn = cmd->conn;
1671   SilcClient client = conn->client;
1672   SilcCommandPayload payload = state_context;
1673   SilcArgumentPayload args = silc_command_get_args(payload);
1674   SilcBuffer detach;
1675
1676   /* Sanity checks */
1677   CHECK_STATUS("Cannot detach: ");
1678   CHECK_ARGS(1, 1);
1679
1680   /* Get detachment data */
1681   detach = silc_client_get_detach_data(client, conn);
1682   if (!detach) {
1683     ERROR_CALLBACK(SILC_STATUS_ERR_RESOURCE_LIMIT);
1684     goto out;
1685   }
1686
1687   /* Notify application */
1688   silc_client_command_callback(cmd, detach);
1689   silc_buffer_free(detach);
1690
1691  out:
1692   silc_fsm_next(fsm, silc_client_command_reply_processed);
1693   return SILC_FSM_CONTINUE;
1694 }
1695
1696 /********************************** WATCH ***********************************/
1697
1698 SILC_FSM_STATE(silc_client_command_reply_watch)
1699 {
1700   SilcClientCommandContext cmd = fsm_context;
1701   SilcCommandPayload payload = state_context;
1702   SilcArgumentPayload args = silc_command_get_args(payload);
1703
1704   /* Sanity checks */
1705   CHECK_STATUS("Cannot set watch: ");
1706   CHECK_ARGS(1, 1);
1707
1708   /* Notify application */
1709   silc_client_command_callback(cmd);
1710
1711   silc_fsm_next(fsm, silc_client_command_reply_processed);
1712   return SILC_FSM_CONTINUE;
1713 }
1714
1715 /*********************************** BAN ************************************/
1716
1717 SILC_FSM_STATE(silc_client_command_reply_ban)
1718 {
1719   SilcClientCommandContext cmd = fsm_context;
1720   SilcClientConnection conn = cmd->conn;
1721   SilcClient client = conn->client;
1722   SilcCommandPayload payload = state_context;
1723   SilcArgumentPayload args = silc_command_get_args(payload);
1724   SilcChannelEntry channel = NULL;
1725   unsigned char *tmp;
1726   SilcUInt32 len;
1727   SilcArgumentPayload invite_args = NULL;
1728   SilcID id;
1729
1730   /* Sanity checks */
1731   CHECK_STATUS("Cannot set ban: ");
1732   CHECK_ARGS(2, 3);
1733
1734   /* Take Channel ID */
1735   if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL)) {
1736     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1737     goto out;
1738   }
1739
1740   /* Get the channel entry */
1741   channel = silc_client_get_channel_by_id(client, conn, &id.u.channel_id);
1742   if (!channel) {
1743     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1744     goto out;
1745   }
1746
1747   /* Get the invite list */
1748   tmp = silc_argument_get_arg_type(args, 3, &len);
1749   if (tmp)
1750     invite_args = silc_argument_list_parse(tmp, len);
1751
1752   /* Notify application */
1753   silc_client_command_callback(cmd, channel, invite_args);
1754
1755   if (invite_args)
1756     silc_argument_payload_free(invite_args);
1757
1758  out:
1759   silc_client_unref_channel(client, conn, channel);
1760   silc_fsm_next(fsm, silc_client_command_reply_processed);
1761   return SILC_FSM_CONTINUE;
1762 }
1763
1764 /********************************** LEAVE ***********************************/
1765
1766 /* Reply to LEAVE command. */
1767
1768 SILC_FSM_STATE(silc_client_command_reply_leave)
1769 {
1770   SilcClientCommandContext cmd = fsm_context;
1771   SilcClientConnection conn = cmd->conn;
1772   SilcClient client = conn->client;
1773   SilcCommandPayload payload = state_context;
1774   SilcArgumentPayload args = silc_command_get_args(payload);
1775   SilcChannelEntry channel;
1776   SilcID id;
1777
1778   /* Sanity checks */
1779   CHECK_STATUS("Cannot set leave: ");
1780   CHECK_ARGS(2, 2);
1781
1782   /* Get Channel ID */
1783   if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL)) {
1784     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1785     goto out;
1786   }
1787
1788   /* Get the channel entry */
1789   channel = silc_client_get_channel_by_id(client, conn, &id.u.channel_id);
1790   if (!channel) {
1791     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1792     goto out;
1793   }
1794
1795   /* Remove us from this channel. */
1796   silc_client_remove_from_channel(client, conn, channel, conn->local_entry);
1797
1798   /* Notify application */
1799   silc_client_command_callback(cmd, channel);
1800
1801   /* Now delete the channel. */
1802   silc_client_empty_channel(client, conn, channel);
1803   silc_client_del_channel(client, conn, channel);
1804
1805  out:
1806   silc_fsm_next(fsm, silc_client_command_reply_processed);
1807   return SILC_FSM_CONTINUE;
1808 }
1809
1810 /********************************* USERS ************************************/
1811
1812 /* Continue USERS command reply processing after resolving unknown users */
1813
1814 static void
1815 silc_client_command_reply_users_resolved(SilcClient client,
1816                                          SilcClientConnection conn,
1817                                          SilcStatus status,
1818                                          SilcDList clients,
1819                                          void *context)
1820 {
1821   SilcClientCommandContext cmd = context;
1822   SILC_FSM_CALL_CONTINUE(&cmd->thread);
1823 }
1824
1825
1826 /* Continue USERS command after resolving unknown channel */
1827
1828 static void
1829 silc_client_command_reply_users_continue(SilcClient client,
1830                                          SilcClientConnection conn,
1831                                          SilcStatus status,
1832                                          SilcDList channels,
1833                                          void *context)
1834 {
1835   SilcClientCommandContext cmd = context;
1836
1837   if (!channels) {
1838     SilcCommandPayload payload = silc_fsm_get_state_context(&cmd->thread);
1839     SilcArgumentPayload args = silc_command_get_args(payload);
1840
1841     cmd->status = SILC_STATUS_ERR_NO_SUCH_CHANNEL_ID;
1842     ERROR_CALLBACK(cmd->status);
1843     silc_fsm_next(&cmd->thread, silc_client_command_reply_processed);
1844   }
1845
1846   SILC_FSM_CALL_CONTINUE(&cmd->thread);
1847 }
1848
1849 /* Reply to USERS command. Received list of client ID's and theirs modes
1850    on the channel we requested. */
1851
1852 SILC_FSM_STATE(silc_client_command_reply_users)
1853 {
1854   SilcClientCommandContext cmd = fsm_context;
1855   SilcClientConnection conn = cmd->conn;
1856   SilcClient client = conn->client;
1857   SilcCommandPayload payload = state_context;
1858   SilcArgumentPayload args = silc_command_get_args(payload);
1859   unsigned char *tmp;
1860   SilcUInt32 tmp_len, list_count, mode;
1861   SilcUInt16 idp_len;
1862   SilcHashTableList htl;
1863   SilcBufferStruct client_id_list, client_mode_list;
1864   SilcChannelEntry channel = NULL;
1865   SilcClientEntry client_entry;
1866   SilcID id;
1867   int i;
1868
1869   /* Sanity checks */
1870   CHECK_STATUS("Cannot get users: ");
1871   CHECK_ARGS(5, 5);
1872
1873   /* Get channel ID */
1874   if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL)) {
1875     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1876     goto out;
1877   }
1878
1879   /* Get channel entry */
1880   channel = silc_client_get_channel_by_id(client, conn, &id.u.channel_id);
1881   if (!channel) {
1882     /* Resolve the channel from server */
1883     SILC_FSM_CALL(silc_client_get_channel_by_id_resolve(
1884                         client, conn, &id.u.channel_id,
1885                         silc_client_command_reply_users_continue, cmd));
1886     /* NOT REACHED */
1887   }
1888
1889   /* Get the list count */
1890   tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1891   if (!tmp || tmp_len != 4) {
1892     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1893     goto out;
1894   }
1895   SILC_GET32_MSB(list_count, tmp);
1896
1897   /* Get Client ID list */
1898   tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
1899   if (!tmp) {
1900     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1901     goto out;
1902   }
1903   silc_buffer_set(&client_id_list, tmp, tmp_len);
1904
1905   /* Resolve users we do not know about */
1906   if (!cmd->resolved) {
1907     cmd->resolved = TRUE;
1908     silc_client_unref_channel(client, conn, channel);
1909     SILC_FSM_CALL(silc_client_get_clients_by_list(
1910                           client, conn, list_count, &client_id_list,
1911                           silc_client_command_reply_users_resolved, cmd));
1912     /* NOT REACHED */
1913   }
1914
1915   /* Get client mode list */
1916   tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
1917   if (!tmp) {
1918     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1919     goto out;
1920   }
1921   silc_buffer_set(&client_mode_list, tmp, tmp_len);
1922
1923   SILC_LOG_DEBUG(("channel %s, %d users", channel->channel_name, list_count));
1924
1925   silc_rwlock_wrlock(channel->internal.lock);
1926
1927   /* Cache the received Client ID's and modes. */
1928   for (i = 0; i < list_count; i++) {
1929     SILC_GET16_MSB(idp_len, client_id_list.data + 2);
1930     idp_len += 4;
1931     if (!silc_id_payload_parse_id(client_id_list.data, idp_len, &id))
1932       goto out;
1933
1934     /* Mode */
1935     SILC_GET32_MSB(mode, client_mode_list.data);
1936
1937     /* Save the client on this channel.  Unknown clients are ignored as they
1938        clearly do not exist since the resolving didn't find them. */
1939     client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
1940     if (client_entry && client_entry->internal.valid) {
1941       silc_rwlock_wrlock(client_entry->internal.lock);
1942       silc_client_add_to_channel(client, conn, channel, client_entry, mode);
1943       silc_rwlock_unlock(client_entry->internal.lock);
1944     }
1945     silc_client_unref_client(client, conn, client_entry);
1946
1947     if (!silc_buffer_pull(&client_id_list, idp_len)) {
1948       silc_rwlock_unlock(channel->internal.lock);
1949       goto out;
1950     }
1951     if (!silc_buffer_pull(&client_mode_list, 4)) {
1952       silc_rwlock_unlock(channel->internal.lock);
1953       goto out;
1954     }
1955   }
1956
1957   silc_rwlock_unlock(channel->internal.lock);
1958
1959   /* Notify application */
1960   silc_hash_table_list(channel->user_list, &htl);
1961   silc_client_command_callback(cmd, channel, &htl);
1962   silc_hash_table_list_reset(&htl);
1963
1964  out:
1965   silc_client_unref_channel(client, conn, channel);
1966   silc_fsm_next(fsm, silc_client_command_reply_processed);
1967   return SILC_FSM_CONTINUE;
1968 }
1969
1970 /********************************** GETKEY **********************************/
1971
1972 /* Received command reply to GETKEY command. WE've received the remote
1973    client's public key. */
1974
1975 SILC_FSM_STATE(silc_client_command_reply_getkey)
1976 {
1977   SilcClientCommandContext cmd = fsm_context;
1978   SilcClientConnection conn = cmd->conn;
1979   SilcClient client = conn->client;
1980   SilcCommandPayload payload = state_context;
1981   SilcArgumentPayload args = silc_command_get_args(payload);
1982   SilcClientEntry client_entry;
1983   SilcServerEntry server_entry;
1984   unsigned char *tmp;
1985   SilcUInt32 len;
1986   SilcPublicKey public_key;
1987   SilcID id;
1988
1989   /* Sanity checks */
1990   CHECK_STATUS("Cannot get key: ");
1991   CHECK_ARGS(2, 3);
1992
1993   /* Get the ID */
1994   if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL)) {
1995     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
1996     goto out;
1997   }
1998
1999   /* Get the public key */
2000   tmp = silc_argument_get_arg_type(args, 3, &len);
2001   if (!tmp) {
2002     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
2003     goto out;
2004   }
2005   if (!silc_public_key_payload_decode(tmp, len, &public_key)) {
2006     SAY(client, conn, SILC_CLIENT_MESSAGE_COMMAND_ERROR,
2007         "Cannot decode public key: malformed/unsupported public key");
2008     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
2009     goto out;
2010   }
2011
2012   if (id.type == SILC_ID_CLIENT) {
2013     /* Received client's public key */
2014     client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
2015     if (!client_entry) {
2016       ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
2017       goto out;
2018     }
2019
2020     silc_rwlock_wrlock(client_entry->internal.lock);
2021
2022     /* Save fingerprint */
2023     if (!client_entry->fingerprint)
2024       silc_hash_make(conn->internal->sha1hash, tmp + 4, len - 4,
2025                      client_entry->fingerprint);
2026     if (!client_entry->public_key) {
2027       client_entry->public_key = public_key;
2028       public_key = NULL;
2029     }
2030
2031     silc_rwlock_unlock(client_entry->internal.lock);
2032
2033     /* Notify application */
2034     silc_client_command_callback(cmd, SILC_ID_CLIENT, client_entry,
2035                                  client_entry->public_key);
2036     silc_client_unref_client(client, conn, client_entry);
2037   } else if (id.type == SILC_ID_SERVER) {
2038     /* Received server's public key */
2039     server_entry = silc_client_get_server_by_id(client, conn, &id.u.server_id);
2040     if (!server_entry) {
2041       ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
2042       goto out;
2043     }
2044
2045     silc_rwlock_wrlock(server_entry->internal.lock);
2046
2047     if (!server_entry->public_key) {
2048       server_entry->public_key = public_key;
2049       public_key = NULL;
2050     }
2051
2052     silc_rwlock_unlock(server_entry->internal.lock);
2053
2054     /* Notify application */
2055     silc_client_command_callback(cmd, SILC_ID_SERVER, server_entry,
2056                                  server_entry->public_key);
2057     silc_client_unref_server(client, conn, server_entry);
2058   }
2059
2060  out:
2061   if (public_key)
2062     silc_pkcs_public_key_free(public_key);
2063   silc_fsm_next(fsm, silc_client_command_reply_processed);
2064   return SILC_FSM_CONTINUE;
2065 }
2066
2067 /********************************** SERVICE *********************************/
2068
2069 /* Reply to SERVICE command. */
2070 /* XXX incomplete */
2071
2072 SILC_FSM_STATE(silc_client_command_reply_service)
2073 {
2074   SilcClientCommandContext cmd = fsm_context;
2075   SilcCommandPayload payload = state_context;
2076   SilcArgumentPayload args = silc_command_get_args(payload);
2077   SilcUInt32 tmp_len;
2078   unsigned char *service_list, *name;
2079
2080   /* Sanity checks */
2081   CHECK_STATUS("Cannot get service: ");
2082
2083   /* Get service list */
2084   service_list = silc_argument_get_arg_type(args, 2, &tmp_len);
2085
2086   /* Get requested service name */
2087   name = silc_argument_get_arg_type(args, 3, &tmp_len);
2088
2089   /* Notify application */
2090   silc_client_command_callback(cmd, service_list, name);
2091
2092   silc_fsm_next(fsm, silc_client_command_reply_processed);
2093   return SILC_FSM_CONTINUE;
2094 }
2095
2096 /*********************************** QUIT ***********************************/
2097
2098 /* QUIT command reply stub */
2099
2100 SILC_FSM_STATE(silc_client_command_reply_quit)
2101 {
2102   silc_fsm_next(fsm, silc_client_command_reply_processed);
2103   return SILC_FSM_CONTINUE;
2104 }