X-Git-Url: http://git.silcnet.org/gitweb/?p=silc.git;a=blobdiff_plain;f=lib%2Fsilcclient%2Fcommand_reply.c;h=9a8b9fe6b1b82837e610accd5193b05a7737af4c;hp=c026a869182080503136569630e17f8d350278b1;hb=e5d8d3db6caa344b3d419b884556c21b15e7d123;hpb=0dcbb205044702fc7aa8563ef164328a218c4e69

diff --git a/lib/silcclient/command_reply.c b/lib/silcclient/command_reply.c
index c026a869..9a8b9fe6 100644
--- a/lib/silcclient/command_reply.c
+++ b/lib/silcclient/command_reply.c
@@ -4,7 +4,7 @@
 
   Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
 
-  Copyright (C) 1997 - 2000 Pekka Riikonen
+  Copyright (C) 1997 - 2001 Pekka Riikonen
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -34,6 +34,7 @@
 /* $Id$ */
 
 #include "clientlibincludes.h"
+#include "client_internal.h"
 
 /* Client command reply list. */
 SilcClientCommandReply silc_command_reply_list[] =
@@ -45,7 +46,6 @@ SilcClientCommandReply silc_command_reply_list[] =
   SILC_CLIENT_CMD_REPLY(list, LIST),
   SILC_CLIENT_CMD_REPLY(topic, TOPIC),
   SILC_CLIENT_CMD_REPLY(invite, INVITE),
-  SILC_CLIENT_CMD_REPLY(quit, QUIT),
   SILC_CLIENT_CMD_REPLY(kill, KILL),
   SILC_CLIENT_CMD_REPLY(info, INFO),
   SILC_CLIENT_CMD_REPLY(connect, CONNECT),
@@ -57,28 +57,21 @@ SilcClientCommandReply silc_command_reply_list[] =
   SILC_CLIENT_CMD_REPLY(cmode, CMODE),
   SILC_CLIENT_CMD_REPLY(cumode, CUMODE),
   SILC_CLIENT_CMD_REPLY(kick, KICK),
-  SILC_CLIENT_CMD_REPLY(restart, RESTART),
+  SILC_CLIENT_CMD_REPLY(ban, BAN),
   SILC_CLIENT_CMD_REPLY(close, CLOSE),
-  SILC_CLIENT_CMD_REPLY(die, DIE),
+  SILC_CLIENT_CMD_REPLY(shutdown, SHUTDOWN),
   SILC_CLIENT_CMD_REPLY(silcoper, SILCOPER),
   SILC_CLIENT_CMD_REPLY(leave, LEAVE),
   SILC_CLIENT_CMD_REPLY(users, USERS),
+  SILC_CLIENT_CMD_REPLY(getkey, GETKEY),
 
   { NULL, 0 },
 };
 
-/* Status message structure. Messages are defined below. */
-typedef struct {
-  SilcCommandStatus status;
-  char *message;
-} SilcCommandStatusMessage;
-
-/* Status messages returned by the server */
-#define STAT(x) SILC_STATUS_ERR_##x
 const SilcCommandStatusMessage silc_command_status_messages[] = {
 
-  { STAT(NO_SUCH_NICK),      "No such nickname" },
-  { STAT(NO_SUCH_CHANNEL),   "No such channel" },
+  { STAT(NO_SUCH_NICK),      "There was no such nickname" },
+  { STAT(NO_SUCH_CHANNEL),   "There was no such channel" },
   { STAT(NO_SUCH_SERVER),    "No such server" },
   { STAT(TOO_MANY_TARGETS),  "Duplicate recipients. No message delivered" },
   { STAT(NO_RECIPIENT),      "No recipient given" },
@@ -89,8 +82,8 @@ const SilcCommandStatusMessage silc_command_status_messages[] = {
   { STAT(NO_SERVER_ID),      "No Server ID given" },
   { STAT(BAD_CLIENT_ID),     "Bad Client ID" },
   { STAT(BAD_CHANNEL_ID),    "Bad Channel ID" },
-  { STAT(NO_SUCH_CLIENT_ID), "No such Client ID" },
-  { STAT(NO_SUCH_CHANNEL_ID),"No such Channel ID" },
+  { STAT(NO_SUCH_CLIENT_ID), "There is no such client" },
+  { STAT(NO_SUCH_CHANNEL_ID),"There is no such channel" },
   { STAT(NICKNAME_IN_USE),   "Nickname already exists" },
   { STAT(NOT_ON_CHANNEL),    "You are not on that channel" },
   { STAT(USER_NOT_ON_CHANNEL),"They are not on the channel" },
@@ -98,7 +91,7 @@ const SilcCommandStatusMessage silc_command_status_messages[] = {
   { STAT(NOT_REGISTERED),    "You have not registered" },
   { STAT(NOT_ENOUGH_PARAMS), "Not enough parameters" },
   { STAT(TOO_MANY_PARAMS),   "Too many parameters" },
-  { STAT(PERM_DENIED),       "Your host is not among the privileged" },
+  { STAT(PERM_DENIED),       "Permission denied" },
   { STAT(BANNED_FROM_SERVER),"You are banned from this server" },
   { STAT(BAD_PASSWORD),      "Cannot join channel. Incorrect password" },
   { STAT(CHANNEL_IS_FULL),   "Cannot join channel. Channel is full" },
@@ -113,10 +106,11 @@ const SilcCommandStatusMessage silc_command_status_messages[] = {
   { STAT(BAD_NICKNAME),    "Bad nickname" },
   { STAT(BAD_CHANNEL),     "Bad channel name" },
   { STAT(AUTH_FAILED),     "Authentication failed" },
+  { STAT(UNKNOWN_ALGORITHM), "Unsupported algorithm" },
+  { STAT(NO_SUCH_SERVER_ID), "No such Server ID" },
 
   { 0, NULL }
 };
-
 /* Command reply operation that is called at the end of all command replys. 
    Usage: COMMAND_REPLY((ARGS, argument1, argument2, etc...)), */
 #define COMMAND_REPLY(args) cmd->client->ops->command_reply args
@@ -128,6 +122,32 @@ const SilcCommandStatusMessage silc_command_status_messages[] = {
   cmd->sock->user_data, cmd->payload, FALSE, \
   silc_command_get(cmd->payload), status)
 
+/* All functions that call the COMMAND_CHECK_STATUS or the
+   COMMAND_CHECK_STATUS_LIST macros must have out: goto label. */
+
+#define COMMAND_CHECK_STATUS						  \
+do {									  \
+  SILC_LOG_DEBUG(("Start"));						  \
+  SILC_GET16_MSB(status, silc_argument_get_arg_type(cmd->args, 1, NULL)); \
+  if (status != SILC_STATUS_OK)  {					  \
+    COMMAND_REPLY_ERROR;						  \
+    goto out;								  \
+  }									  \
+} while(0)
+
+#define COMMAND_CHECK_STATUS_LIST					  \
+do {									  \
+  SILC_LOG_DEBUG(("Start"));						  \
+  SILC_GET16_MSB(status, silc_argument_get_arg_type(cmd->args, 1, NULL)); \
+  if (status != SILC_STATUS_OK &&					  \
+      status != SILC_STATUS_LIST_START &&				  \
+      status != SILC_STATUS_LIST_ITEM &&				  \
+      status != SILC_STATUS_LIST_END) {					  \
+    COMMAND_REPLY_ERROR;						  \
+    goto out;								  \
+  }									  \
+} while(0)
+
 /* Process received command reply. */
 
 void silc_client_command_reply_process(SilcClient client,
@@ -139,7 +159,7 @@ void silc_client_command_reply_process(SilcClient client,
   SilcClientCommandReplyContext ctx;
   SilcCommandPayload payload;
   SilcCommand command;
-  unsigned short ident;
+  uint16 ident;
 
   /* Get command reply payload from packet */
   payload = silc_command_payload_parse(buffer);
@@ -174,13 +194,12 @@ void silc_client_command_reply_process(SilcClient client,
     return;
   }
 
-  cmd->cb(ctx);
+  cmd->cb(ctx, NULL);
 }
 
 /* Returns status message string */
 
-static char *
-silc_client_command_status_message(SilcCommandStatus status)
+char *silc_client_command_status_message(SilcCommandStatus status)
 {
   int i;
 
@@ -200,26 +219,26 @@ silc_client_command_status_message(SilcCommandStatus status)
 void silc_client_command_reply_free(SilcClientCommandReplyContext cmd)
 {
   if (cmd) {
-    silc_command_free_payload(cmd->payload);
+    silc_command_payload_free(cmd->payload);
     silc_free(cmd);
   }
 }
 
 static void 
-silc_client_command_reply_whois_print(SilcClientCommandReplyContext cmd,
-				      SilcCommandStatus status)
+silc_client_command_reply_whois_save(SilcClientCommandReplyContext cmd,
+				     SilcCommandStatus status)
 {
-  char buf[256];
-  int argc, len;
-  unsigned char *id_data;
-  char *nickname = NULL, *username = NULL;
-  char *realname = NULL;
+  SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
   SilcClientID *client_id;
   SilcIDCacheEntry id_cache = NULL;
   SilcClientEntry client_entry = NULL;
-  SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
-  
-  memset(buf, 0, sizeof(buf));
+  int argc;
+  uint32 len;
+  unsigned char *id_data, *tmp;
+  char *nickname = NULL, *username = NULL;
+  char *realname = NULL;
+  uint32 idle = 0, mode = 0;
+  SilcBuffer channels = NULL;
   
   argc = silc_argument_get_arg_num(cmd->args);
 
@@ -236,66 +255,51 @@ silc_client_command_reply_whois_print(SilcClientCommandReplyContext cmd,
   }
   
   nickname = silc_argument_get_arg_type(cmd->args, 3, &len);
-  if (nickname) {
-    strncat(buf, nickname, len);
-    strncat(buf, " is ", 4);
-  }
-  
   username = silc_argument_get_arg_type(cmd->args, 4, &len);
-  if (username) {
-    strncat(buf, username, len);
-  }
-  
   realname = silc_argument_get_arg_type(cmd->args, 5, &len);
-  if (realname) {
-    strncat(buf, " (", 2);
-    strncat(buf, realname, len);
-    strncat(buf, ")", 1);
+  if (!nickname || !username || !realname) {
+    COMMAND_REPLY_ERROR;
+    return;
   }
-  
+
+  tmp = silc_argument_get_arg_type(cmd->args, 6, &len);
+  if (tmp) {
+    channels = silc_buffer_alloc(len);
+    silc_buffer_pull_tail(channels, SILC_BUFFER_END(channels));
+    silc_buffer_put(channels, tmp, len);
+  }
+
+  tmp = silc_argument_get_arg_type(cmd->args, 7, &len);
+  if (tmp)
+    SILC_GET32_MSB(mode, tmp);
+
+  tmp = silc_argument_get_arg_type(cmd->args, 8, &len);
+  if (tmp)
+    SILC_GET32_MSB(idle, tmp);
+
   /* Check if we have this client cached already. */
-  if (!silc_idcache_find_by_id_one(conn->client_cache, (void *)client_id,
-				   SILC_ID_CLIENT, &id_cache)) {
-    client_entry = silc_calloc(1, sizeof(*client_entry));
-    client_entry->id = client_id;
-    silc_parse_nickname(nickname, &client_entry->nickname, 
-			&client_entry->server, &client_entry->num);
-    client_entry->username = strdup(username);
-    if (realname)
-      client_entry->realname = strdup(realname);
-    
-    /* Add client to cache */
-    silc_idcache_add(conn->client_cache, client_entry->nickname,
-		     SILC_ID_CLIENT, client_id, (void *)client_entry, TRUE);
+  if (!silc_idcache_find_by_id_one_ext(conn->client_cache, (void *)client_id, 
+				       NULL, NULL, 
+				       silc_hash_client_id_compare, NULL,
+				       &id_cache)) {
+    SILC_LOG_DEBUG(("Adding new client entry"));
+    client_entry = 
+      silc_client_add_client(cmd->client, conn, nickname, username, realname,
+			     client_id, mode);
   } else {
     client_entry = (SilcClientEntry)id_cache->context;
-    if (client_entry->nickname)
-      silc_free(client_entry->nickname);
-    if (client_entry->server)
-      silc_free(client_entry->server);
-    if (client_entry->username)
-      silc_free(client_entry->username);
-    if (client_entry->realname)
-      silc_free(client_entry->realname);
-
-    silc_parse_nickname(nickname, &client_entry->nickname, 
-			&client_entry->server, &client_entry->num);
-    client_entry->username = strdup(username);
-    if (realname)
-      client_entry->realname = strdup(realname);
-
-    id_cache->data = client_entry->nickname;
-    silc_idcache_sort_by_data(conn->client_cache);
-
+    silc_client_update_client(cmd->client, conn, client_entry, 
+			      nickname, username, realname, mode);
     silc_free(client_id);
   }
 
+  /* Notify application */
   if (!cmd->callback)
-    cmd->client->ops->say(cmd->client, conn, "%s", buf);
+    COMMAND_REPLY((ARGS, client_entry, nickname, username, realname, 
+		   channels, mode, idle));
 
-  /* Notify application */
-  COMMAND_REPLY((ARGS, client_entry, nickname, username, realname, 
-		 NULL, NULL));
+  if (channels)
+    silc_buffer_free(channels);
 }
 
 /* Received reply for WHOIS command. This maybe called several times
@@ -304,171 +308,233 @@ silc_client_command_reply_whois_print(SilcClientCommandReplyContext cmd,
 SILC_CLIENT_CMD_REPLY_FUNC(whois)
 {
   SilcClientCommandReplyContext cmd = (SilcClientCommandReplyContext)context;
-  SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
   SilcCommandStatus status;
-  unsigned char *tmp;
 
-  SILC_LOG_DEBUG(("Start"));
+  COMMAND_CHECK_STATUS_LIST;
 
-  tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
-  SILC_GET16_MSB(status, tmp);
-  if (status != SILC_STATUS_OK && 
-      status != SILC_STATUS_LIST_START &&
-      status != SILC_STATUS_LIST_ITEM &&
+  /* Save WHOIS info */
+  silc_client_command_reply_whois_save(cmd, status);
+
+  /* Pending callbacks are not executed if this was an list entry */
+  if (status != SILC_STATUS_OK &&
       status != SILC_STATUS_LIST_END) {
-    if (status == SILC_STATUS_ERR_NO_SUCH_NICK) {
-      /* Take nickname which may be provided */
-      tmp = silc_argument_get_arg_type(cmd->args, 3, NULL);
-      if (tmp)
-	cmd->client->ops->say(cmd->client, conn, "%s: %s", tmp,
-		 silc_client_command_status_message(status));
-      else
-	cmd->client->ops->say(cmd->client, conn, "%s",
-		 silc_client_command_status_message(status));
-      COMMAND_REPLY_ERROR;
-      goto out;
-    } else {
-      cmd->client->ops->say(cmd->client, conn,
-	       "%s", silc_client_command_status_message(status));
-      COMMAND_REPLY_ERROR;
-      goto out;
-    }
+    silc_client_command_reply_free(cmd);
+    return;
   }
 
-  /* Display one whois reply */
-  if (status == SILC_STATUS_OK) {
-    silc_client_command_reply_whois_print(cmd, status);
-  }
+ out:
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_WHOIS);
+  SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_WHOIS);
+  silc_client_command_reply_free(cmd);
+}
 
-  /* XXX list should not be displayed untill all items has been received. */
-  if (status == SILC_STATUS_LIST_START) {
-    silc_client_command_reply_whois_print(cmd, status);
-  }
+/* Received reply for WHOWAS command. */
+
+SILC_CLIENT_CMD_REPLY_FUNC(whowas)
+{
+  SilcClientCommandReplyContext cmd = (SilcClientCommandReplyContext)context;
+  SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
+  SilcCommandStatus status;
+  SilcClientID *client_id;
+  SilcIDCacheEntry id_cache = NULL;
+  SilcClientEntry client_entry = NULL;
+  uint32 len;
+  unsigned char *id_data;
+  char *nickname, *username;
+  char *realname = NULL;
+
+  COMMAND_CHECK_STATUS_LIST;
 
-  if (status == SILC_STATUS_LIST_ITEM) {
-    silc_client_command_reply_whois_print(cmd, status);
+  id_data = silc_argument_get_arg_type(cmd->args, 2, &len);
+  if (!id_data) {
+    COMMAND_REPLY_ERROR;
+    goto out;
+  }
+  
+  client_id = silc_id_payload_parse_id(id_data, len);
+  if (!client_id) {
+    COMMAND_REPLY_ERROR;
+    goto out;
   }
 
-  if (status == SILC_STATUS_LIST_END) {
-    silc_client_command_reply_whois_print(cmd, status);
+  /* Get the client entry, if exists */
+  if (silc_idcache_find_by_id_one_ext(conn->client_cache, (void *)client_id, 
+				      NULL, NULL, 
+				      silc_hash_client_id_compare, NULL,
+				      &id_cache)) 
+    client_entry = (SilcClientEntry)id_cache->context;
+  silc_free(client_id);
+
+  nickname = silc_argument_get_arg_type(cmd->args, 3, &len);
+  username = silc_argument_get_arg_type(cmd->args, 4, &len);
+  realname = silc_argument_get_arg_type(cmd->args, 5, &len);
+  if (!nickname || !username) {
+    COMMAND_REPLY_ERROR;
+    goto out;
   }
 
-  /* Execute any pending command callbacks */
-  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_WHOIS);
+  /* Notify application. We don't save any history information to any
+     cache. Just pass the data to the application for displaying on 
+     the screen. */
+  COMMAND_REPLY((ARGS, client_entry, nickname, username, realname));
+
+  /* Pending callbacks are not executed if this was an list entry */
+  if (status != SILC_STATUS_OK &&
+      status != SILC_STATUS_LIST_END) {
+    silc_client_command_reply_free(cmd);
+    return;
+  }
 
  out:
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_WHOIS);
   SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_WHOIS);
   silc_client_command_reply_free(cmd);
 }
 
-/* Received reply for WHOWAS command. */
-
-SILC_CLIENT_CMD_REPLY_FUNC(whowas)
+static void 
+silc_client_command_reply_identify_save(SilcClientCommandReplyContext cmd,
+					SilcCommandStatus status)
 {
+  SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
+  SilcClient client = cmd->client;
+  SilcClientID *client_id = NULL;
+  SilcServerID *server_id = NULL;
+  SilcChannelID *channel_id = NULL;
+  SilcIDCacheEntry id_cache = NULL;
+  SilcClientEntry client_entry;
+  SilcServerEntry server_entry;
+  SilcChannelEntry channel_entry;
+  int argc;
+  uint32 len;
+  unsigned char *id_data;
+  char *name = NULL, *info = NULL;
+  SilcIDPayload idp = NULL;
+  SilcIdType id_type;
+  
+  argc = silc_argument_get_arg_num(cmd->args);
 
-}
+  id_data = silc_argument_get_arg_type(cmd->args, 2, &len);
+  if (!id_data) {
+    COMMAND_REPLY_ERROR;
+    return;
+  }
+  idp = silc_id_payload_parse_data(id_data, len);
+  if (!idp) {
+    COMMAND_REPLY_ERROR;
+    return;
+  }
 
-/* Received reply for IDENTIFY command. This maybe called several times
-   for one IDENTIFY command as server may reply with list of results. 
-   This is totally silent and does not print anything on screen. */
+  name = silc_argument_get_arg_type(cmd->args, 3, &len);
+  info = silc_argument_get_arg_type(cmd->args, 4, &len);
 
-SILC_CLIENT_CMD_REPLY_FUNC(identify)
-{
-  SilcClientCommandReplyContext cmd = (SilcClientCommandReplyContext)context;
-  SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
-  SilcClientEntry client_entry;
-  SilcIDCacheEntry id_cache = NULL;
-  SilcCommandStatus status;
-  unsigned char *tmp;
+  id_type = silc_id_payload_get_type(idp);
 
-  SILC_LOG_DEBUG(("Start"));
+  switch (id_type) {
+  case SILC_ID_CLIENT:
+    client_id = silc_id_payload_get_id(idp);
 
-  tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
-  SILC_GET16_MSB(status, tmp);
-  if (status != SILC_STATUS_OK) {
-    if (status == SILC_STATUS_ERR_NO_SUCH_NICK) {
-      /* Take nickname which may be provided */
-      tmp = silc_argument_get_arg_type(cmd->args, 3, NULL);
-      if (tmp)
-	cmd->client->ops->say(cmd->client, conn, "%s: %s", tmp,
-		 silc_client_command_status_message(status));
-      else
-	cmd->client->ops->say(cmd->client, conn, "%s",
-		 silc_client_command_status_message(status));
-      COMMAND_REPLY_ERROR;
-      goto out;
+    SILC_LOG_DEBUG(("Received client information"));
+
+    /* Check if we have this client cached already. */
+    if (!silc_idcache_find_by_id_one_ext(conn->client_cache, 
+					 (void *)client_id, 
+					 NULL, NULL, 
+					 silc_hash_client_id_compare, NULL,
+					 &id_cache)) {
+      SILC_LOG_DEBUG(("Adding new client entry"));
+      client_entry = 
+	silc_client_add_client(cmd->client, conn, name, info, NULL,
+			       silc_id_dup(client_id, id_type), 0);
     } else {
-      cmd->client->ops->say(cmd->client, conn,
-	       "%s", silc_client_command_status_message(status));
-      COMMAND_REPLY_ERROR;
-      goto out;
+      client_entry = (SilcClientEntry)id_cache->context;
+      silc_client_update_client(cmd->client, conn, client_entry, 
+				name, info, NULL, 0);
     }
-  }
 
-  /* Display one whois reply */
-  if (status == SILC_STATUS_OK) {
-    unsigned int len;
-    unsigned char *id_data;
-    char *nickname;
-    char *username;
-    SilcClientID *client_id;
+    /* Notify application */
+    COMMAND_REPLY((ARGS, client_entry, name, info));
+    break;
 
-    id_data = silc_argument_get_arg_type(cmd->args, 2, &len);
-    if (!id_data)
-      goto out;
-    client_id = silc_id_payload_parse_id(id_data, len);
-    if (!client_id)
-      goto out;
+  case SILC_ID_SERVER:
+    server_id = silc_id_payload_get_id(idp);
 
-    nickname = silc_argument_get_arg_type(cmd->args, 3, NULL);
-    username = silc_argument_get_arg_type(cmd->args, 4, NULL);
-
-    if (!silc_idcache_find_by_id_one(conn->client_cache, (void *)client_id,
-				     SILC_ID_CLIENT, &id_cache)) {
-      client_entry = silc_calloc(1, sizeof(*client_entry));
-      client_entry->id = client_id;
-      silc_parse_nickname(nickname, &client_entry->nickname, 
-			  &client_entry->server, &client_entry->num);
-      if (username)
-	client_entry->username = strdup(username);
-    
-      /* Add client to cache */
-      silc_idcache_add(conn->client_cache, client_entry->nickname,
-		       SILC_ID_CLIENT, client_id, (void *)client_entry, TRUE);
+    SILC_LOG_DEBUG(("Received server information"));
+
+    /* Check if we have this server cached already. */
+    if (!silc_idcache_find_by_id_one(conn->server_cache, 
+				     (void *)server_id, &id_cache)) {
+      SILC_LOG_DEBUG(("Adding new server entry"));
+      
+      server_entry = silc_calloc(1, sizeof(*server_entry));
+      server_entry->server_id = silc_id_dup(server_id, id_type);
+      if (name)
+	server_entry->server_name = strdup(name);
+      if (info)
+	server_entry->server_info = strdup(info);
+      
+      /* Add server to cache */
+      silc_idcache_add(conn->server_cache, server_entry->server_name,
+		       server_entry->server_id, (void *)server_entry, FALSE);
     } else {
-      client_entry = (SilcClientEntry)id_cache->context;
-      if (client_entry->nickname)
-	silc_free(client_entry->nickname);
-      if (client_entry->server)
-	silc_free(client_entry->server);
-      if (username && client_entry->username)
-	silc_free(client_entry->username);
+      server_entry = (SilcServerEntry)id_cache->context;
+    }
 
-      silc_parse_nickname(nickname, &client_entry->nickname, 
-			  &client_entry->server, &client_entry->num);
+    /* Notify application */
+    COMMAND_REPLY((ARGS, server_entry, name, info));
+    break;
 
-      if (username)
-	client_entry->username = strdup(username);
+  case SILC_ID_CHANNEL:
+    channel_id = silc_id_payload_get_id(idp);
 
-      id_cache->data = client_entry->nickname;
-      silc_idcache_sort_by_data(conn->client_cache);
-    
-      silc_free(client_id);
+    SILC_LOG_DEBUG(("Received channel information"));
+
+    /* Check if we have this channel cached already. */
+    if (!silc_idcache_find_by_id_one(conn->channel_cache, 
+				     (void *)channel_id, &id_cache)) {
+      if (!name)
+	break;
+
+      SILC_LOG_DEBUG(("Adding new channel entry"));
+      channel_entry = silc_client_new_channel_id(client, conn->sock, 
+						 strdup(name), 0, idp);
+    } else {
+      channel_entry = (SilcChannelEntry)id_cache->context;
     }
+
+    /* Notify application */
+    COMMAND_REPLY((ARGS, channel_entry, name, info));
+    break;
   }
 
-  if (status == SILC_STATUS_LIST_START) {
+  silc_id_payload_free(idp);
+  silc_free(client_id);
+  silc_free(server_id);
+  silc_free(channel_id);
+}
 
-  }
+/* Received reply for IDENTIFY command. This maybe called several times
+   for one IDENTIFY command as server may reply with list of results. 
+   This is totally silent and does not print anything on screen. */
+
+SILC_CLIENT_CMD_REPLY_FUNC(identify)
+{
+  SilcClientCommandReplyContext cmd = (SilcClientCommandReplyContext)context;
+  SilcCommandStatus status;
 
-  if (status == SILC_STATUS_LIST_END) {
+  COMMAND_CHECK_STATUS_LIST;
 
-  }
+  /* Save IDENTIFY info */
+  silc_client_command_reply_identify_save(cmd, status);
 
-  /* Execute any pending command callbacks */
-  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_IDENTIFY);
+  /* Pending callbacks are not executed if this was an list entry */
+  if (status != SILC_STATUS_OK &&
+      status != SILC_STATUS_LIST_END) {
+    silc_client_command_reply_free(cmd);
+    return;
+  }
 
  out:
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_IDENTIFY);
   SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_IDENTIFY);
   silc_client_command_reply_free(cmd);
 }
@@ -483,21 +549,22 @@ SILC_CLIENT_CMD_REPLY_FUNC(nick)
   SilcCommandStatus status;
   SilcIDPayload idp;
   unsigned char *tmp;
-  unsigned int argc, len;
+  uint32 argc, len;
 
   SILC_LOG_DEBUG(("Start"));
 
   SILC_GET16_MSB(status, silc_argument_get_arg_type(cmd->args, 1, NULL));
   if (status != SILC_STATUS_OK) {
-    cmd->client->ops->say(cmd->client, conn, "Cannot set nickname: %s", 
-	     silc_client_command_status_message(status));
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
+			  "Cannot set nickname: %s", 
+			  silc_client_command_status_message(status));
     COMMAND_REPLY_ERROR;
     goto out;
   }
 
   argc = silc_argument_get_arg_num(cmd->args);
   if (argc < 2 || argc > 2) {
-    cmd->client->ops->say(cmd->client, conn, 
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
 			  "Cannot set nickname: bad reply to command");
     COMMAND_REPLY_ERROR;
     goto out;
@@ -515,16 +582,43 @@ SILC_CLIENT_CMD_REPLY_FUNC(nick)
   /* Notify application */
   COMMAND_REPLY((ARGS, conn->local_entry));
 
-  /* Execute any pending command callbacks */
-  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_NICK);
-
  out:
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_NICK);
   SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_NICK);
   silc_client_command_reply_free(cmd);
 }
 
+/* Received reply to the LIST command. */
+
 SILC_CLIENT_CMD_REPLY_FUNC(list)
 {
+  SilcClientCommandReplyContext cmd = (SilcClientCommandReplyContext)context;
+  SilcCommandStatus status;
+  unsigned char *tmp, *name, *topic;
+  uint32 usercount = 0;
+
+  COMMAND_CHECK_STATUS_LIST;
+
+  name = silc_argument_get_arg_type(cmd->args, 3, NULL);
+  topic = silc_argument_get_arg_type(cmd->args, 4, NULL);
+  tmp = silc_argument_get_arg_type(cmd->args, 5, NULL);
+  if (tmp)
+    SILC_GET32_MSB(usercount, tmp);
+
+  /* Notify application */
+  COMMAND_REPLY((ARGS, NULL, name, topic, usercount));
+
+  /* Pending callbacks are not executed if this was an list entry */
+  if (status != SILC_STATUS_OK &&
+      status != SILC_STATUS_LIST_END) {
+    silc_client_command_reply_free(cmd);
+    return;
+  }
+
+ out:
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_LIST);
+  SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_LIST);
+  silc_client_command_reply_free(cmd);
 }
 
 /* Received reply to topic command. */
@@ -539,16 +633,14 @@ SILC_CLIENT_CMD_REPLY_FUNC(topic)
   SilcIDCacheEntry id_cache = NULL;
   unsigned char *tmp;
   char *topic;
-  unsigned int argc, len;
+  uint32 argc, len;
 
   SILC_GET16_MSB(status, silc_argument_get_arg_type(cmd->args, 1, NULL));
   if (status != SILC_STATUS_OK) {
-    cmd->client->ops->say(cmd->client, conn,
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
 	     "%s", silc_client_command_status_message(status));
     COMMAND_REPLY_ERROR;
-    SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_TOPIC);
-    silc_client_command_reply_free(cmd);
-    return;
+    goto out;
   }
 
   argc = silc_argument_get_arg_num(cmd->args);
@@ -571,9 +663,9 @@ SILC_CLIENT_CMD_REPLY_FUNC(topic)
   if (!channel_id)
     goto out;
 
-  /* Get the channel name */
+  /* Get the channel entry */
   if (!silc_idcache_find_by_id_one(conn->channel_cache, (void *)channel_id,
-				   SILC_ID_CHANNEL, &id_cache)) {
+				   &id_cache)) {
     silc_free(channel_id);
     COMMAND_REPLY_ERROR;
     goto out;
@@ -581,17 +673,11 @@ SILC_CLIENT_CMD_REPLY_FUNC(topic)
   
   channel = (SilcChannelEntry)id_cache->context;
 
-  cmd->client->ops->say(cmd->client, conn, 
-			"Topic on channel %s: %s", channel->channel_name,
-			topic);
-
   /* Notify application */
   COMMAND_REPLY((ARGS, channel, topic));
 
-  /* Execute any pending command callbacks */
-  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_TOPIC);
-
  out:
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_TOPIC);
   SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_TOPIC);
   silc_client_command_reply_free(cmd);
 }
@@ -603,35 +689,75 @@ SILC_CLIENT_CMD_REPLY_FUNC(invite)
   SilcClientCommandReplyContext cmd = (SilcClientCommandReplyContext)context;
   SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
   SilcCommandStatus status;
+  SilcChannelEntry channel;
+  SilcChannelID *channel_id;
+  SilcIDCacheEntry id_cache;
   unsigned char *tmp;
+  uint32 len;
 
   tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
   SILC_GET16_MSB(status, tmp);
   if (status != SILC_STATUS_OK) {
-    cmd->client->ops->say(cmd->client, conn,
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
 	     "%s", silc_client_command_status_message(status));
     COMMAND_REPLY_ERROR;
-    SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_INVITE);
-    silc_client_command_reply_free(cmd);
-    return;
+    goto out;
+  }
+
+  /* Take Channel ID */
+  tmp = silc_argument_get_arg_type(cmd->args, 2, &len);
+  if (!tmp)
+    goto out;
+
+  channel_id = silc_id_payload_parse_id(tmp, len);
+  if (!channel_id)
+    goto out;
+
+  /* Get the channel entry */
+  if (!silc_idcache_find_by_id_one(conn->channel_cache, (void *)channel_id,
+				   &id_cache)) {
+    silc_free(channel_id);
+    COMMAND_REPLY_ERROR;
+    goto out;
   }
+  
+  channel = (SilcChannelEntry)id_cache->context;
+
+  /* Get the invite list */
+  tmp = silc_argument_get_arg_type(cmd->args, 3, &len);
 
   /* Notify application */
-  COMMAND_REPLY((ARGS));
+  COMMAND_REPLY((ARGS, channel, tmp));
 
-  /* Execute any pending command callbacks */
+ out:
   SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_INVITE);
-
   SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_INVITE);
   silc_client_command_reply_free(cmd);
 }
- 
-SILC_CLIENT_CMD_REPLY_FUNC(quit)
-{
-}
 
+/* Received reply to the KILL command. */
+ 
 SILC_CLIENT_CMD_REPLY_FUNC(kill)
 {
+  SilcClientCommandReplyContext cmd = (SilcClientCommandReplyContext)context;
+  SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
+  SilcCommandStatus status;
+
+  SILC_GET16_MSB(status, silc_argument_get_arg_type(cmd->args, 1, NULL));
+  if (status != SILC_STATUS_OK) {
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
+	     "%s", silc_client_command_status_message(status));
+    COMMAND_REPLY_ERROR;
+    goto out;
+  }
+
+  /* Notify application */
+  COMMAND_REPLY((ARGS));
+
+ out:
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_KILL);
+  SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_KILL);
+  silc_client_command_reply_free(cmd);
 }
 
 /* Received reply to INFO command. We receive the server ID and some
@@ -641,50 +767,69 @@ SILC_CLIENT_CMD_REPLY_FUNC(info)
 {
   SilcClientCommandReplyContext cmd = (SilcClientCommandReplyContext)context;
   SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
-  SilcClient client = cmd->client;
   SilcCommandStatus status;
   unsigned char *tmp;
+  SilcIDCacheEntry id_cache;
+  SilcServerEntry server;
+  SilcServerID *server_id = NULL;
+  char *server_name, *server_info;
+  uint32 len;
 
   tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
   SILC_GET16_MSB(status, tmp);
   if (status != SILC_STATUS_OK) {
-    cmd->client->ops->say(cmd->client, conn,
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
 	     "%s", silc_client_command_status_message(status));
     COMMAND_REPLY_ERROR;
-    SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_INFO);
-    silc_client_command_reply_free(cmd);
-    return;
+    goto out;
   }
 
   /* Get server ID */
-  tmp = silc_argument_get_arg_type(cmd->args, 2, NULL);
+  tmp = silc_argument_get_arg_type(cmd->args, 2, &len);
   if (!tmp)
     goto out;
 
-  /* XXX save server id */
+  server_id = silc_id_payload_parse_id(tmp, len);
+  if (!server_id)
+    goto out;
+
+  /* Get server name */
+  server_name = silc_argument_get_arg_type(cmd->args, 3, NULL);
+  if (!server_name)
+    goto out;
 
   /* Get server info */
-  tmp = silc_argument_get_arg_type(cmd->args, 3, NULL);
-  if (!tmp)
+  server_info = silc_argument_get_arg_type(cmd->args, 4, NULL);
+  if (!server_info)
     goto out;
 
-  client->ops->say(cmd->client, conn, "Info: %s", tmp);
+  /* See whether we have this server cached. If not create it. */
+  if (!silc_idcache_find_by_id_one(conn->server_cache, (void *)server_id,
+				   &id_cache)) {
+    SILC_LOG_DEBUG(("New server entry"));
 
-  /* Notify application */
-  COMMAND_REPLY((ARGS, NULL, (char *)tmp));
+    server = silc_calloc(1, sizeof(*server));
+    server->server_name = strdup(server_name);
+    server->server_info = strdup(server_info);
+    server->server_id = silc_id_dup(server_id, SILC_ID_SERVER);
 
-  /* Execute any pending command callbacks */
-  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_INFO);
+    /* Add it to the cache */
+    silc_idcache_add(conn->server_cache, server->server_name,
+		     server->server_id, (void *)server, FALSE);
+  } else {
+    server = (SilcServerEntry)id_cache->context;
+  }
+  
+  /* Notify application */
+  COMMAND_REPLY((ARGS, server, server->server_name, server->server_info));
 
  out:
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_INFO);
   SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_INFO);
+  silc_free(server_id);
   silc_client_command_reply_free(cmd);
 }
 
-SILC_CLIENT_CMD_REPLY_FUNC(connect)
-{
-}
-
 /* Received reply to PING command. The reply time is shown to user. */
 
 SILC_CLIENT_CMD_REPLY_FUNC(ping)
@@ -698,7 +843,7 @@ SILC_CLIENT_CMD_REPLY_FUNC(ping)
 
   SILC_GET16_MSB(status, silc_argument_get_arg_type(cmd->args, 1, NULL));
   if (status != SILC_STATUS_OK) {
-    cmd->client->ops->say(cmd->client, conn,
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
 	     "%s", silc_client_command_status_message(status));
     COMMAND_REPLY_ERROR;
     goto out;
@@ -713,9 +858,9 @@ SILC_CLIENT_CMD_REPLY_FUNC(ping)
   }
 
   for (i = 0; i < conn->ping_count; i++) {
-    if (!SILC_ID_SERVER_COMPARE(conn->ping[i].dest_id, id)) {
+    if (SILC_ID_SERVER_COMPARE(conn->ping[i].dest_id, id)) {
       diff = curtime - conn->ping[i].start_time;
-      cmd->client->ops->say(cmd->client, conn, 
+      cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, 
 			    "Ping reply from %s: %d second%s", 
 			    conn->ping[i].dest_name, diff, 
 			    diff == 1 ? "" : "s");
@@ -734,44 +879,41 @@ SILC_CLIENT_CMD_REPLY_FUNC(ping)
   /* Notify application */
   COMMAND_REPLY((ARGS));
 
-  /* Execute any pending command callbacks */
-  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_PING);
-
  out:
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_PING);
   SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_PING);
   silc_client_command_reply_free(cmd);
 }
 
-SILC_CLIENT_CMD_REPLY_FUNC(oper)
-{
-}
-
 /* Received reply for JOIN command. */
 
 SILC_CLIENT_CMD_REPLY_FUNC(join)
 {
   SilcClientCommandReplyContext cmd = (SilcClientCommandReplyContext)context;
   SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
-  SilcClient client = cmd->client;
   SilcCommandStatus status;
   SilcIDPayload idp = NULL;
-  unsigned int argc, mode, len;
-  char *topic, *tmp, *channel_name = NULL;
-  SilcBuffer keyp;
+  SilcChannelEntry channel;
+  SilcIDCacheEntry id_cache = NULL;
+  SilcChannelUser chu;
+  uint32 argc, mode, len, list_count;
+  char *topic, *tmp, *channel_name = NULL, *hmac;
+  SilcBuffer keyp = NULL, client_id_list = NULL, client_mode_list = NULL;
+  int i;
 
   SILC_LOG_DEBUG(("Start"));
 
   SILC_GET16_MSB(status, silc_argument_get_arg_type(cmd->args, 1, NULL));
   if (status != SILC_STATUS_OK) {
-    cmd->client->ops->say(cmd->client, conn,
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
 	     "%s", silc_client_command_status_message(status));
     COMMAND_REPLY_ERROR;
     goto out;
   }
 
   argc = silc_argument_get_arg_num(cmd->args);
-  if (argc < 3 || argc > 9) {
-    cmd->client->ops->say(cmd->client, conn,
+  if (argc < 7 || argc > 14) {
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
 	     "Cannot join channel: Bad reply packet");
     COMMAND_REPLY_ERROR;
     goto out;
@@ -780,7 +922,7 @@ SILC_CLIENT_CMD_REPLY_FUNC(join)
   /* Get channel name */
   tmp = silc_argument_get_arg_type(cmd->args, 2, NULL);
   if (!tmp) {
-    cmd->client->ops->say(cmd->client, conn, 
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
 			  "Cannot join channel: Bad reply packet");
     COMMAND_REPLY_ERROR;
     goto out;
@@ -790,7 +932,7 @@ SILC_CLIENT_CMD_REPLY_FUNC(join)
   /* Get Channel ID */
   tmp = silc_argument_get_arg_type(cmd->args, 3, &len);
   if (!tmp) {
-    cmd->client->ops->say(cmd->client, conn, 
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
 			  "Cannot join channel: Bad reply packet");
     COMMAND_REPLY_ERROR;
     silc_free(channel_name);
@@ -804,49 +946,143 @@ SILC_CLIENT_CMD_REPLY_FUNC(join)
   }
 
   /* Get channel mode */
-  tmp = silc_argument_get_arg_type(cmd->args, 4, NULL);
+  tmp = silc_argument_get_arg_type(cmd->args, 5, NULL);
   if (tmp)
     SILC_GET32_MSB(mode, tmp);
   else
     mode = 0;
 
   /* Get channel key */
-  tmp = silc_argument_get_arg_type(cmd->args, 6, &len);
-  if (!tmp) {
-    silc_id_payload_free(idp);
-    silc_free(channel_name);
-    goto out;
+  tmp = silc_argument_get_arg_type(cmd->args, 7, &len);
+  if (tmp) {
+    keyp = silc_buffer_alloc(len);
+    silc_buffer_pull_tail(keyp, SILC_BUFFER_END(keyp));
+    silc_buffer_put(keyp, tmp, len);
   }
-  keyp = silc_buffer_alloc(len);
-  silc_buffer_pull_tail(keyp, SILC_BUFFER_END(keyp));
-  silc_buffer_put(keyp, tmp, len);
 
   /* Get topic */
-  topic = silc_argument_get_arg_type(cmd->args, 8, NULL);
+  topic = silc_argument_get_arg_type(cmd->args, 10, NULL);
 
-  /* Save received Channel ID */
-  silc_client_new_channel_id(cmd->client, cmd->sock, channel_name, 
-			     mode, idp);
+  /* If we have the channel entry, remove it and create a new one */
+  channel = silc_client_get_channel(cmd->client, conn, channel_name);
+  if (channel)
+    silc_client_del_channel(cmd->client, conn, channel);
+
+  /* Save received Channel ID. This actually creates the channel */
+  channel = silc_client_new_channel_id(cmd->client, cmd->sock, channel_name, 
+				       mode, idp);
   silc_id_payload_free(idp);
 
+  conn->current_channel = channel;
+
+  /* Get hmac */
+  hmac = silc_argument_get_arg_type(cmd->args, 11, NULL);
+  if (hmac) {
+    if (!silc_hmac_alloc(hmac, NULL, &channel->hmac)) {
+      cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR, 
+			    "Cannot join channel: Unsupported HMAC `%s'",
+			    hmac);
+      COMMAND_REPLY_ERROR;
+      silc_free(channel_name);
+      goto out;
+    }
+  }
+
+  /* Get the list count */
+  tmp = silc_argument_get_arg_type(cmd->args, 12, &len);
+  if (!tmp)
+    goto out;
+  SILC_GET32_MSB(list_count, tmp);
+
+  /* Get Client ID list */
+  tmp = silc_argument_get_arg_type(cmd->args, 13, &len);
+  if (!tmp)
+    goto out;
+
+  client_id_list = silc_buffer_alloc(len);
+  silc_buffer_pull_tail(client_id_list, len);
+  silc_buffer_put(client_id_list, tmp, len);
+
+  /* Get client mode list */
+  tmp = silc_argument_get_arg_type(cmd->args, 14, &len);
+  if (!tmp)
+    goto out;
+
+  client_mode_list = silc_buffer_alloc(len);
+  silc_buffer_pull_tail(client_mode_list, len);
+  silc_buffer_put(client_mode_list, tmp, len);
+
+  /* Add clients we received in the reply to the channel */
+  for (i = 0; i < list_count; i++) {
+    uint16 idp_len;
+    uint32 mode;
+    SilcClientID *client_id;
+    SilcClientEntry client_entry;
+
+    /* Client ID */
+    SILC_GET16_MSB(idp_len, client_id_list->data + 2);
+    idp_len += 4;
+    client_id = silc_id_payload_parse_id(client_id_list->data, idp_len);
+    if (!client_id)
+      continue;
+
+    /* Mode */
+    SILC_GET32_MSB(mode, client_mode_list->data);
+
+    /* Check if we have this client cached already. */
+    if (!silc_idcache_find_by_id_one_ext(conn->client_cache, 
+					 (void *)client_id, 
+					 NULL, NULL, 
+					 silc_hash_client_id_compare, NULL,
+					 &id_cache)) {
+      /* No, we don't have it, add entry for it. */
+      client_entry = 
+	silc_client_add_client(cmd->client, conn, NULL, NULL, NULL,
+			       silc_id_dup(client_id, SILC_ID_CLIENT), 0);
+    } else {
+      /* Yes, we have it already */
+      client_entry = (SilcClientEntry)id_cache->context;
+    }
+
+    /* Join the client to the channel */
+    chu = silc_calloc(1, sizeof(*chu));
+    chu->client = client_entry;
+    chu->mode = mode;
+    silc_list_add(channel->clients, chu);
+    silc_free(client_id);
+
+    silc_buffer_pull(client_id_list, idp_len);
+    silc_buffer_pull(client_mode_list, 4);
+  }
+  silc_buffer_push(client_id_list, client_id_list->data - 
+		   client_id_list->head);
+  silc_buffer_push(client_mode_list, client_mode_list->data - 
+		   client_mode_list->head);
+
   /* Save channel key */
-  silc_client_save_channel_key(conn, keyp, conn->current_channel);
-  silc_buffer_free(keyp);
+  if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY))
+    silc_client_save_channel_key(conn, keyp, channel);
 
-  if (topic)
-    client->ops->say(cmd->client, conn, 
-		     "Topic for %s: %s", channel_name, topic);
+  /* Client is now joined to the channel */
+  channel->on_channel = TRUE;
 
   /* Notify application */
-  COMMAND_REPLY((ARGS, channel_name, conn->current_channel, mode,
-		 NULL, NULL, topic));
-
-  /* Execute any pending command callbacks */
-  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_JOIN);
+  COMMAND_REPLY((ARGS, channel_name, channel, mode, 0, 
+		 keyp ? keyp->head : NULL, NULL,
+		 NULL, topic, hmac, list_count, client_id_list, 
+		 client_mode_list));
 
  out:
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_JOIN);
   SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_JOIN);
   silc_client_command_reply_free(cmd);
+
+  if (keyp)
+    silc_buffer_free(keyp);
+  if (client_id_list)
+    silc_buffer_free(client_id_list);
+  if (client_mode_list)
+    silc_buffer_free(client_mode_list);
 }
 
 /* Received reply for MOTD command */
@@ -856,27 +1092,27 @@ SILC_CLIENT_CMD_REPLY_FUNC(motd)
   SilcClientCommandReplyContext cmd = (SilcClientCommandReplyContext)context;
   SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
   SilcCommandStatus status;
-  unsigned int argc, i;
+  uint32 argc, i;
   unsigned char *tmp;
   char *motd = NULL, *cp, line[256];
 
   tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
   SILC_GET16_MSB(status, tmp);
   if (status != SILC_STATUS_OK) {
-    cmd->client->ops->say(cmd->client, conn,
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
 	     "%s", silc_client_command_status_message(status));
     COMMAND_REPLY_ERROR;
     return;
   }
 
   argc = silc_argument_get_arg_num(cmd->args);
-  if (argc > 2) {
+  if (argc > 3) {
     COMMAND_REPLY_ERROR;
     goto out;
   }
 
-  if (argc == 2) {
-    motd = silc_argument_get_arg_type(cmd->args, 2, NULL);
+  if (argc == 3) {
+    motd = silc_argument_get_arg_type(cmd->args, 3, NULL);
     if (!motd) {
       COMMAND_REPLY_ERROR;
       goto out;
@@ -893,7 +1129,8 @@ SILC_CLIENT_CMD_REPLY_FUNC(motd)
 	if (i == 2)
 	  line[0] = ' ';
 	
-	cmd->client->ops->say(cmd->client, conn, "%s", line);
+	cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+			      "%s", line);
 	
 	if (!strlen(cp))
 	  break;
@@ -905,16 +1142,47 @@ SILC_CLIENT_CMD_REPLY_FUNC(motd)
   /* Notify application */
   COMMAND_REPLY((ARGS, motd));
 
-  /* Execute any pending command callbacks */
-  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_MOTD);
-
  out:
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_MOTD);
   SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_MOTD);
   silc_client_command_reply_free(cmd);
 }
 
+/* Received reply tot he UMODE command. Save the current user mode */
+
 SILC_CLIENT_CMD_REPLY_FUNC(umode)
 {
+  SilcClientCommandReplyContext cmd = (SilcClientCommandReplyContext)context;
+  SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
+  SilcCommandStatus status;
+  unsigned char *tmp;
+  uint32 mode;
+
+  tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
+  SILC_GET16_MSB(status, tmp);
+  if (status != SILC_STATUS_OK) {
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
+	     "%s", silc_client_command_status_message(status));
+    COMMAND_REPLY_ERROR;
+    goto out;
+  }
+
+  tmp = silc_argument_get_arg_type(cmd->args, 2, NULL);
+  if (!tmp) {
+    COMMAND_REPLY_ERROR;
+    goto out;
+  }
+
+  SILC_GET32_MSB(mode, tmp);
+  conn->local_entry->mode = mode;
+
+  /* Notify application */
+  COMMAND_REPLY((ARGS, mode));
+
+ out:
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_UMODE);
+  SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_UMODE);
+  silc_client_command_reply_free(cmd);
 }
 
 /* Received reply for CMODE command. */
@@ -925,29 +1193,57 @@ SILC_CLIENT_CMD_REPLY_FUNC(cmode)
   SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
   SilcCommandStatus status;
   unsigned char *tmp;
+  uint32 mode;
+  SilcIDCacheEntry id_cache;
+  SilcChannelID *channel_id;
+  SilcChannelEntry channel;
+  uint32 len;
 
   SILC_GET16_MSB(status, silc_argument_get_arg_type(cmd->args, 1, NULL));
   if (status != SILC_STATUS_OK) {
-    cmd->client->ops->say(cmd->client, conn,
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
 	     "%s", silc_client_command_status_message(status));
     COMMAND_REPLY_ERROR;
     goto out;
   }
 
+  /* Take Channel ID */
+  tmp = silc_argument_get_arg_type(cmd->args, 2, &len);
+  if (!tmp)
+    goto out;
+  channel_id = silc_id_payload_parse_id(tmp, len);
+  if (!channel_id)
+    goto out;
+
+  /* Get the channel entry */
+  if (!silc_idcache_find_by_id_one(conn->channel_cache, (void *)channel_id,
+				   &id_cache)) {
+    silc_free(channel_id);
+    COMMAND_REPLY_ERROR;
+    goto out;
+  }
+  
+  channel = (SilcChannelEntry)id_cache->context;
+
   /* Get channel mode */
-  tmp = silc_argument_get_arg_type(cmd->args, 2, NULL);
+  tmp = silc_argument_get_arg_type(cmd->args, 3, NULL);
   if (!tmp) {
+    silc_free(channel_id);
     COMMAND_REPLY_ERROR;
     goto out;
   }
 
+  /* Save the mode */
+  SILC_GET32_MSB(mode, tmp);
+  channel->mode = mode;
+
   /* Notify application */
-  COMMAND_REPLY((ARGS, tmp));
+  COMMAND_REPLY((ARGS, channel, mode));
 
-  /* Execute any pending command callbacks */
-  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_CMODE);
+  silc_free(channel_id);
 
  out:
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_CMODE);
   SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_CMODE);
   silc_client_command_reply_free(cmd);
 }
@@ -961,51 +1257,90 @@ SILC_CLIENT_CMD_REPLY_FUNC(cumode)
   SilcCommandStatus status;
   SilcIDCacheEntry id_cache = NULL;
   SilcClientID *client_id;
-  unsigned char *tmp, *id;
-  unsigned int len;
+  SilcChannelID *channel_id;
+  SilcClientEntry client_entry;
+  SilcChannelEntry channel;
+  SilcChannelUser chu;
+  unsigned char *modev, *tmp, *id;
+  uint32 len, mode;
   
   SILC_GET16_MSB(status, silc_argument_get_arg_type(cmd->args, 1, NULL));
   if (status != SILC_STATUS_OK) {
-    cmd->client->ops->say(cmd->client, conn,
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
 	     "%s", silc_client_command_status_message(status));
     COMMAND_REPLY_ERROR;
     goto out;
   }
   
   /* Get channel mode */
-  tmp = silc_argument_get_arg_type(cmd->args, 2, NULL);
-  if (!tmp) {
+  modev = silc_argument_get_arg_type(cmd->args, 2, NULL);
+  if (!modev) {
     COMMAND_REPLY_ERROR;
     goto out;
   }
 
+  /* Take Channel ID */
+  tmp = silc_argument_get_arg_type(cmd->args, 3, &len);
+  if (!tmp)
+    goto out;
+  channel_id = silc_id_payload_parse_id(tmp, len);
+  if (!channel_id)
+    goto out;
+
+  /* Get the channel entry */
+  if (!silc_idcache_find_by_id_one(conn->channel_cache, (void *)channel_id,
+				   &id_cache)) {
+    silc_free(channel_id);
+    COMMAND_REPLY_ERROR;
+    goto out;
+  }
+  
+  channel = (SilcChannelEntry)id_cache->context;
+
   /* Get Client ID */
-  id = silc_argument_get_arg_type(cmd->args, 3, &len);
+  id = silc_argument_get_arg_type(cmd->args, 4, &len);
   if (!id) {
+    silc_free(channel_id);
     COMMAND_REPLY_ERROR;
     goto out;
   }
   client_id = silc_id_payload_parse_id(id, len);
   if (!client_id) {
+    silc_free(channel_id);
     COMMAND_REPLY_ERROR;
     goto out;
   }
   
   /* Get client entry */
-  if (!silc_idcache_find_by_id_one(conn->client_cache, (void *)client_id,
-				   SILC_ID_CLIENT, &id_cache)) {
+  if (!silc_idcache_find_by_id_one_ext(conn->client_cache, (void *)client_id, 
+				       NULL, NULL, 
+				       silc_hash_client_id_compare, NULL,
+				       &id_cache)) {
+    silc_free(channel_id);
+    silc_free(client_id);
     COMMAND_REPLY_ERROR;
     goto out;
   }
 
+  client_entry = (SilcClientEntry)id_cache->context;
+
+  /* Save the mode */
+  SILC_GET32_MSB(mode, modev);
+  silc_list_start(channel->clients);
+  while ((chu = silc_list_get(channel->clients)) != SILC_LIST_END) {
+    if (chu->client == client_entry) {
+      chu->mode = mode;
+      break;
+    }
+  }
+
   /* Notify application */
-  COMMAND_REPLY((ARGS, tmp, (SilcClientEntry)id_cache->context));
+  COMMAND_REPLY((ARGS, mode, channel, client_entry));
   silc_free(client_id);
+  silc_free(channel_id);
   
-  /* Execute any pending command callbacks */
-  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_CUMODE);
-
  out:
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_CUMODE);
   SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_CUMODE);
   silc_client_command_reply_free(cmd);
 }
@@ -1020,7 +1355,7 @@ SILC_CLIENT_CMD_REPLY_FUNC(kick)
   tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
   SILC_GET16_MSB(status, tmp);
   if (status != SILC_STATUS_OK) {
-    cmd->client->ops->say(cmd->client, conn,
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
 	     "%s", silc_client_command_status_message(status));
     COMMAND_REPLY_ERROR;
     goto out;
@@ -1029,30 +1364,188 @@ SILC_CLIENT_CMD_REPLY_FUNC(kick)
   /* Notify application */
   COMMAND_REPLY((ARGS));
 
-  /* Execute any pending command callbacks */
+ out:
   SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_KICK);
+  SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_KICK);
+  silc_client_command_reply_free(cmd);
+}
+
+SILC_CLIENT_CMD_REPLY_FUNC(silcoper)
+{
+  SilcClientCommandReplyContext cmd = (SilcClientCommandReplyContext)context;
+  SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
+  SilcCommandStatus status;
+  unsigned char *tmp;
+
+  tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
+  SILC_GET16_MSB(status, tmp);
+  if (status != SILC_STATUS_OK) {
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
+	     "%s", silc_client_command_status_message(status));
+    COMMAND_REPLY_ERROR;
+    goto out;
+  }
+
+  /* Notify application */
+  COMMAND_REPLY((ARGS));
 
  out:
-  SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_KICK);
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_SILCOPER);
+  SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_SILCOPER);
   silc_client_command_reply_free(cmd);
 }
 
-SILC_CLIENT_CMD_REPLY_FUNC(restart)
+SILC_CLIENT_CMD_REPLY_FUNC(oper)
 {
+  SilcClientCommandReplyContext cmd = (SilcClientCommandReplyContext)context;
+  SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
+  SilcCommandStatus status;
+  unsigned char *tmp;
+
+  tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
+  SILC_GET16_MSB(status, tmp);
+  if (status != SILC_STATUS_OK) {
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
+	     "%s", silc_client_command_status_message(status));
+    COMMAND_REPLY_ERROR;
+    goto out;
+  }
+
+  /* Notify application */
+  COMMAND_REPLY((ARGS));
+
+ out:
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_OPER);
+  SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_OPER);
+  silc_client_command_reply_free(cmd);
 }
- 
-SILC_CLIENT_CMD_REPLY_FUNC(close)
+
+SILC_CLIENT_CMD_REPLY_FUNC(connect)
 {
+  SilcClientCommandReplyContext cmd = (SilcClientCommandReplyContext)context;
+  SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
+  SilcCommandStatus status;
+  unsigned char *tmp;
+
+  tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
+  SILC_GET16_MSB(status, tmp);
+  if (status != SILC_STATUS_OK) {
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
+	     "%s", silc_client_command_status_message(status));
+    COMMAND_REPLY_ERROR;
+    goto out;
+  }
+
+  /* Notify application */
+  COMMAND_REPLY((ARGS));
+
+ out:
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_CONNECT);
+  SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_CONNECT);
+  silc_client_command_reply_free(cmd);
 }
- 
-SILC_CLIENT_CMD_REPLY_FUNC(die)
+
+SILC_CLIENT_CMD_REPLY_FUNC(ban)
 {
+  SilcClientCommandReplyContext cmd = (SilcClientCommandReplyContext)context;
+  SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
+  SilcCommandStatus status;
+  SilcIDCacheEntry id_cache = NULL;
+  SilcChannelEntry channel;
+  SilcChannelID *channel_id;
+  unsigned char *tmp;
+  uint32 len;
+
+  tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
+  SILC_GET16_MSB(status, tmp);
+  if (status != SILC_STATUS_OK) {
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
+	     "%s", silc_client_command_status_message(status));
+    COMMAND_REPLY_ERROR;
+    goto out;
+  }
+
+  /* Take Channel ID */
+  tmp = silc_argument_get_arg_type(cmd->args, 2, &len);
+  if (!tmp)
+    goto out;
+
+  channel_id = silc_id_payload_parse_id(tmp, len);
+  if (!channel_id)
+    goto out;
+
+  /* Get the channel entry */
+  if (!silc_idcache_find_by_id_one(conn->channel_cache, (void *)channel_id,
+				   &id_cache)) {
+    silc_free(channel_id);
+    COMMAND_REPLY_ERROR;
+    goto out;
+  }
+  
+  channel = (SilcChannelEntry)id_cache->context;
+
+  /* Get the ban list */
+  tmp = silc_argument_get_arg_type(cmd->args, 3, &len);
+
+  /* Notify application */
+  COMMAND_REPLY((ARGS, channel, tmp));
+
+ out:
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_BAN);
+  SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_BAN);
+  silc_client_command_reply_free(cmd);
 }
- 
-SILC_CLIENT_CMD_REPLY_FUNC(silcoper)
+
+SILC_CLIENT_CMD_REPLY_FUNC(close)
 {
+  SilcClientCommandReplyContext cmd = (SilcClientCommandReplyContext)context;
+  SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
+  SilcCommandStatus status;
+  unsigned char *tmp;
+
+  tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
+  SILC_GET16_MSB(status, tmp);
+  if (status != SILC_STATUS_OK) {
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
+	     "%s", silc_client_command_status_message(status));
+    COMMAND_REPLY_ERROR;
+    goto out;
+  }
+
+  /* Notify application */
+  COMMAND_REPLY((ARGS));
+
+ out:
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_CLOSE);
+  SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_CLOSE);
+  silc_client_command_reply_free(cmd);
 }
+ 
+SILC_CLIENT_CMD_REPLY_FUNC(shutdown)
+{
+  SilcClientCommandReplyContext cmd = (SilcClientCommandReplyContext)context;
+  SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
+  SilcCommandStatus status;
+  unsigned char *tmp;
 
+  tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
+  SILC_GET16_MSB(status, tmp);
+  if (status != SILC_STATUS_OK) {
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
+	     "%s", silc_client_command_status_message(status));
+    COMMAND_REPLY_ERROR;
+    goto out;
+  }
+
+  /* Notify application */
+  COMMAND_REPLY((ARGS));
+
+ out:
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_SHUTDOWN);
+  SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_SHUTDOWN);
+  silc_client_command_reply_free(cmd);
+}
+ 
 /* Reply to LEAVE command. */
 
 SILC_CLIENT_CMD_REPLY_FUNC(leave)
@@ -1065,7 +1558,7 @@ SILC_CLIENT_CMD_REPLY_FUNC(leave)
   tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
   SILC_GET16_MSB(status, tmp);
   if (status != SILC_STATUS_OK) {
-    cmd->client->ops->say(cmd->client, conn,
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
 	     "%s", silc_client_command_status_message(status));
     COMMAND_REPLY_ERROR;
     goto out;
@@ -1074,10 +1567,8 @@ SILC_CLIENT_CMD_REPLY_FUNC(leave)
   /* Notify application */
   COMMAND_REPLY((ARGS));
 
-  /* Execute any pending command callbacks */
-  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_LEAVE);
-
  out:
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_LEAVE);
   SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_LEAVE);
   silc_client_command_reply_free(cmd);
 }
@@ -1094,20 +1585,20 @@ SILC_CLIENT_CMD_REPLY_FUNC(users)
   SilcChannelEntry channel;
   SilcChannelUser chu;
   SilcChannelID *channel_id = NULL;
-  SilcBuffer client_id_list;
-  SilcBuffer client_mode_list;
+  SilcBuffer client_id_list = NULL;
+  SilcBuffer client_mode_list = NULL;
   unsigned char *tmp;
-  unsigned int tmp_len, list_count;
+  uint32 tmp_len, list_count;
   int i;
   unsigned char **res_argv = NULL;
-  unsigned int *res_argv_lens = NULL, *res_argv_types = NULL, res_argc = 0;
+  uint32 *res_argv_lens = NULL, *res_argv_types = NULL, res_argc = 0;
 
   SILC_LOG_DEBUG(("Start"));
 
   tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
   SILC_GET16_MSB(status, tmp);
   if (status != SILC_STATUS_OK) {
-    cmd->client->ops->say(cmd->client, conn,
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
 	     "%s", silc_client_command_status_message(status));
     COMMAND_REPLY_ERROR;
     goto out;
@@ -1115,22 +1606,30 @@ SILC_CLIENT_CMD_REPLY_FUNC(users)
 
   /* Get channel ID */
   tmp = silc_argument_get_arg_type(cmd->args, 2, &tmp_len);
-  if (!tmp)
+  if (!tmp) {
+    COMMAND_REPLY_ERROR;
     goto out;
+  }
   channel_id = silc_id_payload_parse_id(tmp, tmp_len);
-  if (!channel_id)
+  if (!channel_id) {
+    COMMAND_REPLY_ERROR;
     goto out;
-
+  }
+  
   /* Get the list count */
   tmp = silc_argument_get_arg_type(cmd->args, 3, &tmp_len);
-  if (!tmp)
+  if (!tmp) {
+    COMMAND_REPLY_ERROR;
     goto out;
+  }
   SILC_GET32_MSB(list_count, tmp);
 
   /* Get Client ID list */
   tmp = silc_argument_get_arg_type(cmd->args, 4, &tmp_len);
-  if (!tmp)
+  if (!tmp) {
+    COMMAND_REPLY_ERROR;
     goto out;
+  }
 
   client_id_list = silc_buffer_alloc(tmp_len);
   silc_buffer_pull_tail(client_id_list, tmp_len);
@@ -1138,8 +1637,10 @@ SILC_CLIENT_CMD_REPLY_FUNC(users)
 
   /* Get client mode list */
   tmp = silc_argument_get_arg_type(cmd->args, 5, &tmp_len);
-  if (!tmp)
+  if (!tmp) {
+    COMMAND_REPLY_ERROR;
     goto out;
+  }
 
   client_mode_list = silc_buffer_alloc(tmp_len);
   silc_buffer_pull_tail(client_mode_list, tmp_len);
@@ -1147,11 +1648,19 @@ SILC_CLIENT_CMD_REPLY_FUNC(users)
 
   /* Get channel entry */
   if (!silc_idcache_find_by_id_one(conn->channel_cache, (void *)channel_id,
-                                   SILC_ID_CHANNEL, &id_cache)) {
-    COMMAND_REPLY_ERROR;
-    goto out;
+				   &id_cache)) {
+    /* Resolve the channel from server */
+    silc_idlist_get_channel_by_id(cmd->client, conn, channel_id, TRUE);
+    
+    /* Register pending command callback. After we've received the channel
+       information we will reprocess this command reply by re-calling this
+       USERS command reply callback. */
+    silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY, conn->cmd_ident,
+				NULL, silc_client_command_reply_users, cmd);
+    return;
+  } else {
+    channel = (SilcChannelEntry)id_cache->context;
   }
-  channel = (SilcChannelEntry)id_cache->context;
 
   /* Remove old client list from channel. */
   silc_list_start(channel->clients);
@@ -1160,12 +1669,10 @@ SILC_CLIENT_CMD_REPLY_FUNC(users)
     silc_free(chu);
   }
 
-  /* Cache the received Client ID's and modes. This cache expires
-     whenever server sends notify message to channel. It means two things;
-     some user has joined or leaved the channel. XXX! */
+  /* Cache the received Client ID's and modes. */
   for (i = 0; i < list_count; i++) {
-    unsigned short idp_len;
-    unsigned int mode;
+    uint16 idp_len;
+    uint32 mode;
     SilcClientID *client_id;
     SilcClientEntry client;
 
@@ -1180,10 +1687,18 @@ SILC_CLIENT_CMD_REPLY_FUNC(users)
     SILC_GET32_MSB(mode, client_mode_list->data);
 
     /* Check if we have this client cached already. */
-    if (!silc_idcache_find_by_id_one(conn->client_cache, (void *)client_id,
-				     SILC_ID_CLIENT, &id_cache)) {
-      /* No we don't have it, query it from the server. Assemble argument
-	 table that will be sent fr the IDENTIFY command later. */
+    id_cache = NULL;
+    silc_idcache_find_by_id_one_ext(conn->client_cache, 
+				    (void *)client_id, 
+				    NULL, NULL, 
+				    silc_hash_client_id_compare, NULL,
+				    &id_cache);
+
+    if (!id_cache || !((SilcClientEntry)id_cache->context)->username ||
+	!((SilcClientEntry)id_cache->context)->realname) {
+      /* No we don't have it (or it is incomplete in information), query
+	 it from the server. Assemble argument table that will be sent
+	 for the WHOIS command later. */
       res_argv = silc_realloc(res_argv, sizeof(*res_argv) *
 			      (res_argc + 1));
       res_argv_lens = silc_realloc(res_argv_lens, sizeof(*res_argv_lens) *
@@ -1215,18 +1730,18 @@ SILC_CLIENT_CMD_REPLY_FUNC(users)
   if (res_argc) {
     SilcBuffer res_cmd;
 
-    /* Send the IDENTIFY command to server */
-    res_cmd = silc_command_payload_encode(SILC_COMMAND_IDENTIFY,
+    /* Send the WHOIS command to server */
+    res_cmd = silc_command_payload_encode(SILC_COMMAND_WHOIS,
 					  res_argc, res_argv, res_argv_lens,
 					  res_argv_types, ++conn->cmd_ident);
     silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, 
 			    NULL, 0, NULL, NULL, res_cmd->data, res_cmd->len,
 			    TRUE);
 
-    /* Register pending command callback. After we've received the IDENTIFY
+    /* Register pending command callback. After we've received the WHOIS
        command reply we will reprocess this command reply by re-calling this
        USERS command reply callback. */
-    silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY, conn->cmd_ident,
+    silc_client_command_pending(conn, SILC_COMMAND_WHOIS, conn->cmd_ident,
 				NULL, silc_client_command_reply_users, cmd);
 
     silc_buffer_free(res_cmd);
@@ -1239,59 +1754,122 @@ SILC_CLIENT_CMD_REPLY_FUNC(users)
     return;
   }
 
-  /* We have all the clients on the channel cached now. Create a nice
-     output for user interface and notify application. */
+  /* Notify application */
+  COMMAND_REPLY((ARGS, channel, list_count, client_id_list, client_mode_list));
+
+ out:
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_USERS);
+  SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_USERS);
+  silc_client_command_reply_free(cmd);
+  silc_free(channel_id);
+  if (client_id_list)
+    silc_buffer_free(client_id_list);
+  if (client_mode_list)
+    silc_buffer_free(client_mode_list);
+}
+
+/* Received command reply to GETKEY command. WE've received the remote
+   client's public key. */
 
-  if (!cmd->callback) {
-    /* Server has sent us USERS reply even when we haven't actually sent
-       USERS command. This is normal behaviour when joining to a channel.
-       Display some nice information on the user interface. */
-    int k = 0, len1 = 0, len2 = 0;
-    char *name_list = NULL;
+SILC_CLIENT_CMD_REPLY_FUNC(getkey)
+{
+  SilcClientCommandReplyContext cmd = (SilcClientCommandReplyContext)context;
+  SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
+  SilcCommandStatus status;
+  SilcIDCacheEntry id_cache;
+  SilcIDPayload idp = NULL;
+  SilcClientID *client_id = NULL;
+  SilcClientEntry client_entry;
+  SilcServerID *server_id = NULL;
+  SilcServerEntry server_entry;
+  SilcSKEPKType type;
+  unsigned char *tmp, *pk;
+  uint32 len;
+  uint16 pk_len;
+  SilcIdType id_type;
+  SilcPublicKey public_key = NULL;
 
-    silc_list_start(channel->clients);
-    while ((chu = silc_list_get(channel->clients)) != SILC_LIST_END) {
-      char *m, *n = chu->client->nickname;
-      len2 = strlen(n);
-      len1 += len2;
+  SILC_LOG_DEBUG(("Start"));
 
-      name_list = silc_realloc(name_list, sizeof(*name_list) * (len1 + 3));
+  tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
+  SILC_GET16_MSB(status, tmp);
+  if (status != SILC_STATUS_OK) {
+    cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
+			  "%s", silc_client_command_status_message(status));
+    COMMAND_REPLY_ERROR;
+    goto out;
+  }
 
-      m = silc_client_chumode_char(chu->mode);
-      if (m) {
-	memcpy(name_list + (len1 - len2), m, strlen(m));
-	len1 += strlen(m);
-	silc_free(m);
-      }
+  tmp = silc_argument_get_arg_type(cmd->args, 2, &len);
+  if (!tmp) {
+    COMMAND_REPLY_ERROR;
+    goto out;
+  }
+  idp = silc_id_payload_parse_data(tmp, len);
+  if (!idp) {
+    COMMAND_REPLY_ERROR;
+    goto out;
+  }
 
-      memcpy(name_list + (len1 - len2), n, len2);
-      name_list[len1] = 0;
-      
-      if (k == silc_list_count(channel->clients) - 1)
-	break;
-      memcpy(name_list + len1, " ", 1);
-      len1++;
-      k++;
+  /* Get the public key payload */
+  tmp = silc_argument_get_arg_type(cmd->args, 3, &len);
+  if (tmp) {
+    /* Decode the public key */
+    SILC_GET16_MSB(pk_len, tmp);
+    SILC_GET16_MSB(type, tmp + 2);
+    pk = tmp + 4;
+    
+    if (type != SILC_SKE_PK_TYPE_SILC) {
+      COMMAND_REPLY_ERROR;
+      goto out;
+    }
+    
+    if (!silc_pkcs_public_key_decode(pk, pk_len, &public_key)) {
+      COMMAND_REPLY_ERROR;
+      goto out;
+    }
+  } 
+   
+  id_type = silc_id_payload_get_type(idp);
+  if (id_type == SILC_ID_CLIENT) {
+    /* Received client's public key */
+    client_id = silc_id_payload_get_id(idp);
+    if (!silc_idcache_find_by_id_one_ext(conn->client_cache, 
+					 (void *)client_id, 
+					 NULL, NULL, 
+					 silc_hash_client_id_compare, NULL,
+					 &id_cache)) {
+      COMMAND_REPLY_ERROR;
+      goto out;
     }
 
-    cmd->client->ops->say(cmd->client, conn, "Users on %s: %s",
-			  channel->channel_name, name_list);
-    silc_free(name_list);
-  }
+    client_entry = (SilcClientEntry)id_cache->context;
 
-  /* Notify application */
-  COMMAND_REPLY((ARGS, channel, client_id_list->head,
-		 client_mode_list->head));
+    /* Notify application */
+    COMMAND_REPLY((ARGS, id_type, client_entry, public_key));
+  } else if (id_type == SILC_ID_SERVER) {
+    /* Received server's public key */
+    server_id = silc_id_payload_get_id(idp);
+    if (!silc_idcache_find_by_id_one(conn->server_cache, (void *)server_id,
+				     &id_cache)) {
+      COMMAND_REPLY_ERROR;
+      goto out;
+    }
 
-  /* Execute any pending command callbacks */
-  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_USERS);
+    server_entry = (SilcServerEntry)id_cache->context;
 
-  silc_buffer_free(client_id_list);
-  silc_buffer_free(client_mode_list);
+    /* Notify application */
+    COMMAND_REPLY((ARGS, id_type, server_entry, public_key));
+  }
 
  out:
-  if (channel_id)
-    silc_free(channel_id);
-  SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_USERS);
+  SILC_CLIENT_PENDING_EXEC(cmd, SILC_COMMAND_GETKEY);
+  SILC_CLIENT_PENDING_DESTRUCTOR(cmd, SILC_COMMAND_GETKEY);
+  if (idp)
+    silc_id_payload_free(idp);
+  if (public_key)
+    silc_pkcs_public_key_free(public_key);
+  silc_free(client_id);
+  silc_free(server_id);
   silc_client_command_reply_free(cmd);
 }