SILC_FSM_STATE(silc_client_command_continue_error)
{
/* Destructor will free all resources */
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/* Command reply callback to continue with the execution of a command.
SILC_FSM_CALL_CONTINUE(&cmd->thread);
}
+/* Dummy command callback. Nothing interesting to do here. Use this when
+ you just send command but don't care about reply. */
+
+SilcBool silc_client_command_called_dummy(SilcClient client,
+ SilcClientConnection conn,
+ SilcCommand command,
+ SilcStatus status,
+ SilcStatus error,
+ void *context,
+ va_list ap)
+{
+ return FALSE;
+}
+
+/* Dummy resolving callback. Nothing interesting to do here. Use this
+ when you just resolve entires but don't care about reply. */
+
+void silc_client_command_resolve_dummy(SilcClient client,
+ SilcClientConnection conn,
+ SilcStatus status,
+ SilcDList clients,
+ void *context)
+{
+ /* Nothing */
+}
+
/* Register command to client */
static SilcBool
SilcUInt32 argc = 0;
unsigned char **argv = NULL;
SilcUInt32 *argv_lens = NULL, *argv_types = NULL;
+ SilcUInt16 cmd_ident;
SilcClientCommand command;
SilcClientCommandContext cmd;
char *arg;
if (!conn) {
- client->internal->ops->say(client, NULL, SILC_CLIENT_MESSAGE_ERROR,
+ client->internal->ops->say(client, NULL, SILC_CLIENT_MESSAGE_COMMAND_ERROR,
"You are not connected to a server, please connect to server");
return 0;
}
cmd->argv = argv;
cmd->argv_lens = argv_lens;
cmd->argv_types = argv_types;
- cmd->cmd_ident = silc_client_cmd_ident(conn);
+ cmd_ident = cmd->cmd_ident = silc_client_cmd_ident(conn);
cmd->called = TRUE;
cmd->verbose = TRUE;
silc_list_init(cmd->reply_callbacks,
silc_client_command_destructor, NULL, FALSE);
silc_fsm_start_sync(&cmd->thread, command->command);
- return cmd->cmd_ident;
+ return cmd_ident;
}
/* Generic function to send any command. The arguments must be sent already
unsigned char count[4], *tmp = NULL;
SilcBool details = FALSE, nick = FALSE;
unsigned char *pubkey = NULL;
+ char *nickname = NULL;
int i;
/* Given without arguments fetches client's own information */
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
for (i = 1; i < cmd->argc; i++) {
SilcPublicKey pk;
if (!silc_pkcs_load_public_key(pubkey, &pk)) {
- SAY(client, conn, SILC_CLIENT_MESSAGE_ERROR,
+ SAY(client, conn, SILC_CLIENT_MESSAGE_COMMAND_ERROR,
"Could not load public key %s, check the filename",
pubkey);
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
SILC_ATTRIBUTE_USER_PUBLIC_KEY,
SILC_ATTRIBUTE_FLAG_VALID,
&obj, sizeof(obj));
+ silc_free(obj.data);
+ }
+
+ if (nick) {
+ silc_client_nickname_parse(client, conn, cmd->argv[1], &nickname);
+ if (!nickname)
+ nickname = strdup(cmd->argv[1]);
}
/* Send command */
silc_client_command_send_va(conn, cmd, cmd->cmd, NULL, NULL,
- 3, 1, nick ? cmd->argv[1] : NULL,
- nick ? cmd->argv_lens[1] : 0,
+ 3, 1, nick ? nickname : NULL,
+ nick ? strlen(nickname) : 0,
2, tmp ? tmp : NULL, tmp ? 4 : 0,
3, silc_buffer_datalen(attrs));
+ silc_free(nickname);
/* Notify application */
COMMAND(SILC_STATUS_OK);
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
out:
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/******************************** WHOWAS ************************************/
"Usage: /WHOWAS <nickname>[@<server>] [<count>]");
COMMAND_ERROR((cmd->argc < 2 ? SILC_STATUS_ERR_NOT_ENOUGH_PARAMS :
SILC_STATUS_ERR_TOO_MANY_PARAMS));
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
if (cmd->argc == 2) {
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/******************************** IDENTIFY **********************************/
int c;
if (cmd->argc < 2 || cmd->argc > 3)
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
if (cmd->argc == 2) {
silc_client_command_send_va(conn, cmd, cmd->cmd, NULL, NULL,
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/********************************** NICK ************************************/
SILC_FSM_STATE(silc_client_command_nick)
{
- SilcClientCommandContext cmd = fsm_context;
+ SilcClientCommandContext cmd2, cmd = fsm_context;
SilcClientConnection conn = cmd->conn;
if (cmd->argc < 2) {
goto out;
}
+ /* If JOIN command is active, wait for it to finish before sending NICK.
+ To avoid problems locally with changing IDs while joining, we do this. */
+ silc_mutex_lock(conn->internal->lock);
+ silc_list_start(conn->internal->pending_commands);
+ while ((cmd2 = silc_list_get(conn->internal->pending_commands))) {
+ if (cmd2->cmd == SILC_COMMAND_JOIN) {
+ silc_mutex_unlock(conn->internal->lock);
+ silc_fsm_next_later(fsm, silc_client_command_nick, 0, 300000);
+ return SILC_FSM_WAIT;
+ }
+ }
+ silc_mutex_unlock(conn->internal->lock);
+
if (cmd->argv_lens[1] > 128)
cmd->argv_lens[1] = 128;
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
out:
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/********************************** LIST ************************************/
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/********************************** TOPIC ***********************************/
SilcClient client = conn->client;
SilcChannelEntry channel;
SilcBuffer idp;
- char *name;
+ char *name, tmp[512];
if (cmd->argc < 2 || cmd->argc > 3) {
SAY(conn->client, conn, SILC_CLIENT_MESSAGE_INFO,
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL);
goto out;
}
- name = conn->current_channel->channel_name;
+
+ if (client->internal->params->full_channel_names)
+ silc_snprintf(tmp, sizeof(tmp), conn->current_channel->channel_name);
+ else
+ silc_snprintf(tmp, sizeof(tmp), "%s%s%s",
+ conn->current_channel->channel_name,
+ conn->current_channel->server[0] ? "@" : "",
+ conn->current_channel->server);
+ name = tmp;
} else {
name = cmd->argv[1];
}
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
out:
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/********************************* INVITE ***********************************/
silc_client_nickname_parse(client, conn, cmd->argv[2], &nickname);
/* Find client entry */
- clients = silc_client_get_clients_local(client, conn, nickname,
- cmd->argv[2]);
+ clients = silc_client_get_clients_local(client, conn, cmd->argv[2],
+ FALSE);
if (!clients)
/* Resolve client information */
SILC_FSM_CALL(silc_client_get_clients(
- client, conn, nickname,
- cmd->argv[2],
+ client, conn, nickname, NULL,
silc_client_command_resolve_continue,
cmd));
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
out:
silc_free(nickname);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/********************************** QUIT ************************************/
{
SilcClientCommandContext cmd = fsm_context;
SilcClientConnection conn = cmd->conn;
- SilcClient client = conn->client;
SILC_LOG_DEBUG(("Quitting"));
/* Notify application */
COMMAND(SILC_STATUS_OK);
- /* Call connection callback */
- if (!conn->internal->callback_called)
- conn->callback(client, conn, SILC_CLIENT_CONN_DISCONNECTED,
- 0, NULL, conn->callback_context);
- conn->internal->callback_called = TRUE;
-
/* Signal to close connection */
+ conn->internal->status = SILC_CLIENT_CONN_DISCONNECTED;
if (!conn->internal->disconnected) {
conn->internal->disconnected = TRUE;
SILC_FSM_EVENT_SIGNAL(&conn->internal->wait_event);
}
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/* Command QUIT. Closes connection with current server. */
/* We close the connection with a little timeout */
silc_fsm_next_later(fsm, silc_client_command_quit_final, 2, 0);
- SILC_FSM_WAIT;
+ return SILC_FSM_WAIT;
}
/********************************** KILL ************************************/
-
/* Command KILL. Router operator can use this command to remove an client
fromthe SILC Network. */
SAY(conn->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /KILL <nickname> [<comment>] [-pubkey]");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/* Parse the typed nickname. */
if (!silc_client_nickname_parse(client, conn, cmd->argv[1], &nickname))
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
/* Get the target client */
- clients = silc_client_get_clients_local(client, conn, nickname,
- cmd->argv[1]);
+ clients = silc_client_get_clients_local(client, conn, cmd->argv[1], FALSE);
if (!clients)
/* Resolve client information */
- SILC_FSM_CALL(silc_client_get_clients(client, conn, nickname,
- cmd->argv[1],
+ SILC_FSM_CALL(silc_client_get_clients(client, conn, nickname, NULL,
silc_client_command_resolve_continue,
cmd));
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/********************************** INFO ************************************/
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/********************************** STATS ***********************************/
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/********************************** PING ************************************/
if (cmd->argc < 2) {
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/* Send the command */
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/********************************** JOIN ************************************/
SILC_FSM_STATE(silc_client_command_join)
{
- SilcClientCommandContext cmd = fsm_context;
+ SilcClientCommandContext cmd2, cmd = fsm_context;
SilcClientConnection conn = cmd->conn;
SilcClient client = conn->client;
SilcChannelEntry channel = NULL;
if (channel && silc_client_on_channel(channel, conn->local_entry))
goto out;
+ /* If NICK command is active, wait for it to finish before sending JOIN.
+ To avoid problems locally with changing IDs while joining, we do this. */
+ silc_mutex_lock(conn->internal->lock);
+ silc_list_start(conn->internal->pending_commands);
+ while ((cmd2 = silc_list_get(conn->internal->pending_commands))) {
+ if (cmd2->cmd == SILC_COMMAND_NICK) {
+ silc_mutex_unlock(conn->internal->lock);
+ silc_fsm_next_later(fsm, silc_client_command_join, 0, 300000);
+ return SILC_FSM_WAIT;
+ }
+ }
+ silc_mutex_unlock(conn->internal->lock);
+
if (cmd->argv_lens[1] > 256)
cmd->argv_lens[1] = 256;
}
if (!silc_load_key_pair(cmd->argv[i + 1], cmd->argv[i + 2], pass,
&pubkey, &privkey)) {
- SAY(conn->client, conn, SILC_CLIENT_MESSAGE_ERROR,
+ SAY(conn->client, conn, SILC_CLIENT_MESSAGE_COMMAND_ERROR,
"Could not load key pair, check your arguments");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
out:
silc_client_unref_channel(client, conn, channel);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/********************************** MOTD ************************************/
"Usage: /MOTD [<server>]");
COMMAND_ERROR((cmd->argc < 1 ? SILC_STATUS_ERR_NOT_ENOUGH_PARAMS :
SILC_STATUS_ERR_TOO_MANY_PARAMS));
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/* Send the command */
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/********************************** UMODE ***********************************/
SAY(conn->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /UMODE +|-<modes>");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
mode = conn->local_entry->mode;
break;
default:
COMMAND_ERROR(SILC_STATUS_ERR_UNKNOWN_MODE);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
break;
}
}
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/********************************** CMODE ***********************************/
pass = cmd->argv[5];
if (!silc_load_key_pair(cmd->argv[3], cmd->argv[4], pass,
&pubkey, &privkey)) {
- SAY(client, conn, SILC_CLIENT_MESSAGE_ERROR,
+ SAY(client, conn, SILC_CLIENT_MESSAGE_COMMAND_ERROR,
"Could not load key pair, check your arguments");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
NULL, NULL, 1,
1, silc_buffer_datalen(chidp));
silc_buffer_free(chidp);
+ silc_client_unref_channel(client, conn, channel);
/* Notify application */
COMMAND(SILC_STATUS_OK);
- goto out;
+
+ /** Wait for command reply */
+ silc_fsm_next(fsm, silc_client_command_reply_wait);
+ return SILC_FSM_CONTINUE;
}
if (cmd->argc >= 4) {
if (cmd->argv[k][0] == '+')
chadd = TRUE;
if (!silc_pkcs_load_public_key(cmd->argv[k] + 1, &chpk)) {
- SAY(conn->client, conn, SILC_CLIENT_MESSAGE_ERROR,
+ SAY(conn->client, conn, SILC_CLIENT_MESSAGE_COMMAND_ERROR,
"Could not load public key %s, check the filename",
cmd->argv[k]);
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
out:
silc_client_unref_channel(client, conn, channel);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/********************************* CUMODE ***********************************/
silc_client_nickname_parse(client, conn, cmd->argv[3], &nickname);
/* Find client entry */
- clients = silc_client_get_clients_local(client, conn, nickname,
- cmd->argv[3]);
+ clients = silc_client_get_clients_local(client, conn, cmd->argv[3], FALSE);
if (!clients)
/* Resolve client information */
- SILC_FSM_CALL(silc_client_get_clients(client, conn, nickname, cmd->argv[3],
+ SILC_FSM_CALL(silc_client_get_clients(client, conn, nickname, NULL,
silc_client_command_resolve_continue,
cmd));
pass = cmd->argv[6];
if (!silc_load_key_pair(cmd->argv[4], cmd->argv[5], pass,
&pubkey, &privkey)) {
- SAY(conn->client, conn, SILC_CLIENT_MESSAGE_ERROR,
+ SAY(conn->client, conn, SILC_CLIENT_MESSAGE_COMMAND_ERROR,
"Could not load key pair, check your arguments");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
out:
silc_client_unref_channel(client, conn, channel);
silc_client_list_free(client, conn, clients);
silc_free(nickname);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/********************************** KICK ************************************/
SilcBuffer idp, idp2;
SilcClientEntry target;
SilcDList clients = NULL;
- char *name;
- char *nickname = NULL;
+ char *name, tmp[512];
if (cmd->argc < 3) {
SAY(conn->client, conn, SILC_CLIENT_MESSAGE_INFO,
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL);
goto out;
}
- name = conn->current_channel->channel_name;
+
+ if (client->internal->params->full_channel_names)
+ silc_snprintf(tmp, sizeof(tmp), conn->current_channel->channel_name);
+ else
+ silc_snprintf(tmp, sizeof(tmp), "%s%s%s",
+ conn->current_channel->channel_name,
+ conn->current_channel->server[0] ? "@" : "",
+ conn->current_channel->server);
+ name = tmp;
} else {
name = cmd->argv[1];
}
goto out;
}
- /* Parse the typed nickname. */
- silc_client_nickname_parse(client, conn, cmd->argv[2], &nickname);
-
/* Get the target client */
- clients = silc_client_get_clients_local(client, conn, nickname,
- cmd->argv[2]);
+ clients = silc_client_get_clients_local(client, conn, cmd->argv[2], FALSE);
if (!clients) {
SAY(conn->client, conn, SILC_CLIENT_MESSAGE_INFO,
"No such client: %s", cmd->argv[2]);
silc_buffer_free(idp);
silc_buffer_free(idp2);
- silc_free(nickname);
silc_client_list_free(client, conn, clients);
silc_client_unref_channel(client, conn, channel);
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
out:
silc_client_unref_channel(client, conn, channel);
- silc_free(nickname);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/***************************** OPER & SILCOPER ******************************/
/* Ask passphrase callback */
-static void silc_client_command_oper_cb(unsigned char *data,
+static void silc_client_command_oper_cb(const unsigned char *data,
SilcUInt32 data_len, void *context)
{
SilcClientCommandContext cmd = context;
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* OPER command. Used to obtain server operator privileges. */
SAY(conn->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /OPER <username> [-pubkey]");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
+ silc_fsm_next(fsm, silc_client_command_oper_send);
+
/* Get passphrase */
if (cmd->argc < 3) {
oper = silc_calloc(1, sizeof(*oper));
if (!oper)
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
cmd->context = oper;
SILC_FSM_CALL(conn->client->internal->
ops->ask_passphrase(conn->client, conn,
silc_client_command_oper_cb, cmd));
}
- silc_fsm_next(fsm, silc_client_command_oper_send);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* SILCOPER command. Used to obtain router operator privileges. */
SAY(conn->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /SILCOPER <username> [-pubkey]");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
+ silc_fsm_next(fsm, silc_client_command_oper_send);
+
/* Get passphrase */
if (cmd->argc < 3) {
oper = silc_calloc(1, sizeof(*oper));
if (!oper)
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
cmd->context = oper;
SILC_FSM_CALL(conn->client->internal->
ops->ask_passphrase(conn->client, conn,
silc_client_command_oper_cb, cmd));
}
- silc_fsm_next(fsm, silc_client_command_oper_send);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/*********************************** BAN ************************************/
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
out:
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/********************************* DETACH ***********************************/
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/********************************** WATCH ***********************************/
SilcBuffer buffer;
if (!silc_pkcs_load_public_key(pubkey, &pk)) {
- SAY(conn->client, conn, SILC_CLIENT_MESSAGE_ERROR,
+ SAY(conn->client, conn, SILC_CLIENT_MESSAGE_COMMAND_ERROR,
"Could not load public key %s, check the filename", pubkey);
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
silc_pkcs_public_key_free(pk);
}
+ /* If watching by nickname, resolve all users with that nickname so that
+ we get their information immediately. */
+ if (type == 2)
+ silc_client_get_clients(conn->client, conn, cmd->argv[2], NULL,
+ silc_client_command_resolve_dummy, NULL);
+
/* Send the commmand */
silc_client_command_send_va(conn, cmd, cmd->cmd, NULL, NULL, 2,
1, silc_buffer_datalen(conn->internal->
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
out:
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/********************************** LEAVE ***********************************/
SilcClient client = conn->client;
SilcChannelEntry channel;
SilcBuffer idp;
- char *name;
+ char *name, tmp[512];
if (cmd->argc != 2) {
SAY(conn->client, conn, SILC_CLIENT_MESSAGE_INFO,
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL);
goto out;
}
- name = conn->current_channel->channel_name;
+
+ if (client->internal->params->full_channel_names)
+ silc_snprintf(tmp, sizeof(tmp), conn->current_channel->channel_name);
+ else
+ silc_snprintf(tmp, sizeof(tmp), "%s%s%s",
+ conn->current_channel->channel_name,
+ conn->current_channel->server[0] ? "@" : "",
+ conn->current_channel->server);
+ name = tmp;
} else {
name = cmd->argv[1];
}
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
out:
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/********************************** USERS ***********************************/
{
SilcClientCommandContext cmd = fsm_context;
SilcClientConnection conn = cmd->conn;
- char *name;
+ char *name, tmp[512];
if (cmd->argc != 2) {
SAY(conn->client, conn, SILC_CLIENT_MESSAGE_INFO,
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL);
goto out;
}
- name = conn->current_channel->channel_name;
+
+ if (conn->client->internal->params->full_channel_names)
+ silc_snprintf(tmp, sizeof(tmp), conn->current_channel->channel_name);
+ else
+ silc_snprintf(tmp, sizeof(tmp), "%s%s%s",
+ conn->current_channel->channel_name,
+ conn->current_channel->server[0] ? "@" : "",
+ conn->current_channel->server);
+ name = tmp;
} else {
name = cmd->argv[1];
}
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
out:
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/********************************* GETKEY ***********************************/
SilcClientEntry client_entry;
SilcServerEntry server_entry;
SilcDList clients;
- char *nickname = NULL;
SilcBuffer idp;
if (cmd->argc < 2) {
client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /GETKEY <nickname or server name>");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- SILC_FSM_FINISH;
- }
-
- /* Parse the typed nickname. */
- if (!silc_client_nickname_parse(client, conn, cmd->argv[1], &nickname)) {
- COMMAND_ERROR(SILC_STATUS_ERR_RESOURCE_LIMIT);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/* Find client entry */
- clients = silc_client_get_clients_local(client, conn, nickname,
- cmd->argv[1]);
+ clients = silc_client_get_clients_local(client, conn, cmd->argv[1], FALSE);
if (!clients) {
/* Check whether user requested server */
server_entry = silc_client_get_server(client, conn, cmd->argv[1]);
errors are handled in the resolving callback. */
COMMAND_ERROR(SILC_STATUS_ERR_NO_SUCH_NICK);
COMMAND_ERROR(SILC_STATUS_ERR_NO_SUCH_SERVER);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/* No client or server exist with this name, query for both. */
1, silc_buffer_datalen(idp));
silc_buffer_free(idp);
- silc_free(nickname);
/* Notify application */
COMMAND(SILC_STATUS_OK);
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/********************************* SERVICE **********************************/
SAY(conn->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /SERVICE [<service name>] [-pubkey]");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
name = cmd->argv[1];
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
- SILC_FSM_CONTINUE;
+ return SILC_FSM_CONTINUE;
}
/* Register all default commands provided by the client library for the
SilcCommandPayload payload,
SilcArgumentPayload args)
{
-#if 0
SilcDList attrs;
unsigned char *tmp;
SilcUInt32 tmp_len;
return;
}
- /* Send the attributes back */
+ /* Send the attributes back in COMMAND_REPLY packet */
packet =
silc_command_reply_payload_encode_va(SILC_COMMAND_WHOIS,
SILC_STATUS_OK, 0,
silc_command_get_ident(payload),
- 1, 11, buffer->data, buffer->len);
- silc_client_packet_send(client, sock, SILC_PACKET_COMMAND_REPLY,
- NULL, 0, NULL, NULL, packet->data,
- packet->len, TRUE);
+ 1, 11, buffer->data,
+ silc_buffer_len(buffer));
+ if (!packet) {
+ silc_buffer_free(buffer);
+ return;
+ }
+
+ SILC_LOG_DEBUG(("Sending back requested WHOIS attributes"));
+
+ silc_packet_send(conn->stream, SILC_PACKET_COMMAND_REPLY, 0,
+ silc_buffer_datalen(packet));
+
silc_buffer_free(packet);
silc_buffer_free(buffer);
-#endif /* 0 */
}
/* Client is able to receive some command packets even though they are
silc_buffer_len(&packet->buffer));
if (!payload) {
SILC_LOG_DEBUG(("Bad command packet"));
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}
/* Get arguments */
}
silc_command_payload_free(payload);
- SILC_FSM_FINISH;
+ return SILC_FSM_FINISH;
}