client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
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);
}
if (cmd->error == SILC_STATUS_ERR_NO_SUCH_CHANNEL_ID) {
SilcChannelEntry channel;
- /* Remove unknown client entry from cache */
+ /* Remove unknown channel entry from cache */
if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL))
return;
if (cmd->error == SILC_STATUS_ERR_NO_SUCH_SERVER_ID) {
SilcServerEntry server_entry;
- /* Remove unknown client entry from cache */
+ /* Remove unknown server entry from cache */
if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL))
return;
/** Wait for command reply */
silc_fsm_set_state_context(fsm, NULL);
silc_fsm_next_later(fsm, silc_client_command_reply_timeout,
- cmd->cmd != SILC_COMMAND_PING ? 25 : 60, 0);
+ cmd->cmd != SILC_COMMAND_PING ? 40 : 60, 0);
return SILC_FSM_WAIT;
}
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);
}
}
/* 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;
}
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;
}
}
/* 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);
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;
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;
}
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;
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;
}
/* 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);
}
{
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);
}
/* 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;
}
/* 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;
}
/* 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 */
/* Get channel public key list */
tmp = silc_argument_get_arg_type(args, 16, &len);
if (tmp)
- silc_client_channel_save_public_keys(channel, tmp, len);
+ silc_client_channel_save_public_keys(channel, tmp, len, FALSE);
/* Set current channel */
conn->current_channel = channel;
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,
channel->channel_pubkeys, channel->user_limit);
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 */
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;
}
-
- /* 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_GET32_MSB(mode, tmp);
silc_rwlock_wrlock(channel->internal.lock);
- /* Save the mode */
- SILC_GET32_MSB(mode, tmp);
- channel->mode = mode;
-
/* Get user limit */
tmp = silc_argument_get_arg_type(args, 6, &len);
if (tmp && len == 4)
/* Get channel public key(s) */
tmp = silc_argument_get_arg_type(args, 5, &len);
if (tmp)
- silc_client_channel_save_public_keys(channel, tmp, len);
+ 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);
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;
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;
}
SilcCommandPayload payload = state_context;
SilcArgumentPayload args = silc_command_get_args(payload);
SilcClientEntry client_entry;
- SilcChannelEntry channel;
+ SilcChannelEntry channel = NULL;
SilcID id;
/* Sanity checks */
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;
}
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);
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);
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;
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;
}
SilcCommandPayload payload = state_context;
SilcArgumentPayload args = silc_command_get_args(payload);
SilcChannelEntry channel;
+ SilcCipher key;
+ SilcHmac hmac;
SilcID id;
/* Sanity checks */
/* 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);
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 = NULL;
}
}
+ silc_rwlock_unlock(channel->internal.lock);
+
/* Notify application */
silc_hash_table_list(channel->user_list, &htl);
silc_client_command_callback(cmd, channel, &htl);
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;
}
projects / silc.git / blobdiff