X-Git-Url: http://git.silcnet.org/gitweb/?p=silc.git;a=blobdiff_plain;f=lib%2Fsilcclient%2Fcommand_reply.c;h=ede887535fdcdc97b6219d0c8d73f11b45867021;hp=f5adc9c231b95e6ed856c9d0e55a6fc7033ce092;hb=HEAD;hpb=598a79d875c80b1f6cbee2ae78198cbff46ab7dc

diff --git a/lib/silcclient/command_reply.c b/lib/silcclient/command_reply.c
index f5adc9c2..ede88753 100644
--- a/lib/silcclient/command_reply.c
+++ b/lib/silcclient/command_reply.c
@@ -4,7 +4,7 @@
 
   Author: Pekka Riikonen <priikone@silcnet.org>
 
-  Copyright (C) 1997 - 2006 Pekka Riikonen
+  Copyright (C) 1997 - 2007 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
@@ -25,13 +25,13 @@
 /************************** Types and definitions ***************************/
 
 /* Calls error command reply callback back to command sender. */
-#define ERROR_CALLBACK(error)					\
+#define ERROR_CALLBACK(err)					\
 do {								\
   void *arg1 = NULL, *arg2 = NULL;				\
   if (cmd->status != SILC_STATUS_OK)				\
     silc_status_get_args(cmd->status, args, &arg1, &arg2);	\
   else								\
-    cmd->status = error;					\
+    cmd->status = cmd->error = err;				\
   SILC_LOG_DEBUG(("Error in command reply: %s",			\
 		 silc_get_status_message(cmd->status)));	\
   silc_client_command_callback(cmd, arg1, arg2);		\
@@ -42,7 +42,7 @@ do {								\
   SILC_LOG_DEBUG(("%s", silc_get_command_name(cmd->cmd)));		\
   if (cmd->error != SILC_STATUS_OK) {					\
     if (cmd->verbose)							\
-      SAY(cmd->conn->client, cmd->conn, SILC_CLIENT_MESSAGE_ERROR,	\
+      SAY(cmd->conn->client, cmd->conn, SILC_CLIENT_MESSAGE_COMMAND_ERROR, \
 	  msg "%s", silc_get_status_message(cmd->error));		\
     ERROR_CALLBACK(cmd->error);						\
     silc_client_command_process_error(cmd, state_context, cmd->error);	\
@@ -69,6 +69,7 @@ static inline void
 silc_client_command_callback(SilcClientCommandContext cmd, ...)
 {
   SilcClientCommandReplyCallback cb;
+  SilcList list;
   va_list ap, cp;
 
   va_start(ap, cmd);
@@ -83,8 +84,9 @@ silc_client_command_callback(SilcClientCommandContext cmd, ...)
   }
 
   /* Reply callback */
-  silc_list_start(cmd->reply_callbacks);
-  while ((cb = silc_list_get(cmd->reply_callbacks)))
+  list = cmd->reply_callbacks;
+  silc_list_start(list);
+  while ((cb = silc_list_get(list)))
     if (!cb->do_not_call) {
       silc_va_copy(cp, ap);
       cb->do_not_call = !cb->reply(cmd->conn->client, cmd->conn, cmd->cmd,
@@ -104,19 +106,54 @@ static void silc_client_command_process_error(SilcClientCommandContext cmd,
   SilcClient client = cmd->conn->client;
   SilcClientConnection conn = cmd->conn;
   SilcArgumentPayload args = silc_command_get_args(payload);
-  SilcClientEntry client_entry;
   SilcID id;
 
   if (cmd->error == SILC_STATUS_ERR_NO_SUCH_CLIENT_ID) {
+    SilcClientEntry client_entry;
+
     /* Remove unknown client entry from cache */
     if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL))
       return;
 
     client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
     if (client_entry) {
-      silc_client_unref_client(client, conn, client_entry);
+      silc_client_remove_from_channels(client, conn, client_entry);
+      client_entry->internal.valid = FALSE;
       silc_client_del_client(client, conn, client_entry);
+      silc_client_unref_client(client, conn, client_entry);
+    }
+    return;
+  }
+
+  if (cmd->error == SILC_STATUS_ERR_NO_SUCH_CHANNEL_ID) {
+    SilcChannelEntry channel;
+
+    /* Remove unknown channel entry from cache */
+    if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL))
+      return;
+
+    channel = silc_client_get_channel_by_id(client, conn, &id.u.channel_id);
+    if (channel) {
+      silc_client_empty_channel(client, conn, channel);
+      silc_client_del_channel(client, conn, channel);
+      silc_client_unref_channel(client, conn, channel);
+    }
+    return;
+  }
+
+  if (cmd->error == SILC_STATUS_ERR_NO_SUCH_SERVER_ID) {
+    SilcServerEntry server_entry;
+
+    /* Remove unknown server entry from cache */
+    if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL))
+      return;
+
+    server_entry = silc_client_get_server_by_id(client, conn, &id.u.server_id);
+    if (server_entry) {
+      silc_client_del_server(client, conn, server_entry);
+      silc_client_unref_server(client, conn, server_entry);
     }
+    return;
   }
 }
 
@@ -163,7 +200,10 @@ SILC_FSM_STATE(silc_client_command_reply)
     return SILC_FSM_FINISH;
   }
 
-  /* Signal command thread that command reply has arrived */
+  /* Signal command thread that command reply has arrived.  We continue
+     command reply processing synchronously because we save the command
+     payload into state context.  No other reply may arrive to this command
+     while we're processing this reply. */
   silc_fsm_set_state_context(&cmd->thread, payload);
   silc_fsm_next(&cmd->thread, silc_client_command_reply_process);
   silc_fsm_continue_sync(&cmd->thread);
@@ -175,11 +215,14 @@ SILC_FSM_STATE(silc_client_command_reply)
 
 SILC_FSM_STATE(silc_client_command_reply_wait)
 {
+  SilcClientCommandContext cmd = fsm_context;
+
   SILC_LOG_DEBUG(("Wait for command reply"));
 
   /** Wait for command reply */
   silc_fsm_set_state_context(fsm, NULL);
-  silc_fsm_next_later(fsm, silc_client_command_reply_timeout, 20, 0);
+  silc_fsm_next_later(fsm, silc_client_command_reply_timeout,
+		      cmd->cmd != SILC_COMMAND_PING ? 40 : 60, 0);
   return SILC_FSM_WAIT;
 }
 
@@ -191,6 +234,14 @@ SILC_FSM_STATE(silc_client_command_reply_timeout)
   SilcClientConnection conn = cmd->conn;
   SilcArgumentPayload args = NULL;
 
+  if (conn->internal->disconnected) {
+    SILC_LOG_DEBUG(("Command %s canceled", silc_get_command_name(cmd->cmd)));
+    silc_list_del(conn->internal->pending_commands, cmd);
+    if (!cmd->called)
+      ERROR_CALLBACK(SILC_STATUS_ERR_TIMEDOUT);
+    return SILC_FSM_FINISH;
+  }
+
   SILC_LOG_DEBUG(("Command %s timeout", silc_get_command_name(cmd->cmd)));
 
   /* Timeout, reply not received in timely fashion */
@@ -424,7 +475,7 @@ SILC_FSM_STATE(silc_client_command_reply_whois)
       silc_client_add_client(client, conn, nickname, username, realname,
 			     &id.u.client_id, mode);
     if (!client_entry) {
-      ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
+      ERROR_CALLBACK(SILC_STATUS_ERR_RESOURCE_LIMIT);
       goto out;
     }
     silc_client_ref_client(client, conn, client_entry);
@@ -433,6 +484,8 @@ SILC_FSM_STATE(silc_client_command_reply_whois)
 			      nickname, username, realname, mode);
   }
 
+  silc_rwlock_wrlock(client_entry->internal.lock);
+
   if (fingerprint && fingerprint_len == sizeof(client_entry->fingerprint))
     memcpy(client_entry->fingerprint, fingerprint, fingerprint_len);
 
@@ -444,6 +497,8 @@ SILC_FSM_STATE(silc_client_command_reply_whois)
     client_entry->attrs = silc_attribute_payload_parse(tmp, len);
   }
 
+  silc_rwlock_unlock(client_entry->internal.lock);
+
   /* Parse channel and channel user mode list */
   if (has_channels) {
     channel_list = silc_channel_payload_parse_list(silc_buffer_data(&channels),
@@ -460,7 +515,7 @@ SILC_FSM_STATE(silc_client_command_reply_whois)
 
   silc_client_unref_client(client, conn, client_entry);
   if (has_channels) {
-    silc_dlist_uninit(channel_list);
+    silc_channel_payload_list_free(channel_list);
     silc_free(umodes);
   }
 
@@ -560,7 +615,7 @@ SILC_FSM_STATE(silc_client_command_reply_identify)
 	silc_client_add_client(client, conn, name, info, NULL,
 			       &id.u.client_id, 0);
       if (!client_entry) {
-	ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
+	ERROR_CALLBACK(SILC_STATUS_ERR_RESOURCE_LIMIT);
 	goto out;
       }
       silc_client_ref_client(client, conn, client_entry);
@@ -605,7 +660,7 @@ SILC_FSM_STATE(silc_client_command_reply_identify)
     channel_entry = silc_client_get_channel_by_id(client, conn,
 						  &id.u.channel_id);
     if (!channel_entry) {
-      SILC_LOG_DEBUG(("Adding new channel entry (IDENTIFY"));
+      SILC_LOG_DEBUG(("Adding new channel entry (IDENTIFY)"));
 
       if (!name) {
 	ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
@@ -623,7 +678,8 @@ SILC_FSM_STATE(silc_client_command_reply_identify)
     }
 
     /* Notify application */
-    silc_client_command_callback(cmd, channel_entry, name, info);
+    silc_client_command_callback(cmd, channel_entry,
+				 channel_entry->channel_name, info);
     silc_client_unref_channel(client, conn, channel_entry);
     break;
   }
@@ -644,7 +700,7 @@ SILC_FSM_STATE(silc_client_command_reply_nick)
   SilcClient client = conn->client;
   SilcCommandPayload payload = state_context;
   SilcArgumentPayload args = silc_command_get_args(payload);
-  unsigned char *tmp, *nick, *idp;
+  unsigned char *nick, *idp;
   SilcUInt32 len, idp_len;
   SilcClientID old_client_id;
   SilcID id;
@@ -653,8 +709,6 @@ SILC_FSM_STATE(silc_client_command_reply_nick)
   CHECK_STATUS("Cannot set nickname: ");
   CHECK_ARGS(2, 3);
 
-  old_client_id = *conn->local_id;
-
   /* Take received Client ID */
   idp = silc_argument_get_arg_type(args, 2, &idp_len);
   if (!idp) {
@@ -673,31 +727,18 @@ SILC_FSM_STATE(silc_client_command_reply_nick)
     goto out;
   }
 
-  /* Normalize nickname */
-  tmp = silc_identifier_check(nick, len, SILC_STRING_UTF8, 128, NULL);
-  if (!tmp) {
-    ERROR_CALLBACK(SILC_STATUS_ERR_BAD_NICKNAME);
-    goto out;
-  }
+  silc_rwlock_wrlock(conn->local_entry->internal.lock);
 
-  /* Update the client entry */
-  silc_mutex_lock(conn->internal->lock);
-  if (!silc_idcache_update(conn->internal->client_cache,
-			   conn->internal->local_entry,
-			   &id.u.client_id, tmp, TRUE)) {
-    silc_free(tmp);
-    silc_mutex_unlock(conn->internal->lock);
+  /* Change the nickname */
+  old_client_id = *conn->local_id;
+  if (!silc_client_change_nickname(client, conn, conn->local_entry,
+				   nick, &id.u.client_id, idp, idp_len)) {
     ERROR_CALLBACK(SILC_STATUS_ERR_BAD_NICKNAME);
+    silc_rwlock_unlock(conn->local_entry->internal.lock);
     goto out;
   }
-  silc_mutex_unlock(conn->internal->lock);
-  memset(conn->local_entry->nickname, 0, sizeof(conn->local_entry->nickname));
-  memcpy(conn->local_entry->nickname, nick, len);
-  conn->local_entry->nickname_normalized = tmp;
-  silc_buffer_enlarge(conn->internal->local_idp, idp_len);
-  silc_buffer_put(conn->internal->local_idp, idp, idp_len);
-  silc_client_nickname_format(client, conn, conn->local_entry);
-  silc_packet_set_ids(conn->stream, SILC_ID_CLIENT, conn->local_id, 0, NULL);
+
+  silc_rwlock_unlock(conn->local_entry->internal.lock);
 
   /* Notify application */
   silc_client_command_callback(cmd, conn->local_entry,
@@ -762,7 +803,8 @@ SILC_FSM_STATE(silc_client_command_reply_list)
   }
 
   /* Notify application */
-  silc_client_command_callback(cmd, channel_entry, name, topic, usercount);
+  silc_client_command_callback(cmd, channel_entry, channel_entry->channel_name,
+			       topic, usercount);
 
  out:
   silc_client_unref_channel(client, conn, channel_entry);
@@ -781,7 +823,7 @@ SILC_FSM_STATE(silc_client_command_reply_topic)
   SilcClient client = conn->client;
   SilcCommandPayload payload = state_context;
   SilcArgumentPayload args = silc_command_get_args(payload);
-  SilcChannelEntry channel;
+  SilcChannelEntry channel = NULL;
   char *topic;
   SilcUInt32 len;
   SilcID id;
@@ -803,6 +845,8 @@ SILC_FSM_STATE(silc_client_command_reply_topic)
     goto out;
   }
 
+  silc_rwlock_wrlock(channel->internal.lock);
+
   /* Take topic */
   topic = silc_argument_get_arg_type(args, 3, &len);
   if (topic) {
@@ -810,10 +854,13 @@ SILC_FSM_STATE(silc_client_command_reply_topic)
     channel->topic = silc_memdup(topic, len);
   }
 
+  silc_rwlock_unlock(channel->internal.lock);
+
   /* Notify application */
   silc_client_command_callback(cmd, channel, channel->topic);
 
  out:
+  silc_client_unref_channel(client, conn, channel);
   silc_fsm_next(fsm, silc_client_command_reply_processed);
   return SILC_FSM_CONTINUE;
 }
@@ -829,7 +876,7 @@ SILC_FSM_STATE(silc_client_command_reply_invite)
   SilcClient client = conn->client;
   SilcCommandPayload payload = state_context;
   SilcArgumentPayload args = silc_command_get_args(payload);
-  SilcChannelEntry channel;
+  SilcChannelEntry channel = NULL;
   unsigned char *tmp;
   SilcUInt32 len;
   SilcArgumentPayload invite_args = NULL;
@@ -864,6 +911,7 @@ SILC_FSM_STATE(silc_client_command_reply_invite)
     silc_argument_payload_free(invite_args);
 
  out:
+  silc_client_unref_channel(client, conn, channel);
   silc_fsm_next(fsm, silc_client_command_reply_processed);
   return SILC_FSM_CONTINUE;
 }
@@ -897,8 +945,10 @@ SILC_FSM_STATE(silc_client_command_reply_kill)
   /* Notify application */
   silc_client_command_callback(cmd, client_entry);
 
-  /* Remove the client from all channels and free it */
+  /* Remove the client */
   if (client_entry) {
+    silc_client_remove_from_channels(client, conn, client_entry);
+    client_entry->internal.valid = FALSE;
     silc_client_del_client(client, conn, client_entry);
     silc_client_unref_client(client, conn, client_entry);
   }
@@ -1063,11 +1113,34 @@ silc_client_command_reply_join_resolved(SilcClient client,
 {
   SilcClientCommandContext cmd = context;
   SilcChannelEntry channel = cmd->context;
+  SilcCommandPayload payload = silc_fsm_get_state_context(&cmd->thread);
+  SilcArgumentPayload args = silc_command_get_args(payload);
+  SilcUInt32 list_count;
+  unsigned char *tmp;
+  char msg[512];
+
+  if (!clients) {
+    silc_snprintf(msg, sizeof(msg), "Error resolving channel %s user list",
+		  channel->channel_name);
+    SAY(client, conn, SILC_CLIENT_MESSAGE_COMMAND_ERROR, msg);
+  } else {
+    tmp = silc_argument_get_arg_type(args, 12, NULL);
+    if (tmp) {
+      SILC_GET32_MSB(list_count, tmp);
+      if (list_count - silc_dlist_count(clients) > 5) {
+	silc_snprintf(msg, sizeof(msg),
+		      "Channel %s user list was not fully resolved. "
+		      "The channel may not be fully synced.",
+		      channel->channel_name);
+	SAY(client, conn, SILC_CLIENT_MESSAGE_WARNING, msg);
+      }
+    }
+  }
 
   channel->internal.resolve_cmd_ident = 0;
   silc_client_unref_channel(client, conn, channel);
 
-  SILC_FSM_CALL_CONTINUE(&cmd->thread);
+  SILC_FSM_CALL_CONTINUE_SYNC(&cmd->thread);
 }
 
 
@@ -1086,7 +1159,6 @@ SILC_FSM_STATE(silc_client_command_reply_join)
   const char *cipher;
   SilcBufferStruct client_id_list, client_mode_list, keyp;
   SilcHashTableList htl;
-  SilcDList chpks = NULL;
   SilcID id;
   int i;
 
@@ -1125,7 +1197,7 @@ SILC_FSM_STATE(silc_client_command_reply_join)
 
   /* Get the list count */
   tmp = silc_argument_get_arg_type(args, 12, &len);
-  if (!tmp) {
+  if (!tmp || len != 4) {
     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
     goto out;
   }
@@ -1158,10 +1230,11 @@ SILC_FSM_STATE(silc_client_command_reply_join)
   }
   silc_buffer_set(&client_mode_list, tmp, len);
 
+  silc_rwlock_wrlock(channel->internal.lock);
+
   /* Add clients we received in the reply to the channel */
   for (i = 0; i < list_count; i++) {
     SilcUInt16 idp_len;
-    SilcUInt32 mode;
     SilcID id;
     SilcClientEntry client_entry;
 
@@ -1176,17 +1249,22 @@ SILC_FSM_STATE(silc_client_command_reply_join)
 
     /* Get client entry */
     client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
-    if (!client_entry)
-      continue;
-
-    /* Join client to the channel */
-    silc_client_add_to_channel(client, conn, channel, client_entry, mode);
+    if (client_entry && client_entry->internal.valid) {
+      /* Join client to the channel */
+      silc_rwlock_wrlock(client_entry->internal.lock);
+      silc_client_add_to_channel(client, conn, channel, client_entry, mode);
+      silc_rwlock_unlock(client_entry->internal.lock);
+    }
     silc_client_unref_client(client, conn, client_entry);
 
-    if (!silc_buffer_pull(&client_id_list, idp_len))
+    if (!silc_buffer_pull(&client_id_list, idp_len)) {
+      silc_rwlock_unlock(channel->internal.lock);
       goto out;
-    if (!silc_buffer_pull(&client_mode_list, 4))
+    }
+    if (!silc_buffer_pull(&client_mode_list, 4)) {
+      silc_rwlock_unlock(channel->internal.lock);
       goto out;
+    }
   }
 
   /* Get hmac */
@@ -1194,24 +1272,30 @@ SILC_FSM_STATE(silc_client_command_reply_join)
   if (hmac) {
     if (!silc_hmac_alloc(hmac, NULL, &channel->internal.hmac)) {
       if (cmd->verbose)
-	SAY(client, conn, SILC_CLIENT_MESSAGE_ERROR,
+	SAY(client, conn, SILC_CLIENT_MESSAGE_COMMAND_ERROR,
 	    "Cannot join channel: Unsupported HMAC `%s'", hmac);
       ERROR_CALLBACK(SILC_STATUS_ERR_UNKNOWN_ALGORITHM);
+      silc_rwlock_unlock(channel->internal.lock);
       goto out;
     }
   }
 
   /* Get channel mode */
-  tmp = silc_argument_get_arg_type(args, 5, NULL);
-  if (tmp)
+  tmp = silc_argument_get_arg_type(args, 5, &len);
+  if (tmp && len == 4)
     SILC_GET32_MSB(mode, tmp);
   channel->mode = mode;
 
   /* Get channel key and save it */
   tmp = silc_argument_get_arg_type(args, 7, &len);
   if (tmp) {
-    silc_buffer_set(&keyp, tmp, len);
-    silc_client_save_channel_key(client, conn, &keyp, channel);
+    /* If channel key already exists on the channel then while resolving
+       the user list we have already received new key from server.  Don't
+       replace it with this old key. */
+    if (!channel->internal.send_key) {
+      silc_buffer_set(&keyp, tmp, len);
+      silc_client_save_channel_key(client, conn, &keyp, channel);
+    }
   }
 
   /* Get topic */
@@ -1240,23 +1324,22 @@ SILC_FSM_STATE(silc_client_command_reply_join)
   /* Get channel public key list */
   tmp = silc_argument_get_arg_type(args, 16, &len);
   if (tmp)
-    chpks = silc_argument_list_parse_decoded(tmp, len,
-					     SILC_ARGUMENT_PUBLIC_KEY);
+    silc_client_channel_save_public_keys(channel, tmp, len, FALSE);
 
   /* Set current channel */
   conn->current_channel = channel;
 
-  cipher = (channel->internal.channel_key ?
-	    silc_cipher_get_name(channel->internal.channel_key) : NULL);
+  silc_rwlock_unlock(channel->internal.lock);
+
+  cipher = (channel->internal.send_key ?
+	    silc_cipher_get_name(channel->internal.send_key) : NULL);
   silc_hash_table_list(channel->user_list, &htl);
 
   /* Notify application */
-  silc_client_command_callback(cmd, channel_name, channel, mode, &htl,
+  silc_client_command_callback(cmd, channel->channel_name, channel, mode, &htl,
 			       topic, cipher, hmac, channel->founder_key,
-			       chpks, channel->user_limit);
+			       channel->channel_pubkeys, channel->user_limit);
 
-  if (chpks)
-    silc_argument_list_free(chpks, SILC_ARGUMENT_PUBLIC_KEY);
   silc_hash_table_list_reset(&htl);
   silc_client_unref_channel(client, conn, channel);
 
@@ -1343,7 +1426,9 @@ SILC_FSM_STATE(silc_client_command_reply_umode)
   }
 
   SILC_GET32_MSB(mode, tmp);
+  silc_rwlock_wrlock(conn->local_entry->internal.lock);
   conn->local_entry->mode = mode;
+  silc_rwlock_unlock(conn->local_entry->internal.lock);
 
   /* Notify application */
   silc_client_command_callback(cmd, mode);
@@ -1366,10 +1451,9 @@ SILC_FSM_STATE(silc_client_command_reply_cmode)
   SilcArgumentPayload args = silc_command_get_args(payload);
   unsigned char *tmp;
   SilcUInt32 mode;
-  SilcChannelEntry channel;
+  SilcChannelEntry channel = NULL;
   SilcUInt32 len;
   SilcPublicKey public_key = NULL;
-  SilcDList channel_pubkeys = NULL;
   SilcID id;
 
   /* Sanity checks */
@@ -1389,21 +1473,20 @@ SILC_FSM_STATE(silc_client_command_reply_cmode)
     goto out;
   }
 
+  /* Get founder public key */
+  tmp = silc_argument_get_arg_type(args, 4, &len);
+  if (tmp)
+    silc_public_key_payload_decode(tmp, len, &public_key);
+
   /* Get channel mode */
   tmp = silc_argument_get_arg_type(args, 3, &len);
   if (!tmp || len != 4) {
     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
     goto out;
   }
-
-  /* Save the mode */
   SILC_GET32_MSB(mode, tmp);
-  channel->mode = mode;
 
-  /* Get founder public key */
-  tmp = silc_argument_get_arg_type(args, 4, &len);
-  if (tmp)
-    silc_public_key_payload_decode(tmp, len, &public_key);
+  silc_rwlock_wrlock(channel->internal.lock);
 
   /* Get user limit */
   tmp = silc_argument_get_arg_type(args, 6, &len);
@@ -1415,16 +1498,35 @@ SILC_FSM_STATE(silc_client_command_reply_cmode)
   /* Get channel public key(s) */
   tmp = silc_argument_get_arg_type(args, 5, &len);
   if (tmp)
-    channel_pubkeys =
-      silc_argument_list_parse_decoded(tmp, len, SILC_ARGUMENT_PUBLIC_KEY);
+    silc_client_channel_save_public_keys(channel, tmp, len, FALSE);
+  else if (channel->mode & SILC_CHANNEL_MODE_CHANNEL_AUTH)
+    silc_client_channel_save_public_keys(channel, NULL, 0, TRUE);
+
+  /* Save the mode */
+  channel->mode = mode;
+
+  silc_rwlock_unlock(channel->internal.lock);
 
   /* Notify application */
   silc_client_command_callback(cmd, channel, mode, public_key,
-			       channel_pubkeys, channel->user_limit);
+			       channel->channel_pubkeys, channel->user_limit);
+
+  silc_rwlock_wrlock(channel->internal.lock);
 
-  silc_argument_list_free(channel_pubkeys, SILC_ARGUMENT_PUBLIC_KEY);
+  /* If founder key changed, update it */
+  if (public_key &&
+      (!channel->founder_key ||
+       !silc_pkcs_public_key_compare(public_key, channel->founder_key))) {
+    if (channel->founder_key)
+      silc_pkcs_public_key_free(channel->founder_key);
+    channel->founder_key = public_key;
+    public_key = NULL;
+  }
+
+  silc_rwlock_unlock(channel->internal.lock);
 
  out:
+  silc_client_unref_channel(client, conn, channel);
   if (public_key)
     silc_pkcs_public_key_free(public_key);
   silc_fsm_next(fsm, silc_client_command_reply_processed);
@@ -1443,7 +1545,7 @@ SILC_FSM_STATE(silc_client_command_reply_cumode)
   SilcCommandPayload payload = state_context;
   SilcArgumentPayload args = silc_command_get_args(payload);
   SilcClientEntry client_entry;
-  SilcChannelEntry channel;
+  SilcChannelEntry channel = NULL;
   SilcChannelUser chu;
   unsigned char *modev;
   SilcUInt32 len, mode;
@@ -1488,9 +1590,11 @@ SILC_FSM_STATE(silc_client_command_reply_cumode)
   }
 
   /* Save the mode */
+  silc_rwlock_wrlock(channel->internal.lock);
   chu = silc_client_on_channel(channel, client_entry);
   if (chu)
     chu->mode = mode;
+  silc_rwlock_unlock(channel->internal.lock);
 
   /* Notify application */
   silc_client_command_callback(cmd, mode, channel, client_entry);
@@ -1498,6 +1602,7 @@ SILC_FSM_STATE(silc_client_command_reply_cumode)
   silc_client_unref_client(client, conn, client_entry);
 
  out:
+  silc_client_unref_channel(client, conn, channel);
   silc_fsm_next(fsm, silc_client_command_reply_processed);
   return SILC_FSM_CONTINUE;
 }
@@ -1512,7 +1617,7 @@ SILC_FSM_STATE(silc_client_command_reply_kick)
   SilcCommandPayload payload = state_context;
   SilcArgumentPayload args = silc_command_get_args(payload);
   SilcClientEntry client_entry;
-  SilcChannelEntry channel;
+  SilcChannelEntry channel = NULL;
   SilcID id;
 
   /* Sanity checks */
@@ -1551,6 +1656,7 @@ SILC_FSM_STATE(silc_client_command_reply_kick)
   silc_client_unref_client(client, conn, client_entry);
 
  out:
+  silc_client_unref_channel(client, conn, channel);
   silc_fsm_next(fsm, silc_client_command_reply_processed);
   return SILC_FSM_CONTINUE;
 }
@@ -1567,6 +1673,9 @@ SILC_FSM_STATE(silc_client_command_reply_silcoper)
   CHECK_STATUS("Cannot change mode: ");
   CHECK_ARGS(1, 1);
 
+  /* Set user mode */
+  cmd->conn->local_entry->mode |= SILC_UMODE_ROUTER_OPERATOR;
+
   /* Notify application */
   silc_client_command_callback(cmd);
 
@@ -1586,6 +1695,9 @@ SILC_FSM_STATE(silc_client_command_reply_oper)
   CHECK_STATUS("Cannot change mode: ");
   CHECK_ARGS(1, 1);
 
+  /* Set user mode */
+  cmd->conn->local_entry->mode |= SILC_UMODE_SERVER_OPERATOR;
+
   /* Notify application */
   silc_client_command_callback(cmd);
 
@@ -1608,20 +1720,18 @@ SILC_FSM_STATE(silc_client_command_reply_detach)
   CHECK_STATUS("Cannot detach: ");
   CHECK_ARGS(1, 1);
 
-  /* Notify application */
-  silc_client_command_callback(cmd);
-
-#if 0
-  /* Generate the detachment data and deliver it to the client in the
-     detach client operation */
+  /* Get detachment data */
   detach = silc_client_get_detach_data(client, conn);
-  if (detach) {
-    client->internal->ops->detach(client, conn, silc_buffer_data(detach),
-				  silc_buffer_len(detach));
-    silc_buffer_free(detach);
+  if (!detach) {
+    ERROR_CALLBACK(SILC_STATUS_ERR_RESOURCE_LIMIT);
+    goto out;
   }
-#endif /* 0 */
 
+  /* Notify application */
+  silc_client_command_callback(cmd, detach);
+  silc_buffer_free(detach);
+
+ out:
   silc_fsm_next(fsm, silc_client_command_reply_processed);
   return SILC_FSM_CONTINUE;
 }
@@ -1654,7 +1764,7 @@ SILC_FSM_STATE(silc_client_command_reply_ban)
   SilcClient client = conn->client;
   SilcCommandPayload payload = state_context;
   SilcArgumentPayload args = silc_command_get_args(payload);
-  SilcChannelEntry channel;
+  SilcChannelEntry channel = NULL;
   unsigned char *tmp;
   SilcUInt32 len;
   SilcArgumentPayload invite_args = NULL;
@@ -1689,6 +1799,7 @@ SILC_FSM_STATE(silc_client_command_reply_ban)
     silc_argument_payload_free(invite_args);
 
  out:
+  silc_client_unref_channel(client, conn, channel);
   silc_fsm_next(fsm, silc_client_command_reply_processed);
   return SILC_FSM_CONTINUE;
 }
@@ -1705,6 +1816,8 @@ SILC_FSM_STATE(silc_client_command_reply_leave)
   SilcCommandPayload payload = state_context;
   SilcArgumentPayload args = silc_command_get_args(payload);
   SilcChannelEntry channel;
+  SilcCipher key;
+  SilcHmac hmac;
   SilcID id;
 
   /* Sanity checks */
@@ -1730,7 +1843,34 @@ SILC_FSM_STATE(silc_client_command_reply_leave)
   /* Notify application */
   silc_client_command_callback(cmd, channel);
 
+  /* Remove old keys and stuff.  The channel may remain even after leaving
+     but we want to remove these always. */
+  if (channel->internal.send_key)
+    silc_cipher_free(channel->internal.send_key);
+  channel->internal.send_key = NULL;
+  if (channel->internal.receive_key)
+    silc_cipher_free(channel->internal.receive_key);
+  channel->internal.receive_key = NULL;
+  if (channel->internal.hmac)
+    silc_hmac_free(channel->internal.hmac);
+  channel->internal.hmac = NULL;
+  if (channel->internal.old_channel_keys) {
+    silc_dlist_start(channel->internal.old_channel_keys);
+    while ((key = silc_dlist_get(channel->internal.old_channel_keys)))
+      silc_cipher_free(key);
+    silc_dlist_uninit(channel->internal.old_channel_keys);
+  }
+  channel->internal.old_channel_keys = NULL;
+  if (channel->internal.old_hmacs) {
+    silc_dlist_start(channel->internal.old_hmacs);
+    while ((hmac = silc_dlist_get(channel->internal.old_hmacs)))
+      silc_hmac_free(hmac);
+    silc_dlist_uninit(channel->internal.old_hmacs);
+  }
+  channel->internal.old_hmacs = NULL;
+
   /* Now delete the channel. */
+  silc_client_empty_channel(client, conn, channel);
   silc_client_del_channel(client, conn, channel);
 
  out:
@@ -1788,11 +1928,11 @@ SILC_FSM_STATE(silc_client_command_reply_users)
   SilcCommandPayload payload = state_context;
   SilcArgumentPayload args = silc_command_get_args(payload);
   unsigned char *tmp;
-  SilcUInt32 tmp_len, list_count;
-  SilcUInt16 idp_len, mode;
+  SilcUInt32 tmp_len, list_count, mode;
+  SilcUInt16 idp_len;
   SilcHashTableList htl;
   SilcBufferStruct client_id_list, client_mode_list;
-  SilcChannelEntry channel;
+  SilcChannelEntry channel = NULL;
   SilcClientEntry client_entry;
   SilcID id;
   int i;
@@ -1836,6 +1976,7 @@ SILC_FSM_STATE(silc_client_command_reply_users)
   /* Resolve users we do not know about */
   if (!cmd->resolved) {
     cmd->resolved = TRUE;
+    silc_client_unref_channel(client, conn, channel);
     SILC_FSM_CALL(silc_client_get_clients_by_list(
 			  client, conn, list_count, &client_id_list,
 			  silc_client_command_reply_users_resolved, cmd));
@@ -1852,6 +1993,8 @@ SILC_FSM_STATE(silc_client_command_reply_users)
 
   SILC_LOG_DEBUG(("channel %s, %d users", channel->channel_name, list_count));
 
+  silc_rwlock_wrlock(channel->internal.lock);
+
   /* Cache the received Client ID's and modes. */
   for (i = 0; i < list_count; i++) {
     SILC_GET16_MSB(idp_len, client_id_list.data + 2);
@@ -1865,22 +2008,32 @@ SILC_FSM_STATE(silc_client_command_reply_users)
     /* Save the client on this channel.  Unknown clients are ignored as they
        clearly do not exist since the resolving didn't find them. */
     client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
-    if (client_entry)
+    if (client_entry && client_entry->internal.valid) {
+      silc_rwlock_wrlock(client_entry->internal.lock);
       silc_client_add_to_channel(client, conn, channel, client_entry, mode);
+      silc_rwlock_unlock(client_entry->internal.lock);
+    }
     silc_client_unref_client(client, conn, client_entry);
 
-    if (!silc_buffer_pull(&client_id_list, idp_len))
+    if (!silc_buffer_pull(&client_id_list, idp_len)) {
+      silc_rwlock_unlock(channel->internal.lock);
       goto out;
-    if (!silc_buffer_pull(&client_mode_list, 4))
+    }
+    if (!silc_buffer_pull(&client_mode_list, 4)) {
+      silc_rwlock_unlock(channel->internal.lock);
       goto out;
+    }
   }
 
+  silc_rwlock_unlock(channel->internal.lock);
+
   /* Notify application */
   silc_hash_table_list(channel->user_list, &htl);
   silc_client_command_callback(cmd, channel, &htl);
   silc_hash_table_list_reset(&htl);
 
  out:
+  silc_client_unref_channel(client, conn, channel);
   silc_fsm_next(fsm, silc_client_command_reply_processed);
   return SILC_FSM_CONTINUE;
 }
@@ -1921,6 +2074,8 @@ SILC_FSM_STATE(silc_client_command_reply_getkey)
     goto out;
   }
   if (!silc_public_key_payload_decode(tmp, len, &public_key)) {
+    SAY(client, conn, SILC_CLIENT_MESSAGE_COMMAND_ERROR,
+        "Cannot decode public key: malformed/unsupported public key");
     ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
     goto out;
   }
@@ -1933,6 +2088,8 @@ SILC_FSM_STATE(silc_client_command_reply_getkey)
       goto out;
     }
 
+    silc_rwlock_wrlock(client_entry->internal.lock);
+
     /* Save fingerprint */
     if (!client_entry->fingerprint)
       silc_hash_make(conn->internal->sha1hash, tmp + 4, len - 4,
@@ -1942,6 +2099,8 @@ SILC_FSM_STATE(silc_client_command_reply_getkey)
       public_key = NULL;
     }
 
+    silc_rwlock_unlock(client_entry->internal.lock);
+
     /* Notify application */
     silc_client_command_callback(cmd, SILC_ID_CLIENT, client_entry,
 				 client_entry->public_key);
@@ -1954,11 +2113,15 @@ SILC_FSM_STATE(silc_client_command_reply_getkey)
       goto out;
     }
 
+    silc_rwlock_wrlock(server_entry->internal.lock);
+
     if (!server_entry->public_key) {
       server_entry->public_key = public_key;
       public_key = NULL;
     }
 
+    silc_rwlock_unlock(server_entry->internal.lock);
+
     /* Notify application */
     silc_client_command_callback(cmd, SILC_ID_SERVER, server_entry,
 				 server_entry->public_key);