/*
- command.c
+ command.c
Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1997 - 2002 Pekka Riikonen
+ Copyright (C) 1997 - 2003 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
x->internal->ops->say((x), (c), SILC_CLIENT_MESSAGE_ERROR, \
"You are not connected to a server, use /SERVER to connect");
-/* Command operation that is called at the end of all commands.
+/* Command operation that is called at the end of all commands.
Usage: COMMAND(status); */
#define COMMAND(status) cmd->client->internal->ops->command(cmd->client, \
cmd->conn, cmd, TRUE, cmd->command->cmd, (status))
va_start(ap, argc);
packet = silc_command_payload_encode_vap(command, ident, argc, ap);
- silc_client_packet_send(client, conn->sock, SILC_PACKET_COMMAND,
- NULL, 0, NULL, NULL, packet->data,
+ silc_client_packet_send(client, conn->sock, SILC_PACKET_COMMAND,
+ NULL, 0, NULL, NULL, packet->data,
packet->len, TRUE);
silc_buffer_free(packet);
}
ctx->argv = argv;
ctx->argv_lens = argv_lens;
ctx->argv_types = argv_types;
-
+
/* Call the command */
cmd->command(ctx, NULL);
SilcClientCommandPendingCallbacks
silc_client_command_pending_check(SilcClientConnection conn,
SilcClientCommandReplyContext ctx,
- SilcCommand command,
+ SilcCommand command,
SilcUInt16 ident,
SilcUInt32 *callbacks_count)
{
return ctx;
}
-/* Command WHOIS. This command is used to query information about
+/* Command WHOIS. This command is used to query information about
specific user. */
SILC_CLIENT_CMD_FUNC(whois)
/* Given without arguments fetches client's own information */
if (cmd->argc < 2) {
buffer = silc_id_payload_encode(cmd->conn->local_id, SILC_ID_CLIENT);
- silc_client_command_send(cmd->client, cmd->conn, SILC_COMMAND_WHOIS,
+ silc_client_command_send(cmd->client, cmd->conn, SILC_COMMAND_WHOIS,
++conn->cmd_ident,
1, 4, buffer->data, buffer->len);
silc_buffer_free(buffer);
if (cmd->argc == 2) {
buffer = silc_command_payload_encode_va(SILC_COMMAND_WHOIS,
++conn->cmd_ident, 1,
- 1, cmd->argv[1],
+ 1, cmd->argv[1],
cmd->argv_lens[1]);
} else {
if (!strcasecmp(cmd->argv[2], "-details"))
}
if (cmd->argc < 2 || cmd->argc > 3) {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /WHOWAS <nickname>[@<server>] [<count>]");
COMMAND_ERROR((cmd->argc < 2 ? SILC_STATUS_ERR_NOT_ENOUGH_PARAMS :
SILC_STATUS_ERR_TOO_MANY_PARAMS));
if (cmd->argc == 2) {
buffer = silc_command_payload_encode_va(SILC_COMMAND_WHOWAS,
++conn->cmd_ident, 1,
- 1, cmd->argv[1],
+ 1, cmd->argv[1],
cmd->argv_lens[1]);
} else {
int c = atoi(cmd->argv[2]);
silc_client_command_free(cmd);
}
-/* Command IDENTIFY. This command is used to query information about
- specific user, especially ID's.
+/* Command IDENTIFY. This command is used to query information about
+ specific user, especially ID's.
NOTE: This command is used only internally by the client library
and application MUST NOT call this command directly. */
goto out;
if (cmd->argc == 2) {
- buffer = silc_command_payload_encode_va(SILC_COMMAND_IDENTIFY,
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_IDENTIFY,
++conn->cmd_ident, 1,
1, cmd->argv[1],
cmd->argv_lens[1]);
int c = atoi(cmd->argv[2]);
memset(count, 0, sizeof(count));
SILC_PUT32_MSB(c, count);
- buffer = silc_command_payload_encode_va(SILC_COMMAND_IDENTIFY,
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_IDENTIFY,
++conn->cmd_ident, 2,
1, cmd->argv[1],
cmd->argv_lens[1],
}
if (cmd->argc < 2) {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /NICK <nickname>");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
/* Show current nickname */
if (cmd->argc < 2) {
if (cmd->conn) {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
- "Your nickname is %s on server %s",
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+ "Your nickname is %s on server %s",
conn->nickname, conn->remote_host);
} else {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Your nickname is %s", conn->nickname);
}
/* Send the NICK command */
buffer = silc_command_payload_encode(SILC_COMMAND_NICK, 1,
&cmd->argv[1],
- &cmd->argv_lens[1],
+ &cmd->argv_lens[1],
&cmd->argv_types[1],
++cmd->conn->cmd_ident);
silc_client_packet_send(cmd->client, cmd->conn->sock,
}
if (!idp)
- buffer = silc_command_payload_encode_va(SILC_COMMAND_LIST,
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_LIST,
++conn->cmd_ident, 0);
else
- buffer = silc_command_payload_encode_va(SILC_COMMAND_LIST,
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_LIST,
++conn->cmd_ident, 1,
1, idp->data, idp->len);
/* Send TOPIC command to the server */
idp = silc_id_payload_encode(id_cache->id, SILC_ID_CHANNEL);
if (cmd->argc > 2)
- buffer = silc_command_payload_encode_va(SILC_COMMAND_TOPIC,
- ++conn->cmd_ident, 2,
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_TOPIC,
+ ++conn->cmd_ident, 2,
1, idp->data, idp->len,
- 2, cmd->argv[2],
+ 2, cmd->argv[2],
strlen(cmd->argv[2]));
else
- buffer = silc_command_payload_encode_va(SILC_COMMAND_TOPIC,
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_TOPIC,
++conn->cmd_ident, 1,
1, idp->data, idp->len);
- silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
+ silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
0, NULL, NULL, buffer->data, buffer->len, TRUE);
silc_buffer_free(buffer);
silc_buffer_free(idp);
nickname = strdup(cmd->argv[2]);
/* Find client entry */
- client_entry = silc_idlist_get_client(client, conn, nickname,
+ client_entry = silc_idlist_get_client(client, conn, nickname,
cmd->argv[2], TRUE);
if (!client_entry) {
if (cmd->pending) {
COMMAND_ERROR(SILC_STATUS_ERR_NO_SUCH_NICK);
goto out;
}
-
+
/* Client entry not found, it was requested thus mark this to be
pending command. */
- silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY,
+ silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY,
conn->cmd_ident,
- silc_client_command_invite,
+ silc_client_command_invite,
silc_client_command_dup(cmd));
cmd->pending = 1;
goto out;
chidp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL);
if (client_entry) {
clidp = silc_id_payload_encode(client_entry->id, SILC_ID_CLIENT);
- buffer = silc_command_payload_encode_va(SILC_COMMAND_INVITE,
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_INVITE,
++conn->cmd_ident, 4,
1, chidp->data, chidp->len,
2, clidp->data, clidp->len,
args ? args->len : 0);
silc_buffer_free(clidp);
} else {
- buffer = silc_command_payload_encode_va(SILC_COMMAND_INVITE,
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_INVITE,
++conn->cmd_ident, 3,
1, chidp->data, chidp->len,
3, args ? action : NULL,
args ? args->len : 0);
}
- silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
+ silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
0, NULL, NULL, buffer->data, buffer->len, TRUE);
silc_buffer_free(buffer);
silc_buffer_free(chidp);
}
/* Command QUIT. Closes connection with current server. */
-
+
SILC_CLIENT_CMD_FUNC(quit)
{
SilcClientCommandContext cmd = (SilcClientCommandContext)context;
}
if (cmd->argc > 1)
- buffer = silc_command_payload_encode(SILC_COMMAND_QUIT, cmd->argc - 1,
+ buffer = silc_command_payload_encode(SILC_COMMAND_QUIT, cmd->argc - 1,
&cmd->argv[1], &cmd->argv_lens[1],
&cmd->argv_types[1], 0);
else
buffer = silc_command_payload_encode(SILC_COMMAND_QUIT, 0,
NULL, NULL, NULL, 0);
- silc_client_packet_send(cmd->client, cmd->conn->sock, SILC_PACKET_COMMAND,
- NULL, 0, NULL, NULL,
+ silc_client_packet_send(cmd->client, cmd->conn->sock, SILC_PACKET_COMMAND,
+ NULL, 0, NULL, NULL,
buffer->data, buffer->len, TRUE);
silc_buffer_free(buffer);
SilcClientConnection conn = cmd->conn;
SilcClientEntry target;
char *nickname = NULL;
-
+
/* Parse the typed nickname. */
if (client->internal->params->nickname_parse)
client->internal->params->nickname_parse(cmd->argv[1], &nickname);
nickname = strdup(cmd->argv[1]);
/* Get the target client */
- target = silc_idlist_get_client(cmd->client, conn, nickname,
+ target = silc_idlist_get_client(cmd->client, conn, nickname,
cmd->argv[1], FALSE);
if (target)
/* Remove the client from all channels and free it */
SILC_CLIENT_CMD_FUNC(kill_remove)
{
SilcClientCommandContext cmd = (SilcClientCommandContext)context;
- SilcClientCommandReplyContext reply =
+ SilcClientCommandReplyContext reply =
(SilcClientCommandReplyContext)context2;
SilcStatus status;
}
if (cmd->argc < 2) {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /KILL <nickname> [<comment>] [-pubkey]");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
nickname = strdup(cmd->argv[1]);
/* Get the target client */
- target = silc_idlist_get_client(cmd->client, conn, nickname,
+ target = silc_idlist_get_client(cmd->client, conn, nickname,
cmd->argv[1], TRUE);
if (!target) {
if (cmd->pending) {
/* Client entry not found, it was requested thus mark this to be
pending command. */
- silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY,
- conn->cmd_ident,
- silc_client_command_kill,
+ silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY,
+ conn->cmd_ident,
+ silc_client_command_kill,
silc_client_command_dup(cmd));
cmd->pending = 1;
goto out;
/* Send the KILL command to the server */
idp = silc_id_payload_encode(target->id, SILC_ID_CLIENT);
buffer =
- silc_command_payload_encode_va(SILC_COMMAND_KILL,
- ++conn->cmd_ident, 3,
+ silc_command_payload_encode_va(SILC_COMMAND_KILL,
+ ++conn->cmd_ident, 3,
1, idp->data, idp->len,
2, comment, comment ? strlen(comment) : 0,
3, auth ? auth->data : NULL,
/* Send the command */
if (name)
- buffer = silc_command_payload_encode_va(SILC_COMMAND_INFO, 0, 1,
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_INFO, 0, 1,
1, name, strlen(name));
else
buffer = silc_command_payload_encode(SILC_COMMAND_INFO, 0,
NULL, NULL, NULL, 0);
- silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
+ silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
0, NULL, NULL, buffer->data, buffer->len, TRUE);
silc_buffer_free(buffer);
if (name)
goto out;
}
- idp = silc_id_payload_encode(conn->remote_id, SILC_ID_SERVER);
-
+ idp = silc_id_payload_encode(conn->remote_id, SILC_ID_SERVER);
+
/* Send the command */
buffer = silc_command_payload_encode_va(SILC_COMMAND_STATS,
++conn->cmd_ident, 1,
SILC_ID_SERVER, idp->data, idp->len);
- silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
+ silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
0, NULL, NULL, buffer->data, buffer->len, TRUE);
silc_buffer_free(buffer);
silc_buffer_free(idp);
silc_client_command_free(cmd);
}
-/* Command PING. Sends ping to server. This is used to test the
+/* Command PING. Sends ping to server. This is used to test the
communication channel. */
SILC_CLIENT_CMD_FUNC(ping)
goto out;
}
- idp = silc_id_payload_encode(conn->remote_id, SILC_ID_SERVER);
+ idp = silc_id_payload_encode(conn->remote_id, SILC_ID_SERVER);
/* Send the command */
- buffer = silc_command_payload_encode_va(SILC_COMMAND_PING, 0, 1,
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_PING, 0, 1,
1, idp->data, idp->len);
- silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
+ silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
0, NULL, NULL, buffer->data, buffer->len, TRUE);
silc_buffer_free(buffer);
silc_buffer_free(idp);
conn->internal->ping[i].dest_name = strdup(conn->remote_host);
conn->internal->ping_count++;
}
-
+
/* Notify application */
COMMAND(SILC_STATUS_OK);
SilcClientCommandContext cmd = (SilcClientCommandContext)context;
SilcClientConnection conn = cmd->conn;
SilcChannelEntry channel;
- SilcBuffer buffer, idp, auth = NULL;
+ SilcBuffer buffer, idp, auth = NULL, cauth = NULL;
char *name, *passphrase = NULL, *pu8, *cipher = NULL, *hmac = NULL;
int i, passphrase_len = 0;
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
}
-
+
/* See if we have joined to the requested channel already */
channel = silc_client_get_channel(cmd->client, conn, cmd->argv[1]);
if (channel && silc_client_on_channel(channel, conn->local_entry))
} else if (!strcasecmp(cmd->argv[i], "-founder")) {
auth = silc_auth_public_key_auth_generate(cmd->client->public_key,
cmd->client->private_key,
- cmd->client->rng,
+ cmd->client->rng,
cmd->client->sha1hash,
conn->local_id,
SILC_ID_CLIENT);
i++;
+ } else if (!strcasecmp(cmd->argv[i], "-auth")) {
+ SilcPublicKey pubkey = cmd->client->public_key;
+ SilcPrivateKey privkey = cmd->client->private_key;
+ unsigned char *pk, pkhash[20], *pubdata;
+ SilcUInt32 pk_len;
+
+ 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,
+ NULL, &pubkey, &privkey)) {
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
+ "Could not load key pair, check your arguments");
+ COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
+ goto out;
+ }
+ i += 2;
+ }
+
+ pk = silc_pkcs_public_key_encode(pubkey, &pk_len);
+ silc_hash_make(cmd->client->sha1hash, pk, pk_len, pkhash);
+ silc_free(pk);
+ pubdata = silc_rng_get_rn_data(cmd->client->rng, 128);
+ memcpy(pubdata, pkhash, 20);
+ cauth = silc_auth_public_key_auth_generate_wpub(pubkey, privkey,
+ pubdata, 128,
+ cmd->client->sha1hash,
+ conn->local_id,
+ SILC_ID_CLIENT);
+ memset(pubdata, 0, 128);
+ silc_free(pubdata);
+ i++;
} else {
/* Passphrases must be UTF-8 encoded, so encode if it is not */
if (!silc_utf8_valid(cmd->argv[i], cmd->argv_lens[i])) {
- passphrase_len = silc_utf8_encoded_len(cmd->argv[i],
+ passphrase_len = silc_utf8_encoded_len(cmd->argv[i],
cmd->argv_lens[i], 0);
pu8 = silc_calloc(passphrase_len, sizeof(*pu8));
passphrase_len = silc_utf8_encode(cmd->argv[i], cmd->argv_lens[i],
/* Send JOIN command to the server */
buffer =
- silc_command_payload_encode_va(SILC_COMMAND_JOIN, 0, 6,
+ silc_command_payload_encode_va(SILC_COMMAND_JOIN, 0, 7,
1, name, strlen(name),
2, idp->data, idp->len,
3, passphrase, passphrase_len,
4, cipher, cipher ? strlen(cipher) : 0,
5, hmac, hmac ? strlen(hmac) : 0,
6, auth ? auth->data : NULL,
- auth ? auth->len : 0);
- silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
+ auth ? auth->len : 0,
+ 7, cauth ? cauth->data : NULL,
+ cauth ? cauth->len : 0);
+ silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
0, NULL, NULL, buffer->data, buffer->len, TRUE);
silc_buffer_free(buffer);
silc_buffer_free(idp);
- if (auth)
- silc_buffer_free(auth);
+ silc_buffer_free(auth);
+ silc_buffer_free(cauth);
if (passphrase)
memset(passphrase, 0, strlen(passphrase));
silc_free(passphrase);
/* Send TOPIC command to the server */
if (cmd->argc == 1)
- buffer = silc_command_payload_encode_va(SILC_COMMAND_MOTD, 0, 1,
- 1, conn->remote_host,
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_MOTD, 0, 1,
+ 1, conn->remote_host,
strlen(conn->remote_host));
else
- buffer = silc_command_payload_encode_va(SILC_COMMAND_MOTD, 0, 1,
- 1, cmd->argv[1],
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_MOTD, 0, 1,
+ 1, cmd->argv[1],
cmd->argv_lens[1]);
- silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
+ silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
0, NULL, NULL, buffer->data, buffer->len, TRUE);
silc_buffer_free(buffer);
}
if (cmd->argc < 2) {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /UMODE +|-<modes>");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
/* Send the command packet. We support sending only one mode at once
that requires an argument. */
- buffer =
- silc_command_payload_encode_va(SILC_COMMAND_UMODE, ++conn->cmd_ident, 2,
- 1, idp->data, idp->len,
+ buffer =
+ silc_command_payload_encode_va(SILC_COMMAND_UMODE, ++conn->cmd_ident, 2,
+ 1, idp->data, idp->len,
2, modebuf, sizeof(modebuf));
- silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
+ silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
0, NULL, NULL, buffer->data, buffer->len, TRUE);
silc_buffer_free(buffer);
silc_buffer_free(idp);
}
if (cmd->argc < 3) {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /CMODE <channel> +|-<modes> [{ <arguments>}]");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
mode |= SILC_CHANNEL_MODE_ULIMIT;
type = 3;
if (cmd->argc < 4) {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /CMODE <channel> +|-<modes> [{ <arguments>}]");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
mode |= SILC_CHANNEL_MODE_PASSPHRASE;
type = 4;
if (cmd->argc < 4) {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /CMODE <channel> +|-<modes> [{ <arguments>}]");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
mode |= SILC_CHANNEL_MODE_CIPHER;
type = 5;
if (cmd->argc < 4) {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /CMODE <channel> +|-<modes> [{ <arguments>}]");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
mode |= SILC_CHANNEL_MODE_HMAC;
type = 6;
if (cmd->argc < 4) {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /CMODE <channel> +|-<modes> [{ <arguments>}]");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
pk = silc_pkcs_public_key_payload_encode(pubkey);
auth = silc_auth_public_key_auth_generate(pubkey, privkey,
- cmd->client->rng,
+ cmd->client->rng,
cmd->client->sha1hash,
conn->local_id,
SILC_ID_CLIENT);
mode &= ~SILC_CHANNEL_MODE_FOUNDER_AUTH;
}
break;
+ case 'C':
+ if (add) {
+ int k;
+ bool chadd = FALSE;
+ SilcPublicKey chpk = NULL;
+
+ mode |= SILC_CHANNEL_MODE_CHANNEL_AUTH;
+ type = 9;
+
+ if (cmd->argc == 3) {
+ /* Send empty command to receive the public key list. */
+ chidp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL);
+ silc_client_command_send(cmd->client, conn, SILC_COMMAND_CMODE,
+ 0, 1, 1, chidp->data, chidp->len);
+ silc_buffer_free(chidp);
+
+ /* Notify application */
+ COMMAND(SILC_STATUS_OK);
+ goto out;
+ }
+
+ if (cmd->argc >= 4) {
+ auth = silc_buffer_alloc_size(2);
+ silc_buffer_format(auth,
+ SILC_STR_UI_SHORT(cmd->argc - 3),
+ SILC_STR_END);
+ }
+
+ 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,
+ SILC_PKCS_FILE_PEM))
+ if (!silc_pkcs_load_public_key(cmd->argv[k] + 1, &chpk,
+ SILC_PKCS_FILE_BIN)) {
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR,
+ "Could not load public key %s, check the filename",
+ cmd->argv[k]);
+ COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
+ silc_buffer_free(auth);
+ goto out;
+ }
+
+ if (chpk) {
+ pk = silc_pkcs_public_key_payload_encode(chpk);
+ auth = silc_argument_payload_encode_one(auth, pk->data, pk->len,
+ chadd ? 0x00 : 0x01);
+ silc_pkcs_public_key_free(chpk);
+ silc_buffer_free(pk);
+ pk = NULL;
+ }
+ }
+
+ arg = auth->data;
+ arg_len = auth->len;
+ } else {
+ mode &= ~SILC_CHANNEL_MODE_CHANNEL_AUTH;
+ }
+ break;
default:
COMMAND_ERROR(SILC_STATUS_ERR_UNKNOWN_MODE);
goto out;
/* Send the command packet. We support sending only one mode at once
that requires an argument. */
if (type && arg) {
- buffer =
+ buffer =
silc_command_payload_encode_va(SILC_COMMAND_CMODE, 0, 4,
- 1, chidp->data, chidp->len,
+ 1, chidp->data, chidp->len,
2, modebuf, sizeof(modebuf),
type, arg, arg_len,
8, pk ? pk->data : NULL,
pk ? pk->len : 0);
} else {
- buffer =
+ buffer =
silc_command_payload_encode_va(SILC_COMMAND_CMODE, 0, 2,
- 1, chidp->data, chidp->len,
+ 1, chidp->data, chidp->len,
2, modebuf, sizeof(modebuf));
}
- silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
+ silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
0, NULL, NULL, buffer->data, buffer->len, TRUE);
silc_buffer_free(buffer);
silc_buffer_free(chidp);
}
if (cmd->argc < 4) {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /CUMODE <channel> +|-<modes> <nickname>[@<server>]");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
/* Client entry not found, it was requested thus mark this to be
pending command. */
- silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY,
- conn->cmd_ident,
- silc_client_command_cumode,
+ silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY,
+ conn->cmd_ident,
+ silc_client_command_cumode,
silc_client_command_dup(cmd));
cmd->pending = 1;
goto out;
}
-
+
/* Get the current mode */
chu = silc_client_on_channel(channel, client_entry);
if (chu)
/* Send the command packet. We support sending only one mode at once
that requires an argument. */
- buffer = silc_command_payload_encode_va(SILC_COMMAND_CUMODE, 0,
- auth ? 4 : 3,
- 1, chidp->data, chidp->len,
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_CUMODE, 0,
+ auth ? 4 : 3,
+ 1, chidp->data, chidp->len,
2, modebuf, 4,
3, clidp->data, clidp->len,
- 4, auth ? auth->data : NULL,
+ 4, auth ? auth->data : NULL,
auth ? auth->len : 0);
-
- silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
+
+ silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
0, NULL, NULL, buffer->data, buffer->len, TRUE);
silc_buffer_free(buffer);
silc_buffer_free(chidp);
silc_buffer_free(clidp);
if (auth)
silc_buffer_free(auth);
-
+
/* Notify application */
COMMAND(SILC_STATUS_OK);
}
if (cmd->argc < 3) {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /KICK <channel> <nickname> [<comment>]");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
nickname = strdup(cmd->argv[2]);
/* Get the target client */
- target = silc_idlist_get_client(cmd->client, conn, nickname,
+ target = silc_idlist_get_client(cmd->client, conn, nickname,
cmd->argv[2], FALSE);
if (!target) {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
"No such client: %s", cmd->argv[2]);
COMMAND_ERROR(SILC_STATUS_ERR_NO_SUCH_NICK);
goto out;
idp = silc_id_payload_encode(id_cache->id, SILC_ID_CHANNEL);
idp2 = silc_id_payload_encode(target->id, SILC_ID_CLIENT);
if (cmd->argc == 3)
- buffer = silc_command_payload_encode_va(SILC_COMMAND_KICK, 0, 2,
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_KICK, 0, 2,
1, idp->data, idp->len,
2, idp2->data, idp2->len);
else
- buffer = silc_command_payload_encode_va(SILC_COMMAND_KICK, 0, 3,
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_KICK, 0, 3,
1, idp->data, idp->len,
2, idp2->data, idp2->len,
- 3, cmd->argv[3],
+ 3, cmd->argv[3],
strlen(cmd->argv[3]));
silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
0, NULL, NULL, buffer->data, buffer->len, TRUE);
data, data_len);
}
- buffer = silc_command_payload_encode_va(SILC_COMMAND_OPER, 0, 2,
- 1, cmd->argv[1],
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_OPER, 0, 2,
+ 1, cmd->argv[1],
strlen(cmd->argv[1]),
2, auth ? auth->data : NULL,
auth ? auth->len : 0);
}
if (cmd->argc < 2) {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /OPER <username> [-pubkey]");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
}
static void silc_client_command_silcoper_send(unsigned char *data,
- SilcUInt32 data_len,
+ SilcUInt32 data_len,
void *context)
{
SilcClientCommandContext cmd = (SilcClientCommandContext)context;
data, data_len);
}
- buffer = silc_command_payload_encode_va(SILC_COMMAND_SILCOPER, 0, 2,
- 1, cmd->argv[1],
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_SILCOPER, 0, 2,
+ 1, cmd->argv[1],
strlen(cmd->argv[1]),
2, auth ? auth->data : NULL,
auth ? auth->len : 0);
}
if (cmd->argc < 2) {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /SILCOPER <username> [-pubkey]");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
char *name, *ban = NULL;
unsigned char action[1];
SilcPublicKey pubkey = NULL;
-
+
if (!cmd->conn) {
SILC_NOT_CONNECTED(cmd->client, cmd->conn);
COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED);
}
if (cmd->argc < 2) {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /BAN <channel> "
"[+|-[<nickname>[@<server>[!<username>[@hostname>]]]]]");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
chidp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL);
/* Send the command */
- buffer = silc_command_payload_encode_va(SILC_COMMAND_BAN,
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_BAN,
++conn->cmd_ident, 3,
1, chidp->data, chidp->len,
2, args ? action : NULL,
args ? 1 : 0,
3, args ? args->data : NULL,
args ? args->len : 0);
- silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
+ silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
0, NULL, NULL, buffer->data, buffer->len, TRUE);
silc_buffer_free(buffer);
silc_buffer_free(chidp);
buffer = silc_command_payload_encode_va(SILC_COMMAND_DETACH,
++conn->cmd_ident, 0);
- silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
+ silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
0, NULL, NULL, buffer->data, buffer->len, TRUE);
silc_buffer_free(buffer);
goto out;
}
- buffer = silc_command_payload_encode_va(SILC_COMMAND_WATCH,
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_WATCH,
++conn->cmd_ident, 2,
1, idp->data, idp->len,
type, cmd->argv[2],
cmd->argv_lens[2]);
- silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
+ silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
0, NULL, NULL, buffer->data, buffer->len, TRUE);
silc_buffer_free(buffer);
SilcClientCommandContext cmd = (SilcClientCommandContext)context;
SilcClientConnection conn = cmd->conn;
SilcChannelEntry channel;
- SilcChannelUser chu;
SilcBuffer buffer, idp;
char *name;
}
if (cmd->argc != 2) {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /LEAVE <channel>");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
goto out;
}
- /* Remove us from channel */
- chu = silc_client_on_channel(channel, conn->local_entry);
- if (chu) {
- silc_hash_table_del(chu->client->channels, chu->channel);
- silc_hash_table_del(chu->channel->user_list, chu->client);
- silc_free(chu);
- }
-
/* Send LEAVE command to the server */
idp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL);
- buffer = silc_command_payload_encode_va(SILC_COMMAND_LEAVE, 0, 1,
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_LEAVE, 0, 1,
1, idp->data, idp->len);
- silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
+ silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
0, NULL, NULL, buffer->data, buffer->len, TRUE);
silc_buffer_free(buffer);
silc_buffer_free(idp);
if (conn->current_channel == channel)
conn->current_channel = NULL;
- silc_client_del_channel(cmd->client, cmd->conn, channel);
-
out:
silc_client_command_free(cmd);
}
}
if (cmd->argc != 2) {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /USERS <channel>");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
}
/* Send USERS command to the server */
- buffer = silc_command_payload_encode_va(SILC_COMMAND_USERS,
- ++conn->cmd_ident, 1,
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_USERS,
+ ++conn->cmd_ident, 1,
2, name, strlen(name));
- silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND,
- NULL, 0, NULL, NULL, buffer->data,
+ silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND,
+ NULL, 0, NULL, NULL, buffer->data,
buffer->len, TRUE);
silc_buffer_free(buffer);
}
if (cmd->argc < 2) {
- client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_INFO,
+ client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /GETKEY <nickname or server name>");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
if (!cmd->pending) {
/* This will send the IDENTIFY command for nickname */
silc_idlist_get_client(client, conn, nickname, cmd->argv[1], TRUE);
- silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY,
- conn->cmd_ident,
- silc_client_command_getkey,
+ silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY,
+ conn->cmd_ident,
+ silc_client_command_getkey,
silc_client_command_dup(cmd));
cmd->pending = 1;
goto out;
} else {
- SilcClientCommandReplyContext reply =
+ SilcClientCommandReplyContext reply =
(SilcClientCommandReplyContext)context2;
SilcStatus error;
silc_command_get_status(reply->payload, NULL, &error);
if (error == SILC_STATUS_ERR_NO_SUCH_NICK) {
/* This sends the IDENTIFY command to resolve the server. */
- silc_client_command_register(client, SILC_COMMAND_IDENTIFY,
+ silc_client_command_register(client, SILC_COMMAND_IDENTIFY,
NULL, NULL,
silc_client_command_reply_identify_i, 0,
++conn->cmd_ident);
silc_client_command_send(client, conn, SILC_COMMAND_IDENTIFY,
- conn->cmd_ident, 1,
+ conn->cmd_ident, 1,
2, cmd->argv[1], cmd->argv_lens[1]);
- silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY,
- conn->cmd_ident,
- silc_client_command_getkey,
+ silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY,
+ conn->cmd_ident,
+ silc_client_command_getkey,
silc_client_command_dup(cmd));
goto out;
}
/* If server was not found, then we've resolved both nickname and
server and did not find anybody. */
if (error == SILC_STATUS_ERR_NO_SUCH_SERVER) {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR, "%s",
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR, "%s",
silc_get_status_message(SILC_STATUS_ERR_NO_SUCH_NICK));
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR, "%s",
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR, "%s",
silc_get_status_message(error));
COMMAND_ERROR(SILC_STATUS_ERR_NO_SUCH_NICK);
goto out;
idp = silc_id_payload_encode(client_entry->id, SILC_ID_CLIENT);
}
- buffer = silc_command_payload_encode_va(SILC_COMMAND_GETKEY, 0, 1,
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_GETKEY, 0, 1,
1, idp->data, idp->len);
- silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
+ silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
0, NULL, NULL, buffer->data, buffer->len, TRUE);
silc_buffer_free(buffer);
silc_buffer_free(idp);
searched using the silc_client_command_find by that name. The
`command_function' is the function to be called when the command is
executed, and the `command_reply_function' is the function to be
- called after the server has sent reply back to the command.
+ called after the server has sent reply back to the command.
The `ident' is optional identifier for the command. If non-zero
the `command_reply_function' for the command type `command' will be
- called only if the command reply sent by server includes the
+ called only if the command reply sent by server includes the
command identifier `ident'. Application usually does not need it
and set it to zero value. */
}
if (cmd->argc < 2) {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /CONNECT <server> [<port>]");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
}
if (cmd->argc == 3)
- buffer = silc_command_payload_encode_va(SILC_COMMAND_PRIV_CONNECT, 0, 2,
- 1, cmd->argv[1],
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_PRIV_CONNECT, 0, 2,
+ 1, cmd->argv[1],
strlen(cmd->argv[1]),
2, port, 4);
else
buffer = silc_command_payload_encode_va(SILC_COMMAND_PRIV_CONNECT, 0, 1,
- 1, cmd->argv[1],
+ 1, cmd->argv[1],
strlen(cmd->argv[1]));
silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
0, NULL, NULL, buffer->data, buffer->len, TRUE);
/* CLOSE command. Close server connection to the remote server */
-
+
SILC_CLIENT_CMD_FUNC(close)
{
SilcClientCommandContext cmd = (SilcClientCommandContext)context;
}
if (cmd->argc < 2) {
- SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
+ SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO,
"Usage: /CLOSE <server> [<port>]");
COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
}
if (cmd->argc == 3)
- buffer = silc_command_payload_encode_va(SILC_COMMAND_PRIV_CLOSE, 0, 2,
- 1, cmd->argv[1],
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_PRIV_CLOSE, 0, 2,
+ 1, cmd->argv[1],
strlen(cmd->argv[1]),
2, port, 4);
else
buffer = silc_command_payload_encode_va(SILC_COMMAND_PRIV_CLOSE, 0, 1,
- 1, cmd->argv[1],
+ 1, cmd->argv[1],
strlen(cmd->argv[1]));
silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL,
0, NULL, NULL, buffer->data, buffer->len, TRUE);
out:
silc_client_command_free(cmd);
}
-
+
/* SHUTDOWN command. Shutdowns the server. */
SILC_CLIENT_CMD_FUNC(shutdown)
}
/* Send the command */
- silc_client_command_send(cmd->client, cmd->conn,
+ silc_client_command_send(cmd->client, cmd->conn,
SILC_COMMAND_PRIV_SHUTDOWN, 0, 0);
/* Notify application */
void silc_client_commands_register(SilcClient client)
{
- silc_list_init(client->internal->commands, struct SilcClientCommandStruct,
+ silc_list_init(client->internal->commands, struct SilcClientCommandStruct,
next);
SILC_CLIENT_CMD(whois, WHOIS, "WHOIS", 3);
/* Get arguments */
args = silc_command_get_args(payload);
-
+
/* Get the command */
command = silc_command_get(payload);
switch (command) {
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,
+ NULL, 0, NULL, NULL, packet->data,
packet->len, TRUE);
silc_buffer_free(packet);
silc_buffer_free(buffer);
projects / silc.git / blobdiff