X-Git-Url: http://git.silcnet.org/gitweb/?p=silc.git;a=blobdiff_plain;f=lib%2Fsilcclient%2Fcommand_reply.c;h=ede887535fdcdc97b6219d0c8d73f11b45867021;hp=cf68fddd75776cc2f91df04893872259182fdfe1;hb=HEAD;hpb=49bd4f6cd6a28a9bcb8081eaef48567538ba486f diff --git a/lib/silcclient/command_reply.c b/lib/silcclient/command_reply.c index cf68fddd..ede88753 100644 --- a/lib/silcclient/command_reply.c +++ b/lib/silcclient/command_reply.c @@ -4,7 +4,7 @@ Author: Pekka Riikonen - 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 @@ -42,12 +42,12 @@ 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); \ silc_fsm_next(fsm, silc_client_command_reply_processed); \ - SILC_FSM_CONTINUE; \ + return SILC_FSM_CONTINUE; \ } /* Check for correct arguments */ @@ -56,7 +56,7 @@ do { \ silc_argument_get_arg_num(args) > max) { \ ERROR_CALLBACK(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); \ silc_fsm_next(fsm, silc_client_command_reply_processed); \ - SILC_FSM_CONTINUE; \ + return SILC_FSM_CONTINUE; \ } #define SAY cmd->conn->client->internal->ops->say @@ -118,6 +118,7 @@ static void silc_client_command_process_error(SilcClientCommandContext cmd, 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); } @@ -127,7 +128,7 @@ static void silc_client_command_process_error(SilcClientCommandContext cmd, 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; @@ -143,7 +144,7 @@ static void silc_client_command_process_error(SilcClientCommandContext cmd, 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; @@ -174,7 +175,7 @@ SILC_FSM_STATE(silc_client_command_reply) silc_packet_free(packet); if (!payload) { SILC_LOG_DEBUG(("Bad command reply packet")); - SILC_FSM_FINISH; + return SILC_FSM_FINISH; } cmd_ident = silc_command_get_ident(payload); @@ -196,15 +197,18 @@ SILC_FSM_STATE(silc_client_command_reply) SILC_LOG_DEBUG(("Unknown command reply %s, ident %d", silc_get_command_name(command), cmd_ident)); silc_command_payload_free(payload); - SILC_FSM_FINISH; + 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); - SILC_FSM_FINISH; + return SILC_FSM_FINISH; } /* Wait here for command reply to arrive from remote host */ @@ -218,8 +222,8 @@ SILC_FSM_STATE(silc_client_command_reply_wait) /** 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); - SILC_FSM_WAIT; + cmd->cmd != SILC_COMMAND_PING ? 40 : 60, 0); + return SILC_FSM_WAIT; } /* Timeout occurred while waiting command reply */ @@ -233,7 +237,9 @@ SILC_FSM_STATE(silc_client_command_reply_timeout) if (conn->internal->disconnected) { SILC_LOG_DEBUG(("Command %s canceled", silc_get_command_name(cmd->cmd))); silc_list_del(conn->internal->pending_commands, cmd); - SILC_FSM_FINISH; + 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))); @@ -241,7 +247,7 @@ SILC_FSM_STATE(silc_client_command_reply_timeout) /* Timeout, reply not received in timely fashion */ silc_list_del(conn->internal->pending_commands, cmd); ERROR_CALLBACK(SILC_STATUS_ERR_TIMEDOUT); - SILC_FSM_FINISH; + return SILC_FSM_FINISH; } /* Process received command reply payload */ @@ -363,10 +369,10 @@ SILC_FSM_STATE(silc_client_command_reply_process) silc_fsm_next(fsm, silc_client_command_reply_service); break; default: - SILC_FSM_FINISH; + return SILC_FSM_FINISH; } - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /* Completes command reply processing */ @@ -381,7 +387,7 @@ SILC_FSM_STATE(silc_client_command_reply_processed) if (cmd->status == SILC_STATUS_OK || cmd->status == SILC_STATUS_LIST_END || SILC_STATUS_IS_ERROR(cmd->status)) - SILC_FSM_FINISH; + return SILC_FSM_FINISH; /* Add back to pending command reply list */ silc_mutex_lock(conn->internal->lock); @@ -391,7 +397,7 @@ SILC_FSM_STATE(silc_client_command_reply_processed) /** Wait more command payloads */ silc_fsm_next(fsm, silc_client_command_reply_wait); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /******************************** WHOIS *************************************/ @@ -478,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); @@ -489,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), @@ -505,13 +515,13 @@ 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); } out: silc_fsm_next(fsm, silc_client_command_reply_processed); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /******************************** WHOWAS ************************************/ @@ -559,7 +569,7 @@ SILC_FSM_STATE(silc_client_command_reply_whowas) out: silc_client_unref_client(client, conn, client_entry); silc_fsm_next(fsm, silc_client_command_reply_processed); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /******************************** IDENTIFY **********************************/ @@ -668,14 +678,15 @@ 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; } out: silc_fsm_next(fsm, silc_client_command_reply_processed); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /********************************** NICK ************************************/ @@ -716,21 +727,26 @@ SILC_FSM_STATE(silc_client_command_reply_nick) goto out; } + silc_rwlock_wrlock(conn->local_entry->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_rwlock_unlock(conn->local_entry->internal.lock); + /* Notify application */ silc_client_command_callback(cmd, conn->local_entry, conn->local_entry->nickname, &old_client_id); out: silc_fsm_next(fsm, silc_client_command_reply_processed); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /********************************** LIST ************************************/ @@ -756,7 +772,7 @@ SILC_FSM_STATE(silc_client_command_reply_list) /* There were no channels in the network. */ silc_client_command_callback(cmd, NULL, NULL, NULL, 0); silc_fsm_next(fsm, silc_client_command_reply_processed); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } CHECK_ARGS(3, 5); @@ -787,12 +803,13 @@ 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); silc_fsm_next(fsm, silc_client_command_reply_processed); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /********************************* TOPIC ************************************/ @@ -806,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; @@ -828,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) { @@ -835,12 +854,15 @@ 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); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /********************************* INVITE ***********************************/ @@ -854,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; @@ -889,8 +911,9 @@ 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); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /********************************** KILL ************************************/ @@ -922,16 +945,17 @@ 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); } out: silc_fsm_next(fsm, silc_client_command_reply_processed); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /********************************** INFO ************************************/ @@ -992,7 +1016,7 @@ SILC_FSM_STATE(silc_client_command_reply_info) out: silc_fsm_next(fsm, silc_client_command_reply_processed); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /********************************** STATS ***********************************/ @@ -1049,7 +1073,7 @@ SILC_FSM_STATE(silc_client_command_reply_stats) out: silc_fsm_next(fsm, silc_client_command_reply_processed); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /********************************** PING ************************************/ @@ -1073,7 +1097,7 @@ SILC_FSM_STATE(silc_client_command_reply_ping) silc_client_command_callback(cmd); silc_fsm_next(fsm, silc_client_command_reply_processed); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /********************************** JOIN ************************************/ @@ -1089,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); } @@ -1150,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; } @@ -1183,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; @@ -1201,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 */ @@ -1219,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 */ @@ -1265,18 +1324,19 @@ SILC_FSM_STATE(silc_client_command_reply_join) /* Get channel public key list */ tmp = silc_argument_get_arg_type(args, 16, &len); if (tmp) - channel->channel_pubkeys = - 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, channel->channel_pubkeys, channel->user_limit); @@ -1285,7 +1345,7 @@ SILC_FSM_STATE(silc_client_command_reply_join) out: silc_fsm_next(fsm, silc_client_command_reply_processed); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /********************************** MOTD ************************************/ @@ -1339,7 +1399,7 @@ SILC_FSM_STATE(silc_client_command_reply_motd) out: silc_fsm_next(fsm, silc_client_command_reply_processed); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /********************************** UMODE ***********************************/ @@ -1366,14 +1426,16 @@ 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); out: silc_fsm_next(fsm, silc_client_command_reply_processed); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /********************************** CMODE ***********************************/ @@ -1389,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 */ @@ -1412,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); @@ -1438,20 +1498,39 @@ 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); + + /* 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_argument_list_free(channel_pubkeys, SILC_ARGUMENT_PUBLIC_KEY); + 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); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /********************************** CUMODE **********************************/ @@ -1466,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; @@ -1511,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); @@ -1521,8 +1602,9 @@ 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); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /********************************** KICK ************************************/ @@ -1535,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 */ @@ -1574,8 +1656,9 @@ 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); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /******************************** SILCOPER **********************************/ @@ -1590,11 +1673,14 @@ 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); silc_fsm_next(fsm, silc_client_command_reply_processed); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /********************************** OPER ************************************/ @@ -1609,11 +1695,14 @@ 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); silc_fsm_next(fsm, silc_client_command_reply_processed); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /********************************* DETACH ***********************************/ @@ -1644,7 +1733,7 @@ SILC_FSM_STATE(silc_client_command_reply_detach) out: silc_fsm_next(fsm, silc_client_command_reply_processed); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /********************************** WATCH ***********************************/ @@ -1663,7 +1752,7 @@ SILC_FSM_STATE(silc_client_command_reply_watch) silc_client_command_callback(cmd); silc_fsm_next(fsm, silc_client_command_reply_processed); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /*********************************** BAN ************************************/ @@ -1675,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; @@ -1710,8 +1799,9 @@ 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); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /********************************** LEAVE ***********************************/ @@ -1726,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 */ @@ -1751,13 +1843,39 @@ 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: silc_fsm_next(fsm, silc_client_command_reply_processed); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /********************************* USERS ************************************/ @@ -1810,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; @@ -1858,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)); @@ -1874,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); @@ -1887,24 +2008,34 @@ 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); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /********************************** GETKEY **********************************/ @@ -1943,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; } @@ -1955,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, @@ -1964,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); @@ -1976,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); @@ -1991,7 +2132,7 @@ SILC_FSM_STATE(silc_client_command_reply_getkey) if (public_key) silc_pkcs_public_key_free(public_key); silc_fsm_next(fsm, silc_client_command_reply_processed); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /********************************** SERVICE *********************************/ @@ -2020,7 +2161,7 @@ SILC_FSM_STATE(silc_client_command_reply_service) silc_client_command_callback(cmd, service_list, name); silc_fsm_next(fsm, silc_client_command_reply_processed); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; } /*********************************** QUIT ***********************************/ @@ -2030,5 +2171,5 @@ SILC_FSM_STATE(silc_client_command_reply_service) SILC_FSM_STATE(silc_client_command_reply_quit) { silc_fsm_next(fsm, silc_client_command_reply_processed); - SILC_FSM_CONTINUE; + return SILC_FSM_CONTINUE; }