Author: Pekka Riikonen <priikone@silcnet.org>
- 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
if (status != SILC_STATUS_OK)
silc_fsm_next(&cmd->thread, silc_client_command_continue_error);
- if (clients)
- silc_dlist_uninit(clients);
-
/* Continue with the 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
void *fsm_context,
void *destructor_context)
{
- silc_client_command_free(fsm_context);
+ SilcClientCommandContext cmd = fsm_context;
+ SilcClientConnection conn = cmd->conn;
+
+ /* Removes commands that aren't waiting for reply but are waiting
+ for something. They may not have been removed yet. */
+ silc_list_del(conn->internal->pending_commands, cmd);
+
+ silc_client_command_free(cmd);
}
/* Add a command pending a command reply. Used internally by the library. */
SILC_LOG_DEBUG(("Send command %s", silc_get_command_name(command)));
+ if (conn->internal->disconnected)
+ return 0;
+
if (!cmd->cmd_ident)
cmd->cmd_ident = silc_client_cmd_ident(conn);
SILC_LOG_DEBUG(("Send command %s", silc_get_command_name(command)));
+ if (conn->internal->disconnected)
+ return 0;
+
if (!cmd->cmd_ident)
cmd->cmd_ident = silc_client_cmd_ident(conn);
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 */
SilcAttributeObjPk obj;
SilcPublicKey pk;
- if (!silc_pkcs_load_public_key(pubkey, &pk)) {
- SAY(client, conn, SILC_CLIENT_MESSAGE_ERROR,
+ if (!silc_pkcs_load_public_key(pubkey, SILC_PKCS_ANY, &pk)) {
+ 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);
goto out;
break;
}
- obj.data = silc_pkcs_public_key_encode(pk, &obj.data_len);
+ obj.data = silc_pkcs_public_key_encode(NULL, pk, &obj.data_len);
attrs = silc_attribute_payload_encode(attrs,
SILC_ATTRIBUTE_USER_PUBLIC_KEY,
SILC_ATTRIBUTE_FLAG_VALID,
&obj, sizeof(obj));
+ silc_free(obj.data);
+ }
+
+ if (nick) {
+ if (!silc_client_nickname_parse(client, conn, cmd->argv[1], &nickname))
+ goto out;
}
/* 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);
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;
{
SilcClientCommandContext cmd = fsm_context;
SilcClientConnection conn = cmd->conn;
- SilcChannelEntry channel;
+ SilcClient client = conn->client;
+ SilcChannelEntry channel = NULL;
SilcBuffer idp = NULL;
if (cmd->argc == 2) {
1, 1, silc_buffer_datalen(idp));
silc_buffer_free(idp);
+ silc_client_unref_channel(client, conn, channel);
/* Notify application */
COMMAND(SILC_STATUS_OK);
{
SilcClientCommandContext cmd = fsm_context;
SilcClientConnection conn = cmd->conn;
+ 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];
}
1, silc_buffer_datalen(idp));
silc_buffer_free(idp);
+ silc_client_unref_channel(client, conn, channel);
/* Notify application */
COMMAND(SILC_STATUS_OK);
SilcClientConnection conn = cmd->conn;
SilcClient client = conn->client;
SilcClientEntry client_entry = NULL;
- SilcChannelEntry channel;
+ SilcChannelEntry channel = NULL;
SilcBuffer clidp, chidp, args = NULL;
SilcPublicKey pubkey = NULL;
SilcDList clients = NULL;
}
channel = conn->current_channel;
+ silc_client_ref_channel(client, conn, channel);
} else {
name = cmd->argv[1];
/* Parse the typed nickname. */
if (cmd->argc == 3) {
if (cmd->argv[2][0] != '+' && cmd->argv[2][0] != '-') {
- if (client->internal->params->nickname_parse)
- client->internal->params->nickname_parse(cmd->argv[2], &nickname);
- else
- nickname = strdup(cmd->argv[2]);
+ if (!silc_client_nickname_parse(client, conn, cmd->argv[2], &nickname)) {
+ silc_client_unref_channel(client, conn, channel);
+ goto out;
+ }
/* 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));
action[0] = 0x01;
/* Check if it is public key file to be added to invite list */
- silc_pkcs_load_public_key(cmd->argv[2] + 1, &pubkey);
+ silc_pkcs_load_public_key(cmd->argv[2] + 1, SILC_PKCS_ANY, &pubkey);
invite = cmd->argv[2];
if (!pubkey)
invite++;
SILC_STR_UI_SHORT(1),
SILC_STR_END);
if (pubkey) {
- chidp = silc_public_key_payload_encode(pubkey);
+ chidp = silc_public_key_payload_encode(NULL, pubkey);
args = silc_argument_payload_encode_one(args, silc_buffer_data(chidp),
silc_buffer_len(chidp), 2);
silc_buffer_free(chidp);
silc_buffer_free(args);
silc_free(nickname);
silc_client_list_free(client, conn, clients);
+ silc_client_unref_channel(client, conn, channel);
/* Notify application */
COMMAND(SILC_STATUS_OK);
{
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 */
- conn->callback(client, conn, SILC_CLIENT_CONN_DISCONNECTED,
- 0, NULL, conn->callback_context);
-
/* Signal to close connection */
- conn->internal->disconnected = TRUE;
- SILC_FSM_SEMA_POST(&conn->internal->wait_event);
+ conn->internal->status = SILC_CLIENT_CONN_DISCONNECTED;
+ if (!conn->internal->disconnected) {
+ conn->internal->disconnected = TRUE;
+ SILC_FSM_EVENT_SIGNAL(&conn->internal->wait_event);
+ }
return SILC_FSM_FINISH;
}
/********************************** KILL ************************************/
+/* Signature callback */
+
+static void silc_client_command_kill_signed(const SilcBuffer buffer,
+ void *context)
+{
+ SilcClientCommandContext cmd = context;
+
+ if (!buffer) {
+ silc_fsm_finish(&cmd->thread);
+ return;
+ }
+
+ silc_fsm_set_state_context(&cmd->thread, buffer);
+ SILC_FSM_CALL_CONTINUE_SYNC(&cmd->thread);
+}
+
+/* Send KILL command */
+
+SILC_FSM_STATE(silc_client_command_kill_send)
+{
+ SilcClientCommandContext cmd = fsm_context;
+ SilcClientConnection conn = cmd->conn;
+ SilcClient client = conn->client;
+ SilcBuffer idp, auth = state_context;
+ SilcClientEntry target = cmd->context;
+ char *comment = NULL;
+
+ if (cmd->argc >= 3)
+ if (strcasecmp(cmd->argv[2], "-pubkey"))
+ comment = cmd->argv[2];
+
+ /* Send the KILL command to the server */
+ idp = silc_id_payload_encode(&target->id, SILC_ID_CLIENT);
+ silc_client_command_send_va(conn, cmd, cmd->cmd, NULL, NULL, 3,
+ 1, silc_buffer_datalen(idp),
+ 2, comment, comment ? strlen(comment) : 0,
+ 3, silc_buffer_datalen(auth));
+
+ silc_buffer_free(idp);
+ silc_client_unref_client(client, conn, target);
+
+ /* Notify application */
+ COMMAND(SILC_STATUS_OK);
+
+ /** Wait for command reply */
+ silc_fsm_next(fsm, silc_client_command_reply_wait);
+ return SILC_FSM_CONTINUE;
+}
/* Command KILL. Router operator can use this command to remove an client
fromthe SILC Network. */
SilcClientCommandContext cmd = fsm_context;
SilcClientConnection conn = cmd->conn;
SilcClient client = conn->client;
- SilcBuffer idp, auth = NULL;
SilcClientEntry target;
SilcDList clients;
- char *nickname = NULL, *comment = NULL;
+ char *nickname = NULL;
if (cmd->argc < 2) {
SAY(conn->client, conn, SILC_CLIENT_MESSAGE_INFO,
}
/* Parse the typed nickname. */
- if (client->internal->params->nickname_parse)
- client->internal->params->nickname_parse(cmd->argv[1], &nickname);
- else
- nickname = strdup(cmd->argv[1]);
- if (!nickname)
+ if (!silc_client_nickname_parse(client, conn, cmd->argv[1], &nickname))
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));
target = silc_dlist_get(clients);
+ cmd->context = silc_client_ref_client(client, conn, target);
- if (cmd->argc >= 3) {
- if (strcasecmp(cmd->argv[2], "-pubkey"))
- comment = cmd->argv[2];
+ silc_free(nickname);
+ silc_client_list_free(client, conn, clients);
+
+ /** Send KILL */
+ silc_fsm_next(fsm, silc_client_command_kill_send);
+ if (cmd->argc >= 3) {
if (!strcasecmp(cmd->argv[2], "-pubkey") ||
(cmd->argc >= 4 && !strcasecmp(cmd->argv[3], "-pubkey"))) {
/* Encode the public key authentication payload */
- auth = silc_auth_public_key_auth_generate(conn->public_key,
- conn->private_key,
- conn->client->rng,
- conn->internal->sha1hash,
- &target->id, SILC_ID_CLIENT);
+ SILC_FSM_CALL(silc_auth_public_key_auth_generate(
+ conn->public_key,
+ conn->private_key,
+ conn->client->rng,
+ conn->internal->sha1hash,
+ &target->id, SILC_ID_CLIENT,
+ silc_client_command_kill_signed,
+ cmd));
+ /* NOT REACHED */
}
}
- /* Send the KILL command to the server */
- idp = silc_id_payload_encode(&target->id, SILC_ID_CLIENT);
- silc_client_command_send_va(conn, cmd, cmd->cmd, NULL, NULL, 3,
- 1, silc_buffer_datalen(idp),
- 2, comment, comment ? strlen(comment) : 0,
- 3, silc_buffer_datalen(auth));
- silc_buffer_free(idp);
- silc_buffer_free(auth);
- silc_free(nickname);
- silc_client_list_free(client, conn, clients);
-
- /* Notify application */
- COMMAND(SILC_STATUS_OK);
-
- /** Wait for command reply */
- silc_fsm_next(fsm, silc_client_command_reply_wait);
return SILC_FSM_CONTINUE;
}
/********************************** JOIN ************************************/
+typedef struct {
+ int type;
+ SilcBuffer auth;
+ SilcBuffer cauth;
+} *SilcClientJoinContext;
+
+/* Signature callback */
+
+static void silc_client_command_join_signed(const SilcBuffer buffer,
+ void *context)
+{
+ SilcClientCommandContext cmd = context;
+ SilcClientJoinContext j = cmd->context;
+
+ if (!buffer) {
+ silc_fsm_finish(&cmd->thread);
+ return;
+ }
+
+ if (!j->type)
+ j->auth = silc_buffer_copy(buffer);
+ else
+ j->cauth = silc_buffer_copy(buffer);
+
+ SILC_FSM_CALL_CONTINUE(&cmd->thread);
+}
+
/* Command JOIN. Joins to a channel. */
SILC_FSM_STATE(silc_client_command_join)
{
- SilcClientCommandContext cmd = fsm_context;
+ SilcClientCommandContext cmd2, cmd = fsm_context;
SilcClientConnection conn = cmd->conn;
- SilcChannelEntry channel;
+ SilcClient client = conn->client;
+ SilcChannelEntry channel = NULL;
+ SilcClientJoinContext j = cmd->context;
SilcBuffer auth = NULL, cauth = NULL;
char *name, *passphrase = NULL, *pu8, *cipher = NULL, *hmac = NULL;
int i, passphrase_len = 0;
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;
} else if (!strcasecmp(cmd->argv[i], "-hmac") && cmd->argc > i + 1) {
hmac = cmd->argv[++i];
} else if (!strcasecmp(cmd->argv[i], "-founder")) {
- auth = silc_auth_public_key_auth_generate(conn->public_key,
- conn->private_key,
- conn->client->rng,
- conn->internal->sha1hash,
- conn->local_id,
- SILC_ID_CLIENT);
+ if (!j || !j->auth) {
+ if (!j) {
+ j = silc_calloc(1, sizeof(*j));
+ if (!j)
+ goto out;
+ cmd->context = j;
+ }
+ j->type = 0;
+ silc_free(passphrase);
+ silc_client_unref_channel(client, conn, channel);
+ SILC_FSM_CALL(silc_auth_public_key_auth_generate(
+ conn->public_key,
+ conn->private_key,
+ conn->client->rng,
+ conn->internal->sha1hash,
+ conn->local_id,
+ SILC_ID_CLIENT,
+ silc_client_command_join_signed,
+ cmd));
+ /* NOT REACHED */
+ }
} else if (!strcasecmp(cmd->argv[i], "-auth")) {
SilcPublicKey pubkey = conn->public_key;
SilcPrivateKey privkey = conn->private_key;
- unsigned char *pk, pkhash[SILC_HASH_MAXLEN], *pubdata;
+ unsigned char *pk, pkhash[SILC_HASH_MAXLEN], pubdata[128];
SilcUInt32 pk_len;
- if (cmd->argc >= i + 3) {
- char *pass = "";
- if (cmd->argc >= i + 4) {
- pass = cmd->argv[i + 3];
- i++;
+ if (!j || !j->cauth) {
+ if (!j) {
+ j = silc_calloc(1, sizeof(*j));
+ if (!j)
+ goto out;
+ cmd->context = j;
}
- if (!silc_load_key_pair(cmd->argv[i + 1], cmd->argv[i + 2], pass,
- &pubkey, &privkey)) {
- SAY(conn->client, conn, SILC_CLIENT_MESSAGE_ERROR,
- "Could not load key pair, check your arguments");
- COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- goto out;
+
+ if (cmd->argc >= i + 3) {
+ char *pass = "";
+ if (cmd->argc >= i + 4) {
+ pass = cmd->argv[i + 3];
+ i++;
+ }
+ if (!silc_load_key_pair(cmd->argv[i + 1], cmd->argv[i + 2], pass,
+ &pubkey, &privkey)) {
+ 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;
+ }
+ i += 2;
}
- i += 2;
- }
- pk = silc_pkcs_public_key_encode(pubkey, &pk_len);
- silc_hash_make(conn->internal->sha1hash, pk, pk_len, pkhash);
- silc_free(pk);
- pubdata = silc_rng_get_rn_data(conn->client->rng, 128);
- memcpy(pubdata, pkhash, 20);
- cauth = silc_auth_public_key_auth_generate_wpub(pubkey, privkey,
- pubdata, 128,
- conn->internal->sha1hash,
- conn->local_id,
- SILC_ID_CLIENT);
- memset(pubdata, 0, 128);
- silc_free(pubdata);
+ j->type = 1;
+ pk = silc_pkcs_public_key_encode(NULL, pubkey, &pk_len);
+ silc_hash_make(conn->internal->sha1hash, pk, pk_len, pkhash);
+ silc_free(pk);
+ silc_rng_get_rn_data(conn->client->rng, sizeof(pubdata), pubdata,
+ sizeof(pubdata));
+ memcpy(pubdata, pkhash, 20);
+ silc_free(passphrase);
+ silc_client_unref_channel(client, conn, channel);
+ SILC_FSM_CALL(silc_auth_public_key_auth_generate_wpub(
+ pubkey, privkey,
+ pubdata, sizeof(pubdata),
+ conn->internal->sha1hash,
+ client->rng,
+ conn->local_id,
+ SILC_ID_CLIENT,
+ silc_client_command_join_signed,
+ cmd));
+ /* NOT REACHED */
+ }
} else {
/* Passphrases must be UTF-8 encoded, so encode if it is not */
if (!silc_utf8_valid(cmd->argv[i], cmd->argv_lens[i])) {
6, silc_buffer_datalen(auth),
7, silc_buffer_datalen(cauth));
- silc_buffer_free(auth);
- silc_buffer_free(cauth);
if (passphrase)
memset(passphrase, 0, strlen(passphrase));
silc_free(passphrase);
+ silc_client_unref_channel(client, conn, channel);
+ if (j) {
+ silc_buffer_free(j->auth);
+ silc_buffer_free(j->cauth);
+ silc_free(j);
+ }
/* Notify application */
COMMAND(SILC_STATUS_OK);
return SILC_FSM_CONTINUE;
out:
+ silc_client_unref_channel(client, conn, channel);
return SILC_FSM_FINISH;
}
/********************************** CMODE ***********************************/
+/* Signature callback */
+
+static void silc_client_command_cmode_signed(const SilcBuffer buffer,
+ void *context)
+{
+ SilcClientCommandContext cmd = context;
+
+ if (!buffer) {
+ silc_fsm_finish(&cmd->thread);
+ return;
+ }
+
+ silc_fsm_set_state_context(&cmd->thread, buffer);
+ SILC_FSM_CALL_CONTINUE_SYNC(&cmd->thread);
+}
+
/* CMODE command. Sets channel mode. Modes that does not require any arguments
can be set several at once. Those modes that require argument must be set
separately (unless set with modes that does not require arguments). */
SilcClientCommandContext cmd = fsm_context;
SilcClientConnection conn = cmd->conn;
SilcClient client = conn->client;
- SilcChannelEntry channel;
- SilcBuffer chidp, auth = NULL, pk = NULL;
+ SilcBuffer auth = state_context;
+ SilcChannelEntry channel = NULL;
+ SilcBuffer chidp, pk = NULL;
unsigned char *name, *cp, modebuf[4], tmp[4], *arg = NULL;
SilcUInt32 mode, add, type, len, arg_len = 0;
int i;
}
channel = conn->current_channel;
+ silc_client_ref_channel(client, conn, channel);
} else {
name = cmd->argv[1];
break;
case 'f':
if (add) {
- SilcPublicKey pubkey = conn->public_key;
- SilcPrivateKey privkey = conn->private_key;
-
- mode |= SILC_CHANNEL_MODE_FOUNDER_AUTH;
- type = 7;
-
- if (cmd->argc >= 5) {
- char *pass = "";
- if (cmd->argc >= 6)
- 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,
- "Could not load key pair, check your arguments");
- COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- goto out;
+ if (!auth) {
+ SilcPublicKey pubkey = conn->public_key;
+ SilcPrivateKey privkey = conn->private_key;
+
+ mode |= SILC_CHANNEL_MODE_FOUNDER_AUTH;
+ type = 7;
+
+ if (cmd->argc >= 5) {
+ char *pass = "";
+ if (cmd->argc >= 6)
+ pass = cmd->argv[5];
+ if (!silc_load_key_pair(cmd->argv[3], cmd->argv[4], pass,
+ &pubkey, &privkey)) {
+ 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;
+ }
}
- }
- pk = silc_public_key_payload_encode(pubkey);
- auth = silc_auth_public_key_auth_generate(pubkey, privkey,
- conn->client->rng,
- conn->internal->sha1hash,
- conn->local_id,
- SILC_ID_CLIENT);
+ pk = silc_public_key_payload_encode(NULL, pubkey);
+ silc_client_unref_channel(client, conn, channel);
+ SILC_FSM_CALL(silc_auth_public_key_auth_generate(
+ pubkey, privkey,
+ conn->client->rng,
+ conn->internal->sha1hash,
+ conn->local_id,
+ SILC_ID_CLIENT,
+ silc_client_command_cmode_signed,
+ cmd));
+ /* NOT REACHED */
+ }
arg = silc_buffer_data(auth);
arg_len = silc_buffer_len(auth);
} else {
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) {
for (k = 3; k < cmd->argc; k++) {
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,
+ if (!silc_pkcs_load_public_key(cmd->argv[k] + 1, SILC_PKCS_ANY,
+ &chpk)) {
+ 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);
}
if (chpk) {
- pk = silc_public_key_payload_encode(chpk);
+ pk = silc_public_key_payload_encode(NULL, chpk);
auth = silc_argument_payload_encode_one(auth,
silc_buffer_datalen(pk),
chadd ? 0x00 : 0x01);
silc_buffer_free(chidp);
silc_buffer_free(auth);
silc_buffer_free(pk);
+ silc_client_unref_channel(client, conn, channel);
/* Notify application */
COMMAND(SILC_STATUS_OK);
return SILC_FSM_CONTINUE;
out:
+ silc_client_unref_channel(client, conn, channel);
return SILC_FSM_FINISH;
}
/********************************* CUMODE ***********************************/
+/* Signature callback */
+
+static void silc_client_command_cumode_signed(const SilcBuffer buffer,
+ void *context)
+{
+ SilcClientCommandContext cmd = context;
+
+ if (!buffer) {
+ silc_fsm_finish(&cmd->thread);
+ return;
+ }
+
+ silc_fsm_set_state_context(&cmd->thread, buffer);
+ SILC_FSM_CALL_CONTINUE_SYNC(&cmd->thread);
+}
+
/* CUMODE command. Changes client's mode on a channel. */
SILC_FSM_STATE(silc_client_command_cumode)
SilcClientCommandContext cmd = fsm_context;
SilcClientConnection conn = cmd->conn;
SilcClient client = conn->client;
- SilcChannelEntry channel;
+ SilcBuffer auth = state_context;
+ SilcChannelEntry channel = NULL;
SilcChannelUser chu;
SilcClientEntry client_entry;
- SilcBuffer clidp, chidp, auth = NULL;
+ SilcBuffer clidp, chidp;
SilcDList clients = NULL;
unsigned char *name, *cp, modebuf[4];
SilcUInt32 mode = 0, add, len;
}
channel = conn->current_channel;
+ silc_client_ref_channel(client, conn, channel);
} else {
name = cmd->argv[1];
}
/* Parse the typed nickname. */
- if (client->internal->params->nickname_parse)
- client->internal->params->nickname_parse(cmd->argv[3], &nickname);
- else
- nickname = strdup(cmd->argv[3]);
+ if (!silc_client_nickname_parse(client, conn, cmd->argv[3], &nickname))
+ goto out;
/* 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));
break;
case 'f':
if (add) {
- SilcPublicKey pubkey = conn->public_key;
- SilcPrivateKey privkey = conn->private_key;
-
- if (cmd->argc >= 6) {
- char *pass = "";
- if (cmd->argc >= 7)
- 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,
- "Could not load key pair, check your arguments");
- COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- goto out;
+ if (!auth) {
+ SilcPublicKey pubkey = conn->public_key;
+ SilcPrivateKey privkey = conn->private_key;
+
+ if (cmd->argc >= 6) {
+ char *pass = "";
+ if (cmd->argc >= 7)
+ 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_COMMAND_ERROR,
+ "Could not load key pair, check your arguments");
+ COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
+ goto out;
+ }
}
+
+ silc_free(nickname);
+ silc_client_list_free(client, conn, clients);
+ silc_client_unref_channel(client, conn, channel);
+
+ SILC_FSM_CALL(silc_auth_public_key_auth_generate(
+ pubkey, privkey,
+ conn->client->rng,
+ conn->internal->sha1hash,
+ conn->local_id,
+ SILC_ID_CLIENT,
+ silc_client_command_cumode_signed,
+ cmd));
+ /* NOT REACHED */
}
- auth = silc_auth_public_key_auth_generate(pubkey, privkey,
- conn->client->rng,
- conn->internal->sha1hash,
- conn->local_id,
- SILC_ID_CLIENT);
mode |= SILC_CHANNEL_UMODE_CHANFO;
} else {
mode &= ~SILC_CHANNEL_UMODE_CHANFO;
silc_buffer_free(auth);
silc_free(nickname);
silc_client_list_free(client, conn, clients);
+ silc_client_unref_channel(client, conn, channel);
/* Notify application */
COMMAND(SILC_STATUS_OK);
return SILC_FSM_CONTINUE;
out:
+ silc_client_unref_channel(client, conn, channel);
silc_client_list_free(client, conn, clients);
silc_free(nickname);
return SILC_FSM_FINISH;
SilcClientCommandContext cmd = fsm_context;
SilcClientConnection conn = cmd->conn;
SilcClient client = conn->client;
- SilcChannelEntry channel;
+ SilcChannelEntry channel = NULL;
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. */
- if (client->internal->params->nickname_parse)
- client->internal->params->nickname_parse(cmd->argv[2], &nickname);
- else
- nickname = strdup(cmd->argv[2]);
-
/* 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);
/* Notify application */
COMMAND(SILC_STATUS_OK);
return SILC_FSM_CONTINUE;
out:
- silc_free(nickname);
+ silc_client_unref_channel(client, conn, channel);
return SILC_FSM_FINISH;
}
typedef struct {
unsigned char *passphrase;
SilcUInt32 passphrase_len;
+ SilcBuffer auth;
} *SilcClientCommandOper;
/* 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;
SILC_FSM_CALL_CONTINUE(&cmd->thread);
}
+static void silc_client_command_oper_sign_cb(const SilcBuffer data,
+ void *context)
+{
+ SilcClientCommandContext cmd = context;
+ SilcClientCommandOper oper = cmd->context;
+
+ if (data)
+ oper->auth = silc_buffer_copy(data);
+
+ /* Continue */
+ SILC_FSM_CALL_CONTINUE(&cmd->thread);
+}
+
/* Send OPER/SILCOPER command */
SILC_FSM_STATE(silc_client_command_oper_send)
SilcClientCommandContext cmd = fsm_context;
SilcClientConnection conn = cmd->conn;
SilcClientCommandOper oper = cmd->context;
- SilcBuffer auth;
-
- if (!oper || !oper->passphrase) {
- /* Encode the public key authentication payload */
- auth = silc_auth_public_key_auth_generate(conn->public_key,
- conn->private_key,
- conn->client->rng,
- conn->internal->hash,
- conn->local_id,
- SILC_ID_CLIENT);
- } else {
- /* Encode the password authentication payload */
- auth = silc_auth_payload_encode(SILC_AUTH_PASSWORD, NULL, 0,
- oper->passphrase, oper->passphrase_len);
- }
+ SilcBuffer auth = oper ? oper->auth : NULL;
silc_client_command_send_va(conn, cmd, cmd->cmd, NULL, NULL, 2,
1, cmd->argv[1], strlen(cmd->argv[1]),
return SILC_FSM_CONTINUE;
}
+/* Get authentication data */
+
+SILC_FSM_STATE(silc_client_command_oper_get_auth)
+{
+ SilcClientCommandContext cmd = fsm_context;
+ SilcClientConnection conn = cmd->conn;
+ SilcClientCommandOper oper = cmd->context;
+
+ silc_fsm_next(fsm, silc_client_command_oper_send);
+
+ if (!oper || !oper->passphrase) {
+ /* Encode the public key authentication payload */
+ SILC_FSM_CALL(silc_auth_public_key_auth_generate(
+ conn->public_key,
+ conn->private_key,
+ conn->client->rng,
+ conn->internal->hash,
+ conn->local_id, SILC_ID_CLIENT,
+ silc_client_command_oper_sign_cb,
+ oper));
+ /* NOT REACHED */
+ }
+
+ /* Encode the password authentication payload */
+ oper->auth = silc_auth_payload_encode(NULL, SILC_AUTH_PASSWORD, NULL, 0,
+ oper->passphrase, oper->passphrase_len);
+
+ return SILC_FSM_CONTINUE;
+}
+
/* OPER command. Used to obtain server operator privileges. */
SILC_FSM_STATE(silc_client_command_oper)
return SILC_FSM_FINISH;
}
+ silc_fsm_next(fsm, silc_client_command_oper_get_auth);
+
/* Get passphrase */
if (cmd->argc < 3) {
oper = silc_calloc(1, sizeof(*oper));
silc_client_command_oper_cb, cmd));
}
- silc_fsm_next(fsm, silc_client_command_oper_send);
return SILC_FSM_CONTINUE;
}
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));
silc_client_command_oper_cb, cmd));
}
- silc_fsm_next(fsm, silc_client_command_oper_send);
return SILC_FSM_CONTINUE;
}
{
SilcClientCommandContext cmd = fsm_context;
SilcClientConnection conn = cmd->conn;
+ SilcClient client = conn->client;
SilcChannelEntry channel;
SilcBuffer chidp, args = NULL;
char *name, *ban = NULL;
}
channel = conn->current_channel;
+ silc_client_ref_channel(client, conn, channel);
} else {
name = cmd->argv[1];
action[0] = 0x01;
/* Check if it is public key file to be added to invite list */
- silc_pkcs_load_public_key(cmd->argv[2] + 1, &pubkey);
+ silc_pkcs_load_public_key(cmd->argv[2] + 1, SILC_PKCS_ANY, &pubkey);
ban = cmd->argv[2];
if (!pubkey)
ban++;
SILC_STR_UI_SHORT(1),
SILC_STR_END);
if (pubkey) {
- chidp = silc_public_key_payload_encode(pubkey);
+ chidp = silc_public_key_payload_encode(NULL, pubkey);
args = silc_argument_payload_encode_one(args,
silc_buffer_datalen(chidp), 2);
silc_buffer_free(chidp);
silc_buffer_free(chidp);
silc_buffer_free(args);
+ silc_client_unref_channel(client, conn, channel);
/* Notify application */
COMMAND(SILC_STATUS_OK);
SilcPublicKey pk;
SilcBuffer buffer;
- if (!silc_pkcs_load_public_key(pubkey, &pk)) {
- SAY(conn->client, conn, SILC_CLIENT_MESSAGE_ERROR,
+ if (!silc_pkcs_load_public_key(pubkey, SILC_PKCS_ANY, &pk)) {
+ 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_buffer_format(args,
SILC_STR_UI_SHORT(1),
SILC_STR_END);
- buffer = silc_public_key_payload_encode(pk);
+ buffer = silc_public_key_payload_encode(NULL, pk);
args = silc_argument_payload_encode_one(args, silc_buffer_datalen(buffer),
pubkey_add ? 0x00 : 0x01);
silc_buffer_free(buffer);
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->
{
SilcClientCommandContext cmd = fsm_context;
SilcClientConnection conn = cmd->conn;
+ 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];
}
if (conn->current_channel == channel)
conn->current_channel = NULL;
+ silc_client_unref_channel(client, conn, channel);
+
/** Wait for command reply */
silc_fsm_next(fsm, silc_client_command_reply_wait);
return SILC_FSM_CONTINUE;
{
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];
}
SilcClientEntry client_entry;
SilcServerEntry server_entry;
SilcDList clients;
- char *nickname = NULL;
SilcBuffer idp;
if (cmd->argc < 2) {
return SILC_FSM_FINISH;
}
- /* Parse the typed nickname. */
- if (client->internal->params->nickname_parse)
- client->internal->params->nickname_parse(cmd->argv[1], &nickname);
- else
- nickname = strdup(cmd->argv[1]);
- if (!nickname) {
- COMMAND_ERROR(SILC_STATUS_ERR_RESOURCE_LIMIT);
- 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]);
1, silc_buffer_datalen(idp));
silc_buffer_free(idp);
- silc_free(nickname);
/* Notify application */
COMMAND(SILC_STATUS_OK);
/****************** Client Side Incoming Command Handling *******************/
-/* Reply to WHOIS command from server */
+typedef struct {
+ SilcClientConnection conn;
+ SilcUInt16 cmd_ident;
+} *SilcClientProcessWhois;
+
+/* Send reply to WHOIS from server */
+
+static void
+silc_client_command_process_whois_send(SilcBool success,
+ const unsigned char *data,
+ SilcUInt32 data_len, void *context)
+{
+ SilcClientProcessWhois w = context;
+ SilcBufferStruct buffer;
+ SilcBuffer packet;
+
+ if (!data) {
+ silc_free(w);
+ return;
+ }
+
+ silc_buffer_set(&buffer, (unsigned char *)data, data_len);
+
+ /* Send the attributes back in COMMAND_REPLY packet */
+ packet =
+ silc_command_reply_payload_encode_va(SILC_COMMAND_WHOIS,
+ SILC_STATUS_OK, 0, w->cmd_ident,
+ 1, 11, buffer.data,
+ silc_buffer_len(&buffer));
+ if (!packet) {
+ silc_free(w);
+ return;
+ }
+
+ SILC_LOG_DEBUG(("Sending back requested WHOIS attributes"));
+
+ silc_packet_send(w->conn->stream, SILC_PACKET_COMMAND_REPLY, 0,
+ silc_buffer_datalen(packet));
+
+ silc_buffer_free(packet);
+ silc_free(w);
+}
+
+/* Process WHOIS command from server */
static void silc_client_command_process_whois(SilcClient client,
SilcClientConnection conn,
SilcCommandPayload payload,
SilcArgumentPayload args)
{
-#if 0
+ SilcClientProcessWhois w;
SilcDList attrs;
unsigned char *tmp;
SilcUInt32 tmp_len;
- SilcBuffer buffer, packet;
SILC_LOG_DEBUG(("Received WHOIS command"));
if (!attrs)
return;
- /* Process requested attributes */
- buffer = silc_client_attributes_process(client, conn, attrs);
- if (!buffer) {
+ w = silc_calloc(1, sizeof(*w));
+ if (!w) {
silc_attribute_payload_list_free(attrs);
return;
}
+ w->conn = conn;
+ w->cmd_ident = silc_command_get_ident(payload);
- /* Send the attributes back */
- 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);
- silc_buffer_free(packet);
- silc_buffer_free(buffer);
-#endif /* 0 */
+ /* Process requested attributes */
+ silc_client_attributes_process(client, conn, attrs,
+ silc_client_command_process_whois_send, w);
+ silc_attribute_payload_list_free(attrs);
}
/* Client is able to receive some command packets even though they are
case SILC_COMMAND_WHOIS:
/* Ignore everything if requested by application */
- if (client->internal->params->ignore_requested_attributes)
+ if (conn->internal->params.ignore_requested_attributes)
break;
silc_client_command_process_whois(client, conn, payload, args);
projects / silc.git / blobdiff