/************************** 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); \
msg "%s", silc_get_status_message(cmd->error)); \
ERROR_CALLBACK(cmd->error); \
silc_client_command_process_error(cmd, state_context, cmd->error); \
- silc_fsm_next(fsm, silc_client_command_reply_process); \
+ silc_fsm_next(fsm, silc_client_command_reply_processed); \
return SILC_FSM_CONTINUE; \
}
if (silc_argument_get_arg_num(args) < min || \
silc_argument_get_arg_num(args) > max) { \
ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); \
- silc_fsm_next(fsm, silc_client_command_reply_process); \
+ silc_fsm_next(fsm, silc_client_command_reply_processed); \
return SILC_FSM_CONTINUE; \
}
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);
silc_client_del_client(client, conn, client_entry);
+ silc_client_unref_client(client, conn, client_entry);
}
}
}
silc_mutex_unlock(conn->internal->lock);
if (!cmd) {
- SILC_LOG_DEBUG(("Unknown command reply"));
+ SILC_LOG_DEBUG(("Unknown command reply %s, ident %d",
+ silc_get_command_name(command), cmd_ident));
silc_command_payload_free(payload);
return SILC_FSM_FINISH;
}
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 ? 25 : 60, 0);
return SILC_FSM_WAIT;
}
SILC_FSM_STATE(silc_client_command_reply_timeout)
{
SilcClientCommandContext cmd = fsm_context;
+ 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);
+ return SILC_FSM_FINISH;
+ }
+
+ SILC_LOG_DEBUG(("Command %s timeout", silc_get_command_name(cmd->cmd)));
+
/* Timeout, reply not received in timely fashion */
+ silc_list_del(conn->internal->pending_commands, cmd);
ERROR_CALLBACK(SILC_STATUS_ERR_TIMEDOUT);
return SILC_FSM_FINISH;
}
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);
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);
ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
}
+ silc_client_ref_server(client, conn, server_entry);
} else {
silc_client_update_server(client, conn, server_entry, name, info);
}
/* Notify application */
silc_client_command_callback(cmd, server_entry, name, info);
+ silc_client_unref_server(client, conn, server_entry);
break;
case SILC_ID_CHANNEL:
ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
}
+ silc_client_ref_channel(client, conn, channel_entry);
}
/* Notify application */
silc_client_command_callback(cmd, channel_entry, name, info);
+ silc_client_unref_channel(client, conn, channel_entry);
break;
}
silc_mutex_lock(conn->internal->lock);
if (!silc_idcache_update(conn->internal->client_cache,
conn->internal->local_entry,
- &conn->local_entry->id,
- &id.u.client_id,
- conn->local_entry->nickname_normalized,
- tmp, TRUE)) {
+ &id.u.client_id, tmp, TRUE)) {
silc_free(tmp);
silc_mutex_unlock(conn->internal->lock);
ERROR_CALLBACK(SILC_STATUS_ERR_BAD_NICKNAME);
SilcArgumentPayload args = silc_command_get_args(payload);
unsigned char *tmp, *name, *topic;
SilcUInt32 usercount = 0;
- SilcChannelEntry channel_entry;
+ SilcChannelEntry channel_entry = NULL;
SilcID id;
/* Sanity checks */
ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
}
+ silc_client_ref_channel(client, conn, channel_entry);
}
/* Notify application */
silc_client_command_callback(cmd, channel_entry, name, topic, usercount);
out:
+ silc_client_unref_channel(client, conn, channel_entry);
silc_fsm_next(fsm, silc_client_command_reply_processed);
return SILC_FSM_CONTINUE;
}
/* Remove the client from all channels and free it */
if (client_entry) {
+ silc_client_remove_from_channels(client, conn, client_entry);
silc_client_del_client(client, conn, client_entry);
silc_client_unref_client(client, conn, client_entry);
}
/* See whether we have this server cached. If not create it. */
server = silc_client_get_server_by_id(client, conn, &id.u.server_id);
if (!server) {
- SILC_LOG_DEBUG(("New server entry"));
+ SILC_LOG_DEBUG(("Add new server entry (INFO)"));
server = silc_client_add_server(client, conn, server_name,
server_info, &id.u.server_id);
if (!server)
goto out;
+ silc_client_ref_server(client, conn, server);
}
/* Notify application */
silc_client_command_callback(cmd, server, server->server_name,
server->server_info);
+ silc_client_unref_server(client, conn, server);
out:
silc_fsm_next(fsm, silc_client_command_reply_processed);
/* Mode */
SILC_GET32_MSB(mode, client_mode_list.data);
- 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)
continue;
/* Join client to the channel */
- silc_client_add_to_channel(channel, client_entry, mode);
+ silc_client_add_to_channel(client, conn, channel, client_entry, mode);
silc_client_unref_client(client, conn, client_entry);
if (!silc_buffer_pull(&client_id_list, idp_len))
}
/* Remove us from this channel. */
- silc_client_remove_from_channel(channel, conn->local_entry);
+ silc_client_remove_from_channel(client, conn, channel, conn->local_entry);
/* Notify application */
silc_client_command_callback(cmd, channel);
/* Now delete the channel. */
+ silc_client_empty_channel(client, conn, channel);
silc_client_del_channel(client, conn, channel);
out:
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)
- silc_client_add_to_channel(channel, client_entry, mode);
+ silc_client_add_to_channel(client, conn, channel, client_entry, mode);
silc_client_unref_client(client, conn, client_entry);
if (!silc_buffer_pull(&client_id_list, idp_len))
/* Notify application */
silc_client_command_callback(cmd, SILC_ID_SERVER, server_entry,
server_entry->public_key);
+ silc_client_unref_server(client, conn, server_entry);
}
out:
projects / silc.git / blobdiff