silc_status_get_args(cmd->status, args, &arg1, &arg2); \
else \
cmd->status = error; \
- silc_client_command_callback(cmd, arg1, arg2); \
+ SILC_LOG_DEBUG(("Error in command reply")); \
+ silc_client_command_callback(cmd, arg1, arg2); \
} while(0)
/* Check for error */
/* Default reply callback */
if (cmd->called) {
+ SILC_LOG_DEBUG(("cp %p, ap %p", cp, ap));
silc_va_copy(cp, ap);
+ SILC_LOG_DEBUG(("cp %p, ap %p", cp, ap));
cmd->conn->client->internal->ops->command_reply(
cmd->conn->client, cmd->conn, cmd->cmd, cmd->status,
cmd->error, cp);
silc_list_start(cmd->reply_callbacks);
while ((cb = silc_list_get(cmd->reply_callbacks)))
if (!cb->do_not_call) {
+ SILC_LOG_DEBUG(("cp %p, ap %p", cp, ap));
silc_va_copy(cp, ap);
+ SILC_LOG_DEBUG(("cp %p, ap %p", cp, ap));
cb->do_not_call = cb->reply(cmd->conn->client, cmd->conn, cmd->cmd,
cmd->status, cmd->error, cb->context, cp);
va_end(cp);
/* Find the command pending reply */
silc_mutex_lock(conn->internal->lock);
silc_list_start(conn->internal->pending_commands);
- while ((cmd = silc_list_get(conn->internal->pending_commands)))
+ while ((cmd = silc_list_get(conn->internal->pending_commands))) {
+ SILC_LOG_DEBUG(("cmd %p, command %d, ident %d", cmd, cmd->cmd,
+ cmd->cmd_ident));
if ((cmd->cmd == command || cmd->cmd == SILC_COMMAND_NONE)
- && cmd->cmd_ident == cmd_ident)
+ && cmd->cmd_ident == cmd_ident) {
+ silc_list_del(conn->internal->pending_commands, cmd);
break;
+ }
+ }
silc_mutex_unlock(conn->internal->lock);
if (!cmd) {
return SILC_FSM_FINISH;
}
+ SILC_LOG_DEBUG(("cmd %p, command %d", cmd, cmd->cmd));
+
/* Signal command thread that command reply has arrived */
silc_fsm_set_state_context(&cmd->thread, payload);
silc_fsm_next(&cmd->thread, silc_client_command_reply_process);
}
/* Update the client entry */
+ silc_mutex_lock(conn->internal->lock);
if (!silc_idcache_update(conn->internal->client_cache,
conn->internal->local_entry,
&conn->local_entry->id,
conn->local_entry->nickname_normalized,
tmp, TRUE)) {
silc_free(tmp);
+ silc_mutex_unlock(conn->internal->lock);
ERROR_CALLBACK(SILC_STATUS_ERR_BAD_NICKNAME);
goto out;
}
- memcpy(conn->local_entry->nickname, nick, strlen(nick));
+ 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->local_idp, idp_len);
- silc_buffer_put(conn->local_idp, idp, idp_len);
+ 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);
/* Notify application */
silc_client_command_callback(cmd, conn->local_entry,
SilcChannelEntry channel;
unsigned char *tmp;
SilcUInt32 len;
- SilcBufferStruct buf;
+ SilcArgumentPayload invite_args = NULL;
SilcID id;
/* Sanity checks */
/* Get the invite list */
tmp = silc_argument_get_arg_type(args, 3, &len);
if (tmp)
- silc_buffer_set(&buf, tmp, len);
+ invite_args = silc_argument_list_parse(tmp, len);
/* Notify application */
- silc_client_command_callback(cmd, channel, tmp ? &buf : NULL);
+ silc_client_command_callback(cmd, channel, invite_args);
+
+ if (invite_args)
+ silc_argument_payload_free(invite_args);
out:
silc_fsm_next(fsm, silc_client_command_reply_processed);
SilcInt64 diff;
diff = silc_time() - SILC_PTR_TO_64(cmd->context);
- SAY(client, conn, SILC_CLIENT_MESSAGE_INFO,
- "Ping reply from %s: %d second%s", conn->remote_host,
- (int)diff, diff == 1 ? "" : "s");
+ if (cmd->verbose)
+ SAY(client, conn, SILC_CLIENT_MESSAGE_INFO,
+ "Ping reply from %s: %d second%s", conn->remote_host,
+ (int)diff, diff == 1 ? "" : "s");
/* Notify application */
silc_client_command_callback(cmd);
/********************************** JOIN ************************************/
+/* Continue JOIN command reply processing after resolving unknown users */
+
+static void
+silc_client_command_reply_join_resolved(SilcClient client,
+ SilcClientConnection conn,
+ SilcStatus status,
+ SilcDList clients,
+ void *context)
+{
+ SilcClientCommandContext cmd = context;
+ SilcChannelEntry channel = cmd->context;
+
+ channel->internal.resolve_cmd_ident = 0;
+ silc_client_unref_channel(client, conn, channel);
+
+ SILC_FSM_CALL_CONTINUE(&cmd->thread);
+}
+
+
/* Received reply for JOIN command. */
SILC_FSM_STATE(silc_client_command_reply_join)
SilcChannelEntry channel;
SilcUInt32 mode = 0, len, list_count;
char *topic, *tmp, *channel_name = NULL, *hmac;
- SilcBuffer keyp = NULL, client_id_list = NULL, client_mode_list = NULL;
- SilcBufferStruct chpklist;
+ const char *cipher;
+ SilcBufferStruct client_id_list, client_mode_list, keyp;
+ SilcHashTableList htl;
+ SilcDList chpks = NULL;
SilcID id;
int i;
goto out;
}
- /* Get channel mode */
- tmp = silc_argument_get_arg_type(args, 5, NULL);
- if (tmp)
- SILC_GET32_MSB(mode, tmp);
-
- /* Get channel key */
- tmp = silc_argument_get_arg_type(args, 7, &len);
- if (tmp) {
- keyp = silc_buffer_alloc_size(len);
- if (keyp)
- silc_buffer_put(keyp, tmp, len);
- }
-
- /* Get topic */
- topic = silc_argument_get_arg_type(args, 10, NULL);
-
/* Check whether we have this channel entry already. */
channel = silc_client_get_channel(client, conn, channel_name);
if (channel) {
ERROR_CALLBACK(SILC_STATUS_ERR_BAD_CHANNEL);
goto out;
}
- }
-
- conn->current_channel = channel;
- channel->mode = mode;
-
- /* Get hmac */
- hmac = silc_argument_get_arg_type(args, 11, NULL);
- if (hmac) {
- if (!silc_hmac_alloc(hmac, NULL, &channel->internal.hmac)) {
- if (cmd->verbose)
- SAY(client, conn, SILC_CLIENT_MESSAGE_ERROR,
- "Cannot join channel: Unsupported HMAC `%s'", hmac);
- ERROR_CALLBACK(SILC_STATUS_ERR_UNKNOWN_ALGORITHM);
- goto out;
- }
+ silc_client_ref_channel(client, conn, channel);
}
/* Get the list count */
ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
}
+ silc_buffer_set(&client_id_list, tmp, len);
- client_id_list = silc_buffer_alloc_size(len);
- if (client_id_list)
- silc_buffer_put(client_id_list, tmp, len);
+ /* Resolve users we do not know about */
+ if (!cmd->resolved) {
+ cmd->resolved = TRUE;
+ cmd->context = channel;
+ SILC_FSM_CALL(channel->internal.resolve_cmd_ident =
+ silc_client_get_clients_by_list(
+ client, conn, list_count, &client_id_list,
+ silc_client_command_reply_join_resolved, cmd));
+ /* NOT REACHED */
+ }
/* Get client mode list */
tmp = silc_argument_get_arg_type(args, 14, &len);
ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
}
-
- client_mode_list = silc_buffer_alloc_size(len);
- if (client_mode_list)
- silc_buffer_put(client_mode_list, tmp, len);
+ silc_buffer_set(&client_mode_list, tmp, len);
/* Add clients we received in the reply to the channel */
for (i = 0; i < list_count; i++) {
SilcClientEntry client_entry;
/* Client ID */
- SILC_GET16_MSB(idp_len, client_id_list->data + 2);
+ SILC_GET16_MSB(idp_len, client_id_list.data + 2);
idp_len += 4;
- if (!silc_id_payload_parse_id(client_id_list->data, idp_len, &id))
- goto out;
+ if (!silc_id_payload_parse_id(client_id_list.data, idp_len, &id))
+ continue;
/* Mode */
- SILC_GET32_MSB(mode, client_mode_list->data);
+ SILC_GET32_MSB(mode, client_mode_list.data);
- /* Check if we have this client cached already. */
+ SILC_LOG_DEBUG(("id %s", silc_id_render(&id.u.client_id, SILC_ID_CLIENT)));
+
+ /* Get client entry */
client_entry = silc_client_get_client_by_id(client, conn, &id.u.client_id);
- if (!client_entry) {
- /* No, we don't have it, add entry for it. */
- client_entry =
- silc_client_add_client(client, conn, NULL, NULL, NULL,
- &id.u.client_id, 0);
- if (!client_entry)
- goto out;
- }
+ if (!client_entry)
+ continue;
/* Join client to the channel */
- if (!silc_client_add_to_channel(channel, client_entry, mode)) {
- silc_client_unref_client(client, conn, client_entry);
- goto out;
- }
+ silc_client_add_to_channel(channel, client_entry, mode);
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))
goto out;
- if (!silc_buffer_pull(client_mode_list, 4))
+ if (!silc_buffer_pull(&client_mode_list, 4))
goto out;
}
- silc_buffer_start(client_id_list);
- silc_buffer_start(client_mode_list);
- /* Save channel key */
-#if 0
- if (keyp)
- silc_client_save_channel_key(client, conn, keyp, channel);
-#endif /* 0 */
+ /* Get hmac */
+ hmac = silc_argument_get_arg_type(args, 11, NULL);
+ if (hmac) {
+ if (!silc_hmac_alloc(hmac, NULL, &channel->internal.hmac)) {
+ if (cmd->verbose)
+ SAY(client, conn, SILC_CLIENT_MESSAGE_ERROR,
+ "Cannot join channel: Unsupported HMAC `%s'", hmac);
+ ERROR_CALLBACK(SILC_STATUS_ERR_UNKNOWN_ALGORITHM);
+ goto out;
+ }
+ }
+
+ /* Get channel mode */
+ tmp = silc_argument_get_arg_type(args, 5, NULL);
+ if (tmp)
+ 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);
+ }
+
+ /* Get topic */
+ topic = silc_argument_get_arg_type(args, 10, NULL);
+ if (topic) {
+ silc_free(channel->topic);
+ channel->topic = silc_memdup(topic, strlen(topic));
+ }
/* Get founder key */
tmp = silc_argument_get_arg_type(args, 15, &len);
/* Get channel public key list */
tmp = silc_argument_get_arg_type(args, 16, &len);
if (tmp)
- silc_buffer_set(&chpklist, tmp, len);
+ chpks = silc_argument_list_parse_decoded(tmp, len,
+ SILC_ARGUMENT_PUBLIC_KEY);
- if (topic) {
- silc_free(channel->topic);
- channel->topic = silc_memdup(topic, strlen(topic));
- }
+ /* Set current channel */
+ conn->current_channel = channel;
+
+ cipher = (channel->internal.channel_key ?
+ silc_cipher_get_name(channel->internal.channel_key) : NULL);
+ silc_hash_table_list(channel->user_list, &htl);
/* Notify application */
- silc_client_command_callback(cmd, channel_name, channel, mode, 0,
- keyp ? keyp->head : NULL, NULL,
- NULL, topic, hmac, list_count, client_id_list,
- client_mode_list, channel->founder_key,
- tmp ? &chpklist : NULL, channel->user_limit);
+ silc_client_command_callback(cmd, channel_name, channel, mode, &htl,
+ topic, cipher, hmac, channel->founder_key,
+ chpks, 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);
out:
- silc_buffer_free(keyp);
- silc_buffer_free(client_id_list);
- silc_buffer_free(client_mode_list);
silc_fsm_next(fsm, silc_client_command_reply_processed);
return SILC_FSM_CONTINUE;
}
SilcChannelEntry channel;
unsigned char *tmp;
SilcUInt32 len;
- SilcBufferStruct buf;
+ SilcArgumentPayload invite_args = NULL;
SilcID id;
/* Sanity checks */
goto out;
}
- /* Get the ban list */
+ /* Get the invite list */
tmp = silc_argument_get_arg_type(args, 3, &len);
if (tmp)
- silc_buffer_set(&buf, tmp, len);
+ invite_args = silc_argument_list_parse(tmp, len);
/* Notify application */
- silc_client_command_callback(cmd, channel, tmp ? &buf : NULL);
+ silc_client_command_callback(cmd, channel, invite_args);
+
+ if (invite_args)
+ silc_argument_payload_free(invite_args);
out:
silc_fsm_next(fsm, silc_client_command_reply_processed);
/********************************* USERS ************************************/
-/* Continue USERS command after resolving unknown users */
+/* Continue USERS command reply processing after resolving unknown users */
static void
silc_client_command_reply_users_resolved(SilcClient client,
SILC_FSM_CALL_CONTINUE(&cmd->thread);
}
+
/* Continue USERS command after resolving unknown channel */
static void
/* Save fingerprint */
if (!client_entry->fingerprint)
- silc_hash_make(client->sha1hash, tmp + 4, len - 4,
+ silc_hash_make(conn->internal->sha1hash, tmp + 4, len - 4,
client_entry->fingerprint);
if (!client_entry->public_key) {
client_entry->public_key = public_key;
projects / silc.git / blobdiff