X-Git-Url: http://git.silcnet.org/gitweb/?p=silc.git;a=blobdiff_plain;f=lib%2Fsilcclient%2Fcommand.c;h=3131900efdc680fb6379fb6dafc5765c79639bef;hp=3e6839fad2fb0fe9a206909c22d3c7e032acade2;hb=382d15d447b7a95390decfa783836ae4fe255b3d;hpb=6617b351fc8655b8772cae80117faf5b35cc0378 diff --git a/lib/silcclient/command.c b/lib/silcclient/command.c index 3e6839fa..3131900e 100644 --- a/lib/silcclient/command.c +++ b/lib/silcclient/command.c @@ -1,16 +1,15 @@ /* - command.c + command.c - Author: Pekka Riikonen + Author: Pekka Riikonen - Copyright (C) 1997 - 2001 Pekka Riikonen + Copyright (C) 1997 - 2002 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 - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. - + the Free Software Foundation; version 2 of the License. + This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the @@ -19,72 +18,38 @@ */ /* $Id$ */ -#include "clientlibincludes.h" +#include "silcincludes.h" +#include "silcclient.h" #include "client_internal.h" -/* Client command list. */ -SilcClientCommand silc_command_list[] = -{ - SILC_CLIENT_CMD(whois, WHOIS, "WHOIS", SILC_CF_LAG | SILC_CF_REG, 3), - SILC_CLIENT_CMD(whowas, WHOWAS, "WHOWAS", SILC_CF_LAG | SILC_CF_REG, 3), - SILC_CLIENT_CMD(identify, IDENTIFY, "IDENTIFY", - SILC_CF_LAG | SILC_CF_REG, 3), - SILC_CLIENT_CMD(nick, NICK, "NICK", SILC_CF_LAG | SILC_CF_REG, 2), - SILC_CLIENT_CMD(list, LIST, "LIST", SILC_CF_LAG | SILC_CF_REG, 2), - SILC_CLIENT_CMD(topic, TOPIC, "TOPIC", SILC_CF_LAG | SILC_CF_REG, 3), - SILC_CLIENT_CMD(invite, INVITE, "INVITE", SILC_CF_LAG | SILC_CF_REG, 3), - SILC_CLIENT_CMD(quit, QUIT, "QUIT", SILC_CF_LAG | SILC_CF_REG, 2), - SILC_CLIENT_CMD(kill, KILL, "KILL", - SILC_CF_LAG | SILC_CF_REG | SILC_CF_OPER, 3), - SILC_CLIENT_CMD(info, INFO, "INFO", SILC_CF_LAG | SILC_CF_REG, 2), - SILC_CLIENT_CMD(connect, CONNECT, "CONNECT", - SILC_CF_LAG | SILC_CF_REG | SILC_CF_OPER, 3), - SILC_CLIENT_CMD(ping, PING, "PING", SILC_CF_LAG | SILC_CF_REG, 2), - SILC_CLIENT_CMD(oper, OPER, "OPER", - SILC_CF_LAG | SILC_CF_REG | SILC_CF_OPER, 2), - SILC_CLIENT_CMD(join, JOIN, "JOIN", SILC_CF_LAG | SILC_CF_REG, 5), - SILC_CLIENT_CMD(motd, MOTD, "MOTD", SILC_CF_LAG | SILC_CF_REG, 2), - SILC_CLIENT_CMD(umode, UMODE, "UMODE", SILC_CF_LAG | SILC_CF_REG, 2), - SILC_CLIENT_CMD(cmode, CMODE, "CMODE", SILC_CF_LAG | SILC_CF_REG, 4), - SILC_CLIENT_CMD(cumode, CUMODE, "CUMODE", SILC_CF_LAG | SILC_CF_REG, 5), - SILC_CLIENT_CMD(kick, KICK, "KICK", SILC_CF_LAG | SILC_CF_REG, 4), - SILC_CLIENT_CMD(ban, BAN, "BAN", SILC_CF_LAG | SILC_CF_REG, 3), - SILC_CLIENT_CMD(close, CLOSE, "CLOSE", - SILC_CF_LAG | SILC_CF_REG | SILC_CF_OPER, 3), - SILC_CLIENT_CMD(shutdown, SHUTDOWN, "SHUTDOWN", - SILC_CF_LAG | SILC_CF_REG | SILC_CF_OPER, 1), - SILC_CLIENT_CMD(silcoper, SILCOPER, "SILCOPER", - SILC_CF_LAG | SILC_CF_REG | SILC_CF_SILC_OPER, 3), - SILC_CLIENT_CMD(leave, LEAVE, "LEAVE", SILC_CF_LAG | SILC_CF_REG, 2), - SILC_CLIENT_CMD(users, USERS, "USERS", SILC_CF_LAG | SILC_CF_REG, 2), - SILC_CLIENT_CMD(getkey, GETKEY, "GETKEY", SILC_CF_LAG | SILC_CF_REG, 2), - - { NULL, 0, NULL, 0, 0 }, -}; - #define SILC_NOT_CONNECTED(x, c) \ - x->ops->say((x), (c), SILC_CLIENT_MESSAGE_ERROR, \ + 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. - Usage: COMMAND; */ -#define COMMAND cmd->client->ops->command(cmd->client, cmd->conn, \ - cmd, TRUE, cmd->command->cmd) + Usage: COMMAND(status); */ +#define COMMAND(status) cmd->client->internal->ops->command(cmd->client, \ + cmd->conn, cmd, TRUE, cmd->command->cmd, (status)) -/* Error to application. Usage: COMMAND_ERROR; */ -#define COMMAND_ERROR cmd->client->ops->command(cmd->client, cmd->conn, \ - cmd, FALSE, cmd->command->cmd) +/* Error to application. Usage: COMMAND_ERROR(status); */ +#define COMMAND_ERROR(status) \ + cmd->client->internal->ops->command(cmd->client, \ + cmd->conn, cmd, FALSE, cmd->command->cmd, (status)) + +#define SAY cmd->client->internal->ops->say /* Generic function to send any command. The arguments must be sent already encoded into correct form and in correct order. */ -void silc_client_send_command(SilcClient client, SilcClientConnection conn, - SilcCommand command, uint16 ident, - uint32 argc, ...) +void silc_client_command_send(SilcClient client, SilcClientConnection conn, + SilcCommand command, SilcUInt16 ident, + SilcUInt32 argc, ...) { SilcBuffer packet; va_list ap; + assert(client && conn); + va_start(ap, argc); packet = silc_command_payload_encode_vap(command, ident, argc, ap); @@ -97,86 +62,184 @@ void silc_client_send_command(SilcClient client, SilcClientConnection conn, /* Finds and returns a pointer to the command list. Return NULL if the command is not found. */ -SilcClientCommand *silc_client_command_find(const char *name) +SilcClientCommand silc_client_command_find(SilcClient client, + const char *name) { - SilcClientCommand *cmd; + SilcClientCommand cmd; - for (cmd = silc_command_list; cmd->name; cmd++) { - if (!strcmp(cmd->name, name)) + assert(client); + + silc_list_start(client->internal->commands); + while ((cmd = silc_list_get(client->internal->commands)) != SILC_LIST_END) { + if (cmd->name && !strcasecmp(cmd->name, name)) return cmd; } return NULL; } +/* Executes a command */ + +bool silc_client_command_call(SilcClient client, + SilcClientConnection conn, + const char *command_line, ...) +{ + va_list va; + SilcUInt32 argc = 0; + unsigned char **argv = NULL; + SilcUInt32 *argv_lens = NULL, *argv_types = NULL; + SilcClientCommand cmd; + SilcClientCommandContext ctx; + char *arg; + + assert(client); + + /* Parse arguments */ + va_start(va, command_line); + if (command_line) { + char *command_name; + + /* Get command name */ + command_name = silc_memdup(command_line, strcspn(command_line, " ")); + if (!command_name) + return FALSE; + + /* Find command by name */ + cmd = silc_client_command_find(client, command_name); + if (!cmd) { + silc_free(command_name); + return FALSE; + } + + /* Parse command line */ + silc_parse_command_line((char *)command_line, &argv, &argv_lens, + &argv_types, &argc, cmd->max_args); + + silc_free(command_name); + } else { + arg = va_arg(va, char *); + if (!arg) + return FALSE; + + /* Find command by name */ + cmd = silc_client_command_find(client, arg); + if (!cmd) + return FALSE; + + while (arg) { + argv = silc_realloc(argv, sizeof(*argv) * (argc + 1)); + argv_lens = silc_realloc(argv_lens, sizeof(*argv_lens) * (argc + 1)); + argv_types = silc_realloc(argv_types, sizeof(*argv_types) * (argc + 1)); + argv[argc] = silc_memdup(arg, strlen(arg)); + argv_lens[argc] = strlen(arg); + argv_types[argc] = argc; + argc++; + arg = va_arg(va, char *); + } + } + + /* Allocate command context. */ + ctx = silc_client_command_alloc(); + ctx->client = client; + ctx->conn = conn; + ctx->command = cmd; + ctx->argc = argc; + ctx->argv = argv; + ctx->argv_lens = argv_lens; + ctx->argv_types = argv_types; + + /* Call the command */ + cmd->command(ctx, NULL); + + va_end(va); + + return TRUE; +} + /* Add new pending command to be executed when reply to a command has been - received. The `reply_cmd' is the command that will call the `callback' - with `context' when reply has been received. If `ident is non-zero - the `callback' will be executed when received reply with command - identifier `ident'. */ + received. The `reply_cmd' is the command that will call the `callback' + with `context' when reply has been received. It can be SILC_COMMAND_NONE + to match any command with the `ident'. If `ident' is non-zero + the `callback' will be executed when received reply with command + identifier `ident'. If there already exists pending command for the + specified command, ident, callback and context this function has no + effect. */ void silc_client_command_pending(SilcClientConnection conn, SilcCommand reply_cmd, - uint16 ident, - SilcClientPendingDestructor destructor, + SilcUInt16 ident, SilcCommandCb callback, void *context) { SilcClientCommandPending *reply; + assert(conn); reply = silc_calloc(1, sizeof(*reply)); reply->reply_cmd = reply_cmd; reply->ident = ident; reply->context = context; reply->callback = callback; - reply->destructor = destructor; - silc_dlist_add(conn->pending_commands, reply); + silc_dlist_add(conn->internal->pending_commands, reply); } /* Deletes pending command by reply command type. */ void silc_client_command_pending_del(SilcClientConnection conn, SilcCommand reply_cmd, - uint16 ident) + SilcUInt16 ident) { SilcClientCommandPending *r; - silc_dlist_start(conn->pending_commands); - while ((r = silc_dlist_get(conn->pending_commands)) != SILC_LIST_END) { - if (r->reply_cmd == reply_cmd && r->ident == ident) { - silc_dlist_del(conn->pending_commands, r); - break; + if (!conn->internal->pending_commands) + return; + + silc_dlist_start(conn->internal->pending_commands); + while ((r = silc_dlist_get(conn->internal->pending_commands)) + != SILC_LIST_END) { + if ((r->reply_cmd == reply_cmd || (r->reply_cmd == SILC_COMMAND_NONE && + r->reply_check)) + && r->ident == ident) { + silc_dlist_del(conn->internal->pending_commands, r); + silc_free(r); } } } /* Checks for pending commands and marks callbacks to be called from - the command reply function. Returns TRUE if there were pending command. */ - -int silc_client_command_pending_check(SilcClientConnection conn, - SilcClientCommandReplyContext ctx, - SilcCommand command, - uint16 ident) + the command reply function. */ + +SilcClientCommandPendingCallbacks +silc_client_command_pending_check(SilcClientConnection conn, + SilcClientCommandReplyContext ctx, + SilcCommand command, + SilcUInt16 ident, + SilcUInt32 *callbacks_count) { SilcClientCommandPending *r; - - silc_dlist_start(conn->pending_commands); - while ((r = silc_dlist_get(conn->pending_commands)) != SILC_LIST_END) { - if (r->reply_cmd == command && r->ident == ident) { - ctx->context = r->context; - ctx->callback = r->callback; - ctx->destructor = r->destructor; + SilcClientCommandPendingCallbacks callbacks = NULL; + int i = 0; + + silc_dlist_start(conn->internal->pending_commands); + while ((r = silc_dlist_get(conn->internal->pending_commands)) + != SILC_LIST_END) { + if ((r->reply_cmd == command || r->reply_cmd == SILC_COMMAND_NONE) + && r->ident == ident) { + callbacks = silc_realloc(callbacks, sizeof(*callbacks) * (i + 1)); + callbacks[i].context = r->context; + callbacks[i].callback = r->callback; + r->reply_check = TRUE; ctx->ident = ident; - return TRUE; + i++; } } - return FALSE; + *callbacks_count = i; + return callbacks; } /* Allocate Command Context */ -SilcClientCommandContext silc_client_command_alloc() +SilcClientCommandContext silc_client_command_alloc(void) { SilcClientCommandContext ctx = silc_calloc(1, sizeof(*ctx)); ctx->users++; @@ -195,6 +258,7 @@ void silc_client_command_free(SilcClientCommandContext ctx) for (i = 0; i < ctx->argc; i++) silc_free(ctx->argv[i]); + silc_free(ctx->argv); silc_free(ctx->argv_lens); silc_free(ctx->argv_types); silc_free(ctx); @@ -212,23 +276,6 @@ SilcClientCommandContext silc_client_command_dup(SilcClientCommandContext ctx) return ctx; } -/* Pending command destructor. */ - -static void silc_client_command_destructor(void *context) -{ - silc_client_command_free((SilcClientCommandContext)context); -} - -/* silc_client_get_client completion callback */ -void silc_client_command_completion(SilcClient client, - SilcClientConnection conn, - SilcClientEntry clients, - uint32 clients_count, - void *context) -{ - -} - /* Command WHOIS. This command is used to query information about specific user. */ @@ -236,38 +283,54 @@ SILC_CLIENT_CMD_FUNC(whois) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; SilcClientConnection conn = cmd->conn; - SilcBuffer buffer; + SilcBuffer buffer, attrs = NULL; + unsigned char count[4], *tmp = NULL; if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } /* 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_send_command(cmd->client, cmd->conn, SILC_COMMAND_WHOIS, + silc_client_command_send(cmd->client, cmd->conn, SILC_COMMAND_WHOIS, ++conn->cmd_ident, - 1, 3, buffer->data, buffer->len); + 1, 4, buffer->data, buffer->len); silc_buffer_free(buffer); goto out; } - buffer = silc_command_payload_encode(SILC_COMMAND_WHOIS, - cmd->argc - 1, ++cmd->argv, - ++cmd->argv_lens, ++cmd->argv_types, - 0); + if (cmd->argc == 2) { + buffer = silc_command_payload_encode_va(SILC_COMMAND_WHOIS, + ++conn->cmd_ident, 1, + 1, cmd->argv[1], + cmd->argv_lens[1]); + } else { + if (!strcasecmp(cmd->argv[2], "-details")) + attrs = silc_client_attributes_request(0); + + if (!attrs || cmd->argc > 3) { + int c = atoi(cmd->argc > 3 ? cmd->argv[3] : cmd->argv[2]); + SILC_PUT32_MSB(c, count); + tmp = count; + } + + buffer = silc_command_payload_encode_va(SILC_COMMAND_WHOIS, + ++conn->cmd_ident, 3, + 1, cmd->argv[1], cmd->argv_lens[1], + 2, tmp ? tmp : NULL, tmp ? 4 : 0, + 3, attrs ? attrs->data : NULL, + attrs ? attrs->len : 0); + } 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); - cmd->argv--; - cmd->argv_lens--; - cmd->argv_types--; /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); out: silc_client_command_free(cmd); @@ -281,75 +344,90 @@ SILC_CLIENT_CMD_FUNC(whowas) SilcClientCommandContext cmd = (SilcClientCommandContext)context; SilcClientConnection conn = cmd->conn; SilcBuffer buffer; + unsigned char count[4]; if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } if (cmd->argc < 2 || cmd->argc > 3) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /WHOWAS [@] []"); - COMMAND_ERROR; + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /WHOWAS [@] []"); + COMMAND_ERROR((cmd->argc < 2 ? SILC_STATUS_ERR_NOT_ENOUGH_PARAMS : + SILC_STATUS_ERR_TOO_MANY_PARAMS)); goto out; } - buffer = silc_command_payload_encode(SILC_COMMAND_WHOWAS, - cmd->argc - 1, ++cmd->argv, - ++cmd->argv_lens, ++cmd->argv_types, - 0); + if (cmd->argc == 2) { + buffer = silc_command_payload_encode_va(SILC_COMMAND_WHOWAS, + ++conn->cmd_ident, 1, + 1, cmd->argv[1], + cmd->argv_lens[1]); + } else { + int c = atoi(cmd->argv[2]); + memset(count, 0, sizeof(count)); + SILC_PUT32_MSB(c, count); + buffer = silc_command_payload_encode_va(SILC_COMMAND_WHOWAS, + ++conn->cmd_ident, 2, + 1, cmd->argv[1], cmd->argv_lens[1], + 2, count, sizeof(count)); + } 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); - cmd->argv--; - cmd->argv_lens--; - cmd->argv_types--; /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); out: silc_client_command_free(cmd); } /* Command IDENTIFY. This command is used to query information about - specific user, especially ID's. */ + specific user, especially ID's. + + NOTE: This command is used only internally by the client library + and application MUST NOT call this command directly. */ SILC_CLIENT_CMD_FUNC(identify) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; SilcClientConnection conn = cmd->conn; SilcBuffer buffer; + unsigned char count[4]; if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } - if (cmd->argc < 2 || cmd->argc > 3) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /IDENTIFY [@] []"); - COMMAND_ERROR; + if (cmd->argc < 2 || cmd->argc > 3) goto out; + + if (cmd->argc == 2) { + buffer = silc_command_payload_encode_va(SILC_COMMAND_IDENTIFY, + ++conn->cmd_ident, 1, + 1, cmd->argv[1], + cmd->argv_lens[1]); + } else { + 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, + ++conn->cmd_ident, 2, + 1, cmd->argv[1], + cmd->argv_lens[1], + 4, count, sizeof(count)); } - buffer = silc_command_payload_encode(SILC_COMMAND_IDENTIFY, - cmd->argc - 1, ++cmd->argv, - ++cmd->argv_lens, ++cmd->argv_types, - ++conn->cmd_ident); 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); - cmd->argv--; - cmd->argv_lens--; - cmd->argv_types--; - - /* Notify application */ - COMMAND; out: silc_client_command_free(cmd); @@ -366,13 +444,14 @@ SILC_CLIENT_CMD_FUNC(nick) if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } if (cmd->argc < 2) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "Usage: /NICK "); - COMMAND_ERROR; + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /NICK "); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; } @@ -382,37 +461,31 @@ SILC_CLIENT_CMD_FUNC(nick) /* Show current nickname */ if (cmd->argc < 2) { if (cmd->conn) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Your nickname is %s on server %s", - conn->nickname, conn->remote_host); + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Your nickname is %s on server %s", + conn->nickname, conn->remote_host); } else { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Your nickname is %s", conn->nickname); + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Your nickname is %s", conn->nickname); } - /* XXX Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); goto out; } - /* Set new nickname */ - buffer = silc_command_payload_encode(SILC_COMMAND_NICK, - cmd->argc - 1, ++cmd->argv, - ++cmd->argv_lens, ++cmd->argv_types, + if (cmd->argv_lens[1] > 128) + cmd->argv_lens[1] = 128; + + /* Send the NICK command */ + buffer = silc_command_payload_encode(SILC_COMMAND_NICK, 1, + &cmd->argv[1], + &cmd->argv_lens[1], + &cmd->argv_types[1], ++cmd->conn->cmd_ident); 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); - cmd->argv--; - cmd->argv_lens--; - cmd->argv_types--; - if (conn->nickname) - silc_free(conn->nickname); - conn->nickname = strdup(cmd->argv[1]); - - /* Notify application */ - COMMAND; out: silc_client_command_free(cmd); @@ -431,7 +504,7 @@ SILC_CLIENT_CMD_FUNC(list) if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } @@ -439,7 +512,8 @@ SILC_CLIENT_CMD_FUNC(list) name = cmd->argv[1]; /* Get the Channel ID of the channel */ - if (silc_idcache_find_by_name_one(conn->channel_cache, name, &id_cache)) { + if (silc_idcache_find_by_name_one(conn->internal->channel_cache, + name, &id_cache)) { channel = (SilcChannelEntry)id_cache->context; idp = silc_id_payload_encode(id_cache->id, SILC_ID_CHANNEL); } @@ -461,7 +535,7 @@ SILC_CLIENT_CMD_FUNC(list) silc_buffer_free(idp); /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); out: silc_client_command_free(cmd); @@ -480,21 +554,21 @@ SILC_CLIENT_CMD_FUNC(topic) if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } if (cmd->argc < 2 || cmd->argc > 3) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /TOPIC []"); - COMMAND_ERROR; + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /TOPIC []"); + COMMAND_ERROR((cmd->argc < 2 ? SILC_STATUS_ERR_NOT_ENOUGH_PARAMS : + SILC_STATUS_ERR_TOO_MANY_PARAMS)); goto out; } if (cmd->argv[1][0] == '*') { if (!conn->current_channel) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "You are not on any channel"); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } name = conn->current_channel->channel_name; @@ -503,15 +577,14 @@ SILC_CLIENT_CMD_FUNC(topic) } if (!conn->current_channel) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "You are not on that channel"); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } /* Get the Channel ID of the channel */ - if (!silc_idcache_find_by_name_one(conn->channel_cache, name, &id_cache)) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "You are not on that channel"); - COMMAND_ERROR; + if (!silc_idcache_find_by_name_one(conn->internal->channel_cache, + name, &id_cache)) { + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } @@ -535,7 +608,7 @@ SILC_CLIENT_CMD_FUNC(topic) silc_buffer_free(idp); /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); out: silc_client_command_free(cmd); @@ -551,29 +624,29 @@ SILC_CLIENT_CMD_FUNC(invite) SilcClientConnection conn = cmd->conn; SilcClientEntry client_entry = NULL; SilcChannelEntry channel; - SilcBuffer buffer, clidp, chidp; - uint32 num = 0, type = 0; - char *nickname = NULL, *server = NULL, *name; + SilcBuffer buffer, clidp, chidp, args = NULL; + SilcPublicKey pubkey = NULL; + char *nickname = NULL, *name; char *invite = NULL; + unsigned char action[1]; if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } if (cmd->argc < 2) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /INVITE [[@server>]" - "[+|-[[@[![@hostname>]]]]]"); - COMMAND_ERROR; + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /INVITE [[@server>]" + "[+|-[[@[![@hostname>]]]]]"); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; } if (cmd->argv[1][0] == '*') { if (!conn->current_channel) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "You are not on any channel"); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } @@ -583,8 +656,7 @@ SILC_CLIENT_CMD_FUNC(invite) channel = silc_client_get_channel(cmd->client, conn, name); if (!channel) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "You are on that channel"); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } } @@ -592,23 +664,17 @@ SILC_CLIENT_CMD_FUNC(invite) /* Parse the typed nickname. */ if (cmd->argc == 3) { if (cmd->argv[2][0] != '+' && cmd->argv[2][0] != '-') { - if (!silc_parse_nickname(cmd->argv[2], &nickname, &server, &num)) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "Bad nickname"); - COMMAND_ERROR; - goto out; - } - + if (client->internal->params->nickname_parse) + client->internal->params->nickname_parse(cmd->argv[2], &nickname); + else + nickname = strdup(cmd->argv[2]); + /* Find client entry */ client_entry = silc_idlist_get_client(client, conn, nickname, - server, num, TRUE); + cmd->argv[2], TRUE); if (!client_entry) { - if (nickname) - silc_free(nickname); - if (server) - silc_free(server); - if (cmd->pending) { - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NO_SUCH_NICK); goto out; } @@ -616,19 +682,41 @@ SILC_CLIENT_CMD_FUNC(invite) pending command. */ silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY, conn->cmd_ident, - silc_client_command_destructor, silc_client_command_invite, silc_client_command_dup(cmd)); cmd->pending = 1; - return; + goto out; } } else { - invite = cmd->argv[2]; - invite++; if (cmd->argv[2][0] == '+') - type = 3; + action[0] = 0x00; else - type = 4; + action[0] = 0x01; + + /* Check if it is public key file to be added to invite list */ + if (!silc_pkcs_load_public_key(cmd->argv[2] + 1, &pubkey, + SILC_PKCS_FILE_PEM)) + silc_pkcs_load_public_key(cmd->argv[2] + 1, &pubkey, + SILC_PKCS_FILE_BIN); + invite = cmd->argv[2]; + if (!pubkey) + invite++; + } + } + + if (invite) { + args = silc_buffer_alloc_size(2); + silc_buffer_format(args, + SILC_STR_UI_SHORT(1), + SILC_STR_END); + if (pubkey) { + chidp = silc_pkcs_public_key_payload_encode(pubkey); + args = silc_argument_payload_encode_one(args, chidp->data, + chidp->len, 2); + silc_buffer_free(chidp); + silc_pkcs_public_key_free(pubkey); + } else { + args = silc_argument_payload_encode_one(args, invite, strlen(invite), 1); } } @@ -637,33 +725,35 @@ SILC_CLIENT_CMD_FUNC(invite) if (client_entry) { clidp = silc_id_payload_encode(client_entry->id, SILC_ID_CLIENT); buffer = silc_command_payload_encode_va(SILC_COMMAND_INVITE, - ++conn->cmd_ident, 3, + ++conn->cmd_ident, 4, 1, chidp->data, chidp->len, 2, clidp->data, clidp->len, - type, invite, invite ? - strlen(invite) : 0); + 3, args ? action : NULL, + args ? 1 : 0, + 4, args ? args->data : NULL, + args ? args->len : 0); silc_buffer_free(clidp); } else { buffer = silc_command_payload_encode_va(SILC_COMMAND_INVITE, - ++conn->cmd_ident, 2, + ++conn->cmd_ident, 3, 1, chidp->data, chidp->len, - type, invite, invite ? - strlen(invite) : 0); + 3, args ? action : NULL, + args ? 1 : 0, + 4, args ? args->data : NULL, + args ? args->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(chidp); + silc_buffer_free(args), /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); out: - if (nickname) - silc_free(nickname); - if (server) - silc_free(server); + silc_free(nickname); silc_client_command_free(cmd); } @@ -677,8 +767,8 @@ SILC_TASK_CALLBACK(silc_client_command_quit_cb) QuitInternal q = (QuitInternal)context; /* Close connection */ - q->client->ops->disconnect(q->client, q->conn); - silc_client_close_connection(q->client, NULL, q->conn->sock->user_data); + q->client->internal->ops->disconnected(q->client, q->conn, 0, NULL); + silc_client_close_connection(q->client, q->conn->sock->user_data); silc_free(q); } @@ -693,7 +783,7 @@ SILC_CLIENT_CMD_FUNC(quit) if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } @@ -713,61 +803,107 @@ SILC_CLIENT_CMD_FUNC(quit) q->client = cmd->client; q->conn = cmd->conn; + /* Sleep for a while */ + sleep(2); + /* We quit the connection with little timeout */ - silc_task_register(cmd->client->timeout_queue, cmd->conn->sock->sock, - silc_client_command_quit_cb, (void *)q, - 1, 0, SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL); + silc_schedule_task_add(cmd->client->schedule, cmd->conn->sock->sock, + silc_client_command_quit_cb, (void *)q, + 1, 0, SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL); /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); out: silc_client_command_free(cmd); } +/* Timeout callback to remove the killed client from cache */ + +SILC_TASK_CALLBACK(silc_client_command_kill_remove_later) +{ + SilcClientCommandContext cmd = (SilcClientCommandContext)context; + SilcClient client = cmd->client; + 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); + else + nickname = strdup(cmd->argv[1]); + + /* Get the target client */ + 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_del_client(client, conn, target); + + silc_free(nickname); + silc_client_command_free(cmd); +} + +/* Kill command's pending command callback to actually remove the killed + client from our local cache. */ + +SILC_CLIENT_CMD_FUNC(kill_remove) +{ + SilcClientCommandContext cmd = (SilcClientCommandContext)context; + SilcClientCommandReplyContext reply = + (SilcClientCommandReplyContext)context2; + SilcStatus status; + + silc_command_get_status(reply->payload, &status, NULL); + if (status == SILC_STATUS_OK) { + /* Remove with timeout */ + silc_schedule_task_add(cmd->client->schedule, cmd->conn->sock->sock, + silc_client_command_kill_remove_later, context, + 1, 0, SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL); + return; + } + + silc_client_command_free(cmd); +} + /* Command KILL. Router operator can use this command to remove an client fromthe SILC Network. */ SILC_CLIENT_CMD_FUNC(kill) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; + SilcClient client = cmd->client; SilcClientConnection conn = cmd->conn; - SilcBuffer buffer, idp; + SilcBuffer buffer, idp, auth = NULL; SilcClientEntry target; - uint32 num = 0; - char *nickname = NULL, *server = NULL; + char *nickname = NULL, *comment = NULL; if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } if (cmd->argc < 2) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /KILL []"); - COMMAND_ERROR; + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /KILL [] [-pubkey]"); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; } /* Parse the typed nickname. */ - if (!silc_parse_nickname(cmd->argv[1], &nickname, &server, &num)) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Bad nickname"); - COMMAND_ERROR; - goto out; - } + if (client->internal->params->nickname_parse) + client->internal->params->nickname_parse(cmd->argv[1], &nickname); + else + nickname = strdup(cmd->argv[1]); /* Get the target client */ target = silc_idlist_get_client(cmd->client, conn, nickname, - server, num, TRUE); + cmd->argv[1], TRUE); if (!target) { - silc_free(nickname); - if (server) - silc_free(server); - if (cmd->pending) { - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NO_SUCH_NICK); goto out; } @@ -775,36 +911,53 @@ SILC_CLIENT_CMD_FUNC(kill) pending command. */ silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY, conn->cmd_ident, - silc_client_command_destructor, silc_client_command_kill, silc_client_command_dup(cmd)); cmd->pending = 1; - return; + goto out; + } + + if (cmd->argc >= 3) { + if (strcasecmp(cmd->argv[2], "-pubkey")) + comment = cmd->argv[2]; + + 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(cmd->client->public_key, + cmd->client->private_key, + cmd->client->rng, + client->sha1hash, + target->id, SILC_ID_CLIENT); + } } /* Send the KILL command to the server */ idp = silc_id_payload_encode(target->id, SILC_ID_CLIENT); - if (cmd->argc == 2) - buffer = silc_command_payload_encode_va(SILC_COMMAND_KILL, 0, 1, - 1, idp->data, idp->len); - else - buffer = silc_command_payload_encode_va(SILC_COMMAND_KILL, 0, 2, - 1, idp->data, idp->len, - 2, cmd->argv[2], - strlen(cmd->argv[2])); + buffer = + 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, + auth ? auth->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); + silc_buffer_free(auth); /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); + + /* Register a pending callback that will actually remove the killed + client from our cache. */ + silc_client_command_pending(conn, SILC_COMMAND_KILL, conn->cmd_ident, + silc_client_command_kill_remove, + silc_client_command_dup(cmd)); out: - if (nickname) - silc_free(nickname); - if (server) - silc_free(server); + silc_free(nickname); silc_client_command_free(cmd); } @@ -820,7 +973,7 @@ SILC_CLIENT_CMD_FUNC(info) if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } @@ -841,7 +994,39 @@ SILC_CLIENT_CMD_FUNC(info) silc_free(name); /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); + + out: + silc_client_command_free(cmd); +} + +/* Command STATS. Shows server and network statistics. */ + +SILC_CLIENT_CMD_FUNC(stats) +{ + SilcClientCommandContext cmd = (SilcClientCommandContext)context; + SilcClientConnection conn = cmd->conn; + SilcBuffer buffer, idp = NULL; + + if (!cmd->conn) { + SILC_NOT_CONNECTED(cmd->client, cmd->conn); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); + goto out; + } + + 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, + 0, NULL, NULL, buffer->data, buffer->len, TRUE); + silc_buffer_free(buffer); + silc_buffer_free(idp); + + /* Notify application */ + COMMAND(SILC_STATUS_OK); out: silc_client_command_free(cmd); @@ -854,127 +1039,146 @@ SILC_CLIENT_CMD_FUNC(ping) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; SilcClientConnection conn = cmd->conn; - SilcBuffer buffer; + SilcBuffer buffer, idp; void *id; int i; if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } + 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, - 1, conn->remote_id_data, - silc_id_get_len(conn->remote_id, - SILC_ID_SERVER)); + 1, idp->data, idp->len); 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); id = silc_id_str2id(conn->remote_id_data, conn->remote_id_data_len, SILC_ID_SERVER); if (!id) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } /* Start counting time */ - for (i = 0; i < conn->ping_count; i++) { - if (conn->ping[i].dest_id == NULL) { - conn->ping[i].start_time = time(NULL); - conn->ping[i].dest_id = id; - conn->ping[i].dest_name = strdup(conn->remote_host); - conn->ping_count++; + for (i = 0; i < conn->internal->ping_count; i++) { + if (conn->internal->ping[i].dest_id == NULL) { + conn->internal->ping[i].start_time = time(NULL); + conn->internal->ping[i].dest_id = id; + conn->internal->ping[i].dest_name = strdup(conn->remote_host); break; } } - if (i >= conn->ping_count) { - i = conn->ping_count; - conn->ping = silc_realloc(conn->ping, sizeof(*conn->ping) * (i + 1)); - conn->ping[i].start_time = time(NULL); - conn->ping[i].dest_id = id; - conn->ping[i].dest_name = strdup(conn->remote_host); - conn->ping_count++; + if (i >= conn->internal->ping_count) { + i = conn->internal->ping_count; + conn->internal->ping = + silc_realloc(conn->internal->ping, + sizeof(*conn->internal->ping) * (i + 1)); + conn->internal->ping[i].start_time = time(NULL); + conn->internal->ping[i].dest_id = id; + conn->internal->ping[i].dest_name = strdup(conn->remote_host); + conn->internal->ping_count++; } /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); out: silc_client_command_free(cmd); } -SILC_CLIENT_CMD_FUNC(notice) -{ -} - /* Command JOIN. Joins to a channel. */ SILC_CLIENT_CMD_FUNC(join) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; SilcClientConnection conn = cmd->conn; - SilcIDCacheEntry id_cache = NULL; - SilcBuffer buffer, idp; + SilcChannelEntry channel; + SilcBuffer buffer, idp, auth = NULL; + char *name, *passphrase = NULL, *pu8, *cipher = NULL, *hmac = NULL; + int i, passphrase_len = 0; if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } if (cmd->argc < 2) { - /* Show channels currently joined to */ - + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; } - + /* See if we have joined to the requested channel already */ - if (silc_idcache_find_by_name_one(conn->channel_cache, cmd->argv[1], - &id_cache)) { -#if 0 - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "You are talking to channel %s", cmd->argv[1]); - conn->current_channel = (SilcChannelEntry)id_cache->context; - cmd->client->screen->bottom_line->channel = cmd->argv[1]; - silc_screen_print_bottom_line(cmd->client->screen, 0); -#endif + channel = silc_client_get_channel(cmd->client, conn, cmd->argv[1]); + if (channel && silc_client_on_channel(channel, conn->local_entry)) goto out; - } idp = silc_id_payload_encode(conn->local_id, SILC_ID_CLIENT); - /* Send JOIN command to the server */ - if (cmd->argc == 2) - buffer = - silc_command_payload_encode_va(SILC_COMMAND_JOIN, 0, 2, - 1, cmd->argv[1], cmd->argv_lens[1], - 2, idp->data, idp->len); - else if (cmd->argc == 3) - /* XXX Buggy */ - buffer = - silc_command_payload_encode_va(SILC_COMMAND_JOIN, 0, 3, - 1, cmd->argv[1], cmd->argv_lens[1], - 2, idp->data, idp->len, - 3, cmd->argv[2], cmd->argv_lens[2]); - else - buffer = - silc_command_payload_encode_va(SILC_COMMAND_JOIN, 0, 4, - 1, cmd->argv[1], cmd->argv_lens[1], - 2, idp->data, idp->len, - 3, cmd->argv[2], cmd->argv_lens[2], - 4, cmd->argv[3], cmd->argv_lens[3]); + if (cmd->argv_lens[1] > 256) + cmd->argv_lens[1] = 256; + + name = cmd->argv[1]; + + for (i = 2; i < cmd->argc; i++) { + if (!strcasecmp(cmd->argv[i], "-cipher") && cmd->argc > i + 1) { + cipher = cmd->argv[i + 1]; + i++; + } else if (!strcasecmp(cmd->argv[i], "-hmac") && cmd->argc > i + 1) { + hmac = cmd->argv[i + 1]; + i++; + } 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->sha1hash, + conn->local_id, + SILC_ID_CLIENT); + 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], + cmd->argv_lens[i], 0); + pu8 = silc_calloc(passphrase_len, sizeof(*pu8)); + passphrase_len = silc_utf8_encode(cmd->argv[i], cmd->argv_lens[i], + 0, pu8, passphrase_len); + passphrase = pu8; + } else { + passphrase = strdup(cmd->argv[i]); + passphrase_len = cmd->argv_lens[i]; + } + } + } + /* Send JOIN command to the server */ + buffer = + silc_command_payload_encode_va(SILC_COMMAND_JOIN, 0, 6, + 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, 0, NULL, NULL, buffer->data, buffer->len, TRUE); silc_buffer_free(buffer); silc_buffer_free(idp); + if (auth) + silc_buffer_free(auth); + silc_free(passphrase); /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); out: silc_client_command_free(cmd); @@ -990,14 +1194,15 @@ SILC_CLIENT_CMD_FUNC(motd) if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } if (cmd->argc < 1 || cmd->argc > 2) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /MOTD []"); - COMMAND_ERROR; + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /MOTD []"); + COMMAND_ERROR((cmd->argc < 1 ? SILC_STATUS_ERR_NOT_ENOUGH_PARAMS : + SILC_STATUS_ERR_TOO_MANY_PARAMS)); goto out; } @@ -1015,7 +1220,7 @@ SILC_CLIENT_CMD_FUNC(motd) silc_buffer_free(buffer); /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); out: silc_client_command_free(cmd); @@ -1030,19 +1235,19 @@ SILC_CLIENT_CMD_FUNC(umode) SilcClientConnection conn = cmd->conn; SilcBuffer buffer, idp; unsigned char *cp, modebuf[4]; - uint32 mode, add, len; + SilcUInt32 mode, add, len; int i; if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } if (cmd->argc < 2) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /UMODE +|-"); - COMMAND_ERROR; + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /UMODE +|-"); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; } @@ -1064,6 +1269,14 @@ SILC_CLIENT_CMD_FUNC(umode) mode = 0; mode |= SILC_UMODE_SERVER_OPERATOR; mode |= SILC_UMODE_ROUTER_OPERATOR; + mode |= SILC_UMODE_GONE; + mode |= SILC_UMODE_INDISPOSED; + mode |= SILC_UMODE_BUSY; + mode |= SILC_UMODE_PAGE; + mode |= SILC_UMODE_HYPER; + mode |= SILC_UMODE_ROBOT; + mode |= SILC_UMODE_BLOCK_PRIVMSG; + mode |= SILC_UMODE_REJECT_WATCHING; } else { mode = SILC_UMODE_NONE; } @@ -1086,8 +1299,56 @@ SILC_CLIENT_CMD_FUNC(umode) else mode &= ~SILC_UMODE_GONE; break; + case 'i': + if (add) + mode |= SILC_UMODE_INDISPOSED; + else + mode &= ~SILC_UMODE_INDISPOSED; + break; + case 'b': + if (add) + mode |= SILC_UMODE_BUSY; + else + mode &= ~SILC_UMODE_BUSY; + break; + case 'p': + if (add) + mode |= SILC_UMODE_PAGE; + else + mode &= ~SILC_UMODE_PAGE; + break; + case 'h': + if (add) + mode |= SILC_UMODE_HYPER; + else + mode &= ~SILC_UMODE_HYPER; + break; + case 't': + if (add) + mode |= SILC_UMODE_ROBOT; + else + mode &= ~SILC_UMODE_ROBOT; + break; + case 'P': + if (add) + mode |= SILC_UMODE_BLOCK_PRIVMSG; + else + mode &= ~SILC_UMODE_BLOCK_PRIVMSG; + break; + case 'w': + if (add) + mode |= SILC_UMODE_REJECT_WATCHING; + else + mode &= ~SILC_UMODE_REJECT_WATCHING; + break; + case 'I': + if (add) + mode |= SILC_UMODE_BLOCK_INVITE; + else + mode &= ~SILC_UMODE_BLOCK_INVITE; + break; default: - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_UNKNOWN_MODE); goto out; break; } @@ -1108,7 +1369,7 @@ SILC_CLIENT_CMD_FUNC(umode) silc_buffer_free(idp); /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); out: silc_client_command_free(cmd); @@ -1123,28 +1384,27 @@ SILC_CLIENT_CMD_FUNC(cmode) SilcClientCommandContext cmd = (SilcClientCommandContext)context; SilcClientConnection conn = cmd->conn; SilcChannelEntry channel; - SilcBuffer buffer, chidp, auth = NULL; + SilcBuffer buffer, chidp, auth = NULL, pk = NULL; unsigned char *name, *cp, modebuf[4], tmp[4], *arg = NULL; - uint32 mode, add, type, len, arg_len = 0; + SilcUInt32 mode, add, type, len, arg_len = 0; int i; if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } if (cmd->argc < 3) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /CMODE +|- [{ }]"); - COMMAND_ERROR; + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /CMODE +|- [{ }]"); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; } if (cmd->argv[1][0] == '*') { if (!conn->current_channel) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "You are not on any channel"); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } @@ -1154,8 +1414,7 @@ SILC_CLIENT_CMD_FUNC(cmode) channel = silc_client_get_channel(cmd->client, conn, name); if (!channel) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "You are on that channel"); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } } @@ -1206,15 +1465,27 @@ SILC_CLIENT_CMD_FUNC(cmode) else mode &= ~SILC_CHANNEL_MODE_TOPIC; break; + case 'm': + if (add) + mode |= SILC_CHANNEL_MODE_SILENCE_USERS; + else + mode &= ~SILC_CHANNEL_MODE_SILENCE_USERS; + break; + case 'M': + if (add) + mode |= SILC_CHANNEL_MODE_SILENCE_OPERS; + else + mode &= ~SILC_CHANNEL_MODE_SILENCE_OPERS; + break; case 'l': if (add) { int ll; mode |= SILC_CHANNEL_MODE_ULIMIT; type = 3; if (cmd->argc < 4) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /CMODE +|- [{ }]"); - COMMAND_ERROR; + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /CMODE +|- [{ }]"); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; } ll = atoi(cmd->argv[3]); @@ -1230,9 +1501,9 @@ SILC_CLIENT_CMD_FUNC(cmode) mode |= SILC_CHANNEL_MODE_PASSPHRASE; type = 4; if (cmd->argc < 4) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /CMODE +|- [{ }]"); - COMMAND_ERROR; + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /CMODE +|- [{ }]"); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; } arg = cmd->argv[3]; @@ -1246,9 +1517,9 @@ SILC_CLIENT_CMD_FUNC(cmode) mode |= SILC_CHANNEL_MODE_CIPHER; type = 5; if (cmd->argc < 4) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /CMODE +|- [{ }]"); - COMMAND_ERROR; + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /CMODE +|- [{ }]"); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; } arg = cmd->argv[3]; @@ -1262,9 +1533,9 @@ SILC_CLIENT_CMD_FUNC(cmode) mode |= SILC_CHANNEL_MODE_HMAC; type = 6; if (cmd->argc < 4) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /CMODE +|- [{ }]"); - COMMAND_ERROR; + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /CMODE +|- [{ }]"); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; } arg = cmd->argv[3]; @@ -1275,27 +1546,31 @@ SILC_CLIENT_CMD_FUNC(cmode) break; case 'f': if (add) { + SilcPublicKey pubkey = cmd->client->public_key; + SilcPrivateKey privkey = cmd->client->private_key; + mode |= SILC_CHANNEL_MODE_FOUNDER_AUTH; type = 7; - if (cmd->argc < 4) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /CMODE +|- [{ }]"); - COMMAND_ERROR; - goto out; - } - - if (!strcasecmp(cmd->argv[3], "-pubkey")) { - auth = silc_auth_public_key_auth_generate(cmd->client->public_key, - cmd->client->private_key, - conn->hash, - conn->local_id, - SILC_ID_CLIENT); - } else { - auth = silc_auth_payload_encode(SILC_AUTH_PASSWORD, NULL, 0, - cmd->argv[3], cmd->argv_lens[3]); + 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, + 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; + } } + pk = silc_pkcs_public_key_payload_encode(pubkey); + auth = silc_auth_public_key_auth_generate(pubkey, privkey, + cmd->client->rng, + cmd->client->sha1hash, + conn->local_id, + SILC_ID_CLIENT); arg = auth->data; arg_len = auth->len; } else { @@ -1303,7 +1578,7 @@ SILC_CLIENT_CMD_FUNC(cmode) } break; default: - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_UNKNOWN_MODE); goto out; break; } @@ -1316,13 +1591,15 @@ SILC_CLIENT_CMD_FUNC(cmode) that requires an argument. */ if (type && arg) { buffer = - silc_command_payload_encode_va(SILC_COMMAND_CMODE, 0, 3, + silc_command_payload_encode_va(SILC_COMMAND_CMODE, 0, 4, 1, chidp->data, chidp->len, 2, modebuf, sizeof(modebuf), - type, arg, arg_len); + type, arg, arg_len, + 8, pk ? pk->data : NULL, + pk ? pk->len : 0); } else { buffer = - silc_command_payload_encode_va(SILC_COMMAND_CMODE, 0, 2, + silc_command_payload_encode_va(SILC_COMMAND_CMODE, 0, 2, 1, chidp->data, chidp->len, 2, modebuf, sizeof(modebuf)); } @@ -1331,11 +1608,11 @@ SILC_CLIENT_CMD_FUNC(cmode) 0, NULL, NULL, buffer->data, buffer->len, TRUE); silc_buffer_free(buffer); silc_buffer_free(chidp); - if (auth) - silc_buffer_free(auth); + silc_buffer_free(auth); + silc_buffer_free(pk); /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); out: silc_client_command_free(cmd); @@ -1346,34 +1623,33 @@ SILC_CLIENT_CMD_FUNC(cmode) SILC_CLIENT_CMD_FUNC(cumode) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; + SilcClient client = cmd->client; SilcClientConnection conn = cmd->conn; SilcChannelEntry channel; SilcChannelUser chu; SilcClientEntry client_entry; SilcBuffer buffer, clidp, chidp, auth = NULL; unsigned char *name, *cp, modebuf[4]; - uint32 mode = 0, add, len; - char *nickname = NULL, *server = NULL; - uint32 num = 0; + SilcUInt32 mode = 0, add, len; + char *nickname = NULL; int i; if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } if (cmd->argc < 4) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /CUMODE +|- [@]"); - COMMAND_ERROR; + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /CUMODE +|- [@]"); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; } if (cmd->argv[1][0] == '*') { if (!conn->current_channel) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "You are not on any channel"); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } @@ -1383,25 +1659,23 @@ SILC_CLIENT_CMD_FUNC(cumode) channel = silc_client_get_channel(cmd->client, conn, name); if (!channel) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "You are on that channel"); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } } /* Parse the typed nickname. */ - if (!silc_parse_nickname(cmd->argv[3], &nickname, &server, &num)) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "Bad nickname"); - COMMAND_ERROR; - goto out; - } + if (client->internal->params->nickname_parse) + client->internal->params->nickname_parse(cmd->argv[3], &nickname); + else + nickname = strdup(cmd->argv[3]); /* Find client entry */ - client_entry = silc_idlist_get_client(cmd->client, conn, - nickname, server, num, TRUE); + client_entry = silc_idlist_get_client(cmd->client, conn, nickname, + cmd->argv[3], TRUE); if (!client_entry) { if (cmd->pending) { - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NO_SUCH_NICK); goto out; } @@ -1409,20 +1683,16 @@ SILC_CLIENT_CMD_FUNC(cumode) pending command. */ silc_client_command_pending(conn, SILC_COMMAND_IDENTIFY, conn->cmd_ident, - silc_client_command_destructor, silc_client_command_cumode, silc_client_command_dup(cmd)); cmd->pending = 1; - return; + goto out; } /* Get the current mode */ - while ((chu = silc_list_get(channel->clients)) != SILC_LIST_END) { - if (chu->client == client_entry) { - mode = chu->mode; - break; - } - } + chu = silc_client_on_channel(channel, client_entry); + if (chu) + mode = chu->mode; /* Are we adding or removing mode */ if (cmd->argv[2][0] == '-') @@ -1439,24 +1709,36 @@ SILC_CLIENT_CMD_FUNC(cumode) if (add) { mode |= SILC_CHANNEL_UMODE_CHANFO; mode |= SILC_CHANNEL_UMODE_CHANOP; + mode |= SILC_CHANNEL_UMODE_BLOCK_MESSAGES; + mode |= SILC_CHANNEL_UMODE_BLOCK_MESSAGES_USERS; + mode |= SILC_CHANNEL_UMODE_BLOCK_MESSAGES_ROBOTS; } else { mode = SILC_CHANNEL_UMODE_NONE; } break; case 'f': if (add) { - if (cmd->argc == 5) { - if (!strcasecmp(cmd->argv[4], "-pubkey")) { - auth = silc_auth_public_key_auth_generate(cmd->client->public_key, - cmd->client->private_key, - conn->hash, - conn->local_id, - SILC_ID_CLIENT); - } else { - auth = silc_auth_payload_encode(SILC_AUTH_PASSWORD, NULL, 0, - cmd->argv[4], cmd->argv_lens[4]); + SilcPublicKey pubkey = cmd->client->public_key; + SilcPrivateKey privkey = cmd->client->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, + 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; } } + + auth = silc_auth_public_key_auth_generate(pubkey, privkey, + cmd->client->rng, + cmd->client->sha1hash, + conn->local_id, + SILC_ID_CLIENT); mode |= SILC_CHANNEL_UMODE_CHANFO; } else { mode &= ~SILC_CHANNEL_UMODE_CHANFO; @@ -1468,8 +1750,32 @@ SILC_CLIENT_CMD_FUNC(cumode) else mode &= ~SILC_CHANNEL_UMODE_CHANOP; break; + case 'b': + if (add) + mode |= SILC_CHANNEL_UMODE_BLOCK_MESSAGES; + else + mode &= ~SILC_CHANNEL_UMODE_BLOCK_MESSAGES; + break; + case 'u': + if (add) + mode |= SILC_CHANNEL_UMODE_BLOCK_MESSAGES_USERS; + else + mode &= ~SILC_CHANNEL_UMODE_BLOCK_MESSAGES_USERS; + break; + case 'r': + if (add) + mode |= SILC_CHANNEL_UMODE_BLOCK_MESSAGES_ROBOTS; + else + mode &= ~SILC_CHANNEL_UMODE_BLOCK_MESSAGES_ROBOTS; + break; + case 'q': + if (add) + mode |= SILC_CHANNEL_UMODE_QUIET; + else + mode &= ~SILC_CHANNEL_UMODE_QUIET; + break; default: - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_UNKNOWN_MODE); goto out; break; } @@ -1481,7 +1787,8 @@ SILC_CLIENT_CMD_FUNC(cumode) /* 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, 4, + 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, @@ -1497,13 +1804,10 @@ SILC_CLIENT_CMD_FUNC(cumode) silc_buffer_free(auth); /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); out: - if (nickname) - silc_free(nickname); - if (server) - silc_free(server); + silc_free(nickname); silc_client_command_free(cmd); } @@ -1512,32 +1816,31 @@ SILC_CLIENT_CMD_FUNC(cumode) SILC_CLIENT_CMD_FUNC(kick) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; + SilcClient client = cmd->client; SilcClientConnection conn = cmd->conn; SilcIDCacheEntry id_cache = NULL; SilcChannelEntry channel; SilcBuffer buffer, idp, idp2; SilcClientEntry target; char *name; - uint32 num = 0; - char *nickname = NULL, *server = NULL; + char *nickname = NULL; if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } if (cmd->argc < 3) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /KICK []"); - COMMAND_ERROR; + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /KICK []"); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; } if (cmd->argv[1][0] == '*') { if (!conn->current_channel) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "You are not on any channel"); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } name = conn->current_channel->channel_name; @@ -1546,34 +1849,32 @@ SILC_CLIENT_CMD_FUNC(kick) } if (!conn->current_channel) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "You are not on that channel"); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } /* Get the Channel ID of the channel */ - if (!silc_idcache_find_by_name_one(conn->channel_cache, name, &id_cache)) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "You are not on that channel"); - COMMAND_ERROR; + if (!silc_idcache_find_by_name_one(conn->internal->channel_cache, + name, &id_cache)) { + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } channel = (SilcChannelEntry)id_cache->context; /* Parse the typed nickname. */ - if (!silc_parse_nickname(cmd->argv[2], &nickname, &server, &num)) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "Bad nickname"); - COMMAND_ERROR; - goto out; - } + 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 */ target = silc_idlist_get_client(cmd->client, conn, nickname, - server, num, FALSE); + cmd->argv[2], FALSE); if (!target) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "No such client: %s", - cmd->argv[2]); - COMMAND_ERROR; + 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; } @@ -1597,28 +1898,30 @@ SILC_CLIENT_CMD_FUNC(kick) silc_buffer_free(idp2); /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); out: - if (nickname) - silc_free(nickname); - if (server) - silc_free(server); + silc_free(nickname); silc_client_command_free(cmd); } static void silc_client_command_oper_send(unsigned char *data, - uint32 data_len, void *context) + SilcUInt32 data_len, void *context) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; SilcClientConnection conn = cmd->conn; SilcBuffer buffer, auth; - if (cmd->argc == 3) { - /* Pulic key auth XXX TODO */ - auth = NULL; + if (cmd->argc >= 3) { + /* Encode the public key authentication payload */ + auth = silc_auth_public_key_auth_generate(cmd->client->public_key, + cmd->client->private_key, + cmd->client->rng, + conn->internal->hash, + conn->local_id, + SILC_ID_CLIENT); } else { - /* Encode the authentication payload */ + /* Encode the password authentication payload */ auth = silc_auth_payload_encode(SILC_AUTH_PASSWORD, NULL, 0, data, data_len); } @@ -1626,7 +1929,8 @@ static void silc_client_command_oper_send(unsigned char *data, buffer = silc_command_payload_encode_va(SILC_COMMAND_OPER, 0, 2, 1, cmd->argv[1], strlen(cmd->argv[1]), - 2, auth->data, auth->len); + 2, auth ? auth->data : NULL, + auth ? auth->len : 0); silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL, 0, NULL, NULL, buffer->data, buffer->len, TRUE); @@ -1634,7 +1938,7 @@ static void silc_client_command_oper_send(unsigned char *data, silc_buffer_free(auth); /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); } /* OPER command. Used to obtain server operator privileges. */ @@ -1643,59 +1947,52 @@ SILC_CLIENT_CMD_FUNC(oper) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; SilcClientConnection conn = cmd->conn; - unsigned char *auth_data; - uint32 auth_data_len = 0; if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } if (cmd->argc < 2) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /OPER []"); - COMMAND_ERROR; + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /OPER [-pubkey]"); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; } - if (cmd->argc == 3) { - /* XXX Get public key */ - auth_data = NULL; - COMMAND_ERROR; - goto out; - } else { + if (cmd->argc < 3) { /* Get passphrase */ - cmd->client->ops->ask_passphrase(cmd->client, conn, + cmd->client->internal->ops->ask_passphrase(cmd->client, conn, silc_client_command_oper_send, context); return; } - silc_client_command_oper_send(auth_data, auth_data_len, context); - - memset(auth_data, 0, auth_data_len); - silc_free(auth_data); - - /* Notify application */ - COMMAND; + silc_client_command_oper_send(NULL, 0, context); out: silc_client_command_free(cmd); } static void silc_client_command_silcoper_send(unsigned char *data, - uint32 data_len, void *context) + SilcUInt32 data_len, + void *context) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; SilcClientConnection conn = cmd->conn; SilcBuffer buffer, auth; - if (cmd->argc == 3) { - /* Pulic key auth XXX TODO */ - auth = NULL; + if (cmd->argc >= 3) { + /* Encode the public key authentication payload */ + auth = silc_auth_public_key_auth_generate(cmd->client->public_key, + cmd->client->private_key, + cmd->client->rng, + conn->internal->hash, + conn->local_id, + SILC_ID_CLIENT); } else { - /* Encode the authentication payload */ + /* Encode the password authentication payload */ auth = silc_auth_payload_encode(SILC_AUTH_PASSWORD, NULL, 0, data, data_len); } @@ -1703,7 +2000,8 @@ static void silc_client_command_silcoper_send(unsigned char *data, buffer = silc_command_payload_encode_va(SILC_COMMAND_SILCOPER, 0, 2, 1, cmd->argv[1], strlen(cmd->argv[1]), - 2, auth->data, auth->len); + 2, auth ? auth->data : NULL, + auth ? auth->len : 0); silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL, 0, NULL, NULL, buffer->data, buffer->len, TRUE); @@ -1711,7 +2009,7 @@ static void silc_client_command_silcoper_send(unsigned char *data, silc_buffer_free(auth); /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); } /* SILCOPER command. Used to obtain router operator privileges. */ @@ -1720,90 +2018,29 @@ SILC_CLIENT_CMD_FUNC(silcoper) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; SilcClientConnection conn = cmd->conn; - unsigned char *auth_data; - uint32 auth_data_len = 0; if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } if (cmd->argc < 2) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /SILCOPER []"); - COMMAND_ERROR; + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /SILCOPER [-pubkey]"); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; } - if (cmd->argc == 3) { - /* XXX Get public key */ - auth_data = NULL; - COMMAND_ERROR; - goto out; - } else { + if (cmd->argc < 3) { /* Get passphrase */ - cmd->client->ops->ask_passphrase(cmd->client, conn, + cmd->client->internal->ops->ask_passphrase(cmd->client, conn, silc_client_command_silcoper_send, context); return; } - silc_client_command_silcoper_send(auth_data, auth_data_len, context); - - memset(auth_data, 0, auth_data_len); - silc_free(auth_data); - - /* Notify application */ - COMMAND; - - out: - silc_client_command_free(cmd); -} - -/* CONNECT command. Connects the server to another server. */ - -SILC_CLIENT_CMD_FUNC(connect) -{ - SilcClientCommandContext cmd = (SilcClientCommandContext)context; - SilcClientConnection conn = cmd->conn; - SilcBuffer buffer; - unsigned char port[4]; - uint32 tmp; - - if (!cmd->conn) { - SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; - goto out; - } - - if (cmd->argc < 2) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /CONNECT []"); - COMMAND_ERROR; - goto out; - } - - if (cmd->argc == 3) { - tmp = atoi(cmd->argv[2]); - SILC_PUT32_MSB(tmp, port); - } - - if (cmd->argc == 3) - buffer = silc_command_payload_encode_va(SILC_COMMAND_CONNECT, 0, 2, - 1, cmd->argv[1], - strlen(cmd->argv[1]), - 2, port, 4); - else - buffer = silc_command_payload_encode_va(SILC_COMMAND_CONNECT, 0, 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); - silc_buffer_free(buffer); - - /* Notify application */ - COMMAND; + silc_client_command_silcoper_send(NULL, 0, context); out: silc_client_command_free(cmd); @@ -1816,28 +2053,28 @@ SILC_CLIENT_CMD_FUNC(ban) SilcClientCommandContext cmd = (SilcClientCommandContext)context; SilcClientConnection conn = cmd->conn; SilcChannelEntry channel; - SilcBuffer buffer, chidp; - int type = 0; + SilcBuffer buffer, chidp, args = NULL; char *name, *ban = NULL; - + unsigned char action[1]; + SilcPublicKey pubkey = NULL; + if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } if (cmd->argc < 2) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /BAN " - "[+|-[[@[![@hostname>]]]]]"); - COMMAND_ERROR; + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /BAN " + "[+|-[[@[![@hostname>]]]]]"); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; } if (cmd->argv[1][0] == '*') { if (!conn->current_channel) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "You are not on any channel"); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } @@ -1847,113 +2084,139 @@ SILC_CLIENT_CMD_FUNC(ban) channel = silc_client_get_channel(cmd->client, conn, name); if (!channel) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "You are on that channel"); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } } if (cmd->argc == 3) { if (cmd->argv[2][0] == '+') - type = 2; + action[0] = 0x00; else - type = 3; + action[0] = 0x01; + /* Check if it is public key file to be added to invite list */ + if (!silc_pkcs_load_public_key(cmd->argv[2] + 1, &pubkey, + SILC_PKCS_FILE_PEM)) + silc_pkcs_load_public_key(cmd->argv[2] + 1, &pubkey, + SILC_PKCS_FILE_BIN); ban = cmd->argv[2]; - ban++; + if (!pubkey) + ban++; + } + + if (ban) { + args = silc_buffer_alloc_size(2); + silc_buffer_format(args, + SILC_STR_UI_SHORT(1), + SILC_STR_END); + if (pubkey) { + chidp = silc_pkcs_public_key_payload_encode(pubkey); + args = silc_argument_payload_encode_one(args, chidp->data, + chidp->len, 2); + silc_buffer_free(chidp); + silc_pkcs_public_key_free(pubkey); + } else { + args = silc_argument_payload_encode_one(args, ban, strlen(ban), 1); + } } chidp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL); /* Send the command */ - if (ban) - buffer = silc_command_payload_encode_va(SILC_COMMAND_BAN, 0, 2, - 1, chidp->data, chidp->len, - type, ban, strlen(ban)); - else - buffer = silc_command_payload_encode_va(SILC_COMMAND_BAN, 0, 1, - 1, chidp->data, chidp->len); - + 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, 0, NULL, NULL, buffer->data, buffer->len, TRUE); silc_buffer_free(buffer); silc_buffer_free(chidp); + silc_buffer_free(args); /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); out: silc_client_command_free(cmd); } -/* CLOSE command. Close server connection to the remote server */ - -SILC_CLIENT_CMD_FUNC(close) +/* Command DETACH. This is used to detach from the server */ + +SILC_CLIENT_CMD_FUNC(detach) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; SilcClientConnection conn = cmd->conn; SilcBuffer buffer; - unsigned char port[4]; - uint32 tmp; if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; - goto out; - } - - if (cmd->argc < 2) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /CLOSE []"); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } - if (cmd->argc == 3) { - tmp = atoi(cmd->argv[2]); - SILC_PUT32_MSB(tmp, port); - } - - if (cmd->argc == 3) - buffer = silc_command_payload_encode_va(SILC_COMMAND_CLOSE, 0, 2, - 1, cmd->argv[1], - strlen(cmd->argv[1]), - 2, port, 4); - else - buffer = silc_command_payload_encode_va(SILC_COMMAND_CLOSE, 0, 1, - 1, cmd->argv[1], - strlen(cmd->argv[1])); - silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL, + 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, 0, NULL, NULL, buffer->data, buffer->len, TRUE); silc_buffer_free(buffer); /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); out: silc_client_command_free(cmd); } - -/* SHUTDOWN command. Shutdowns the server. */ -SILC_CLIENT_CMD_FUNC(shutdown) +/* Command WATCH. */ + +SILC_CLIENT_CMD_FUNC(watch) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; + SilcClientConnection conn = cmd->conn; + SilcBuffer buffer, idp = NULL; + int type = 0; if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } - /* Send the command */ - silc_client_send_command(cmd->client, cmd->conn, - SILC_COMMAND_SHUTDOWN, 0, 0); + if (cmd->argc < 3) { + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); + goto out; + } + + idp = silc_id_payload_encode(conn->local_id, SILC_ID_CLIENT); + + if (!strcasecmp(cmd->argv[1], "-add")) { + type = 2; + } else if (!strcasecmp(cmd->argv[1], "-del")) { + type = 3; + } else { + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); + goto out; + } + + 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, + 0, NULL, NULL, buffer->data, buffer->len, TRUE); + silc_buffer_free(buffer); /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); out: + if (idp) + silc_buffer_free(idp); silc_client_command_free(cmd); } @@ -1963,27 +2226,27 @@ SILC_CLIENT_CMD_FUNC(leave) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; SilcClientConnection conn = cmd->conn; - SilcIDCacheEntry id_cache = NULL; SilcChannelEntry channel; + SilcChannelUser chu; SilcBuffer buffer, idp; char *name; if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } if (cmd->argc != 2) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "Usage: /LEAVE "); - COMMAND_ERROR; + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /LEAVE "); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; } if (cmd->argv[1][0] == '*') { if (!conn->current_channel) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "You are not on any channel"); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } name = conn->current_channel->channel_name; @@ -1991,17 +2254,23 @@ SILC_CLIENT_CMD_FUNC(leave) name = cmd->argv[1]; } - /* Get the Channel ID of the channel */ - if (!silc_idcache_find_by_name_one(conn->channel_cache, name, &id_cache)) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "You are not on that channel"); - COMMAND_ERROR; + /* Get the channel entry */ + channel = silc_client_get_channel(cmd->client, conn, name); + if (!channel) { + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } - channel = (SilcChannelEntry)id_cache->context; + /* 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(id_cache->id, SILC_ID_CHANNEL); + idp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL); 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, @@ -2010,17 +2279,12 @@ SILC_CLIENT_CMD_FUNC(leave) silc_buffer_free(idp); /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); if (conn->current_channel == channel) conn->current_channel = NULL; - silc_idcache_del_by_id(conn->channel_cache, channel->id); - silc_free(channel->channel_name); - silc_free(channel->id); - silc_free(channel->key); - silc_cipher_free(channel->channel_key); - silc_free(channel); + silc_client_del_channel(cmd->client, cmd->conn, channel); out: silc_client_command_free(cmd); @@ -2033,27 +2297,25 @@ SILC_CLIENT_CMD_FUNC(users) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; SilcClientConnection conn = cmd->conn; - SilcIDCacheEntry id_cache = NULL; - SilcChannelEntry channel; - SilcBuffer buffer, idp; + SilcBuffer buffer; char *name; if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } if (cmd->argc != 2) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "Usage: /USERS "); - COMMAND_ERROR; + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /USERS "); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; } if (cmd->argv[1][0] == '*') { if (!conn->current_channel) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "You are not on any channel"); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } name = conn->current_channel->channel_name; @@ -2061,48 +2323,17 @@ SILC_CLIENT_CMD_FUNC(users) name = cmd->argv[1]; } - if (!conn->current_channel) { - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "You are not on that channel"); - COMMAND_ERROR; - goto out; - } - - /* Get the Channel ID of the channel */ - if (!silc_idcache_find_by_name_one(conn->channel_cache, name, &id_cache)) { - /* XXX should resolve the channel ID; LIST command */ - cmd->client->ops->say(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "You are not on that channel", name); - COMMAND_ERROR; - goto out; - } - - channel = (SilcChannelEntry)id_cache->context; - - if (!cmd->pending) { - /* Send USERS command to the server */ - idp = silc_id_payload_encode(id_cache->id, SILC_ID_CHANNEL); - buffer = silc_command_payload_encode_va(SILC_COMMAND_USERS, - ++conn->cmd_ident, 1, - 1, idp->data, idp->len); - 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); - - /* Register pending callback which will recall this command callback with - same context and reprocesses the command. When reprocessing we actually - display the information on the screen. */ - silc_client_command_pending(conn, SILC_COMMAND_USERS, conn->cmd_ident, - silc_client_command_destructor, - silc_client_command_users, - silc_client_command_dup(cmd)); - cmd->pending = TRUE; - return; - } + /* Send USERS command to the server */ + 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, + buffer->len, TRUE); + silc_buffer_free(buffer); /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); out: silc_client_command_free(cmd); @@ -2116,45 +2347,96 @@ SILC_CLIENT_CMD_FUNC(getkey) SilcClientConnection conn = cmd->conn; SilcClient client = cmd->client; SilcClientEntry client_entry = NULL; - uint32 num = 0; - char *nickname = NULL, *server = NULL; + SilcServerEntry server_entry = NULL; + char *nickname = NULL; SilcBuffer idp, buffer; + SILC_LOG_DEBUG(("Start")); + if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); - COMMAND_ERROR; + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); goto out; } if (cmd->argc < 2) { - client->ops->say(client, conn, SILC_CLIENT_MESSAGE_INFO, "Usage: /GETKEY "); - COMMAND_ERROR; + client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /GETKEY "); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; } /* Parse the typed nickname. */ - if (!silc_parse_nickname(cmd->argv[1], &nickname, &server, &num)) { - client->ops->say(client, conn, SILC_CLIENT_MESSAGE_INFO, "Bad nickname"); - COMMAND_ERROR; - goto out; - } + if (client->internal->params->nickname_parse) + client->internal->params->nickname_parse(cmd->argv[1], &nickname); + else + nickname = strdup(cmd->argv[1]); /* Find client entry */ - client_entry = silc_idlist_get_client(client, conn, nickname, server, num, - TRUE); + client_entry = silc_idlist_get_client(client, conn, nickname, cmd->argv[1], + FALSE); if (!client_entry) { - /* 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_destructor, - silc_client_command_getkey, - silc_client_command_dup(cmd)); - cmd->pending = 1; - return; + /* Check whether user requested server actually */ + server_entry = silc_client_get_server(client, conn, cmd->argv[1]); + + if (!server_entry) { + /* No. what ever user wants we don't have it, so resolve it. We + will first try to resolve the client, and if that fails then + we'll try to resolve the server. */ + + 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_dup(cmd)); + cmd->pending = 1; + goto out; + } else { + SilcClientCommandReplyContext reply = + (SilcClientCommandReplyContext)context2; + SilcStatus error; + + /* If nickname was not found, then resolve the server. */ + 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, + 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, + 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_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", + silc_get_status_message(SILC_STATUS_ERR_NO_SUCH_NICK)); + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR, "%s", + silc_get_status_message(error)); + COMMAND_ERROR(SILC_STATUS_ERR_NO_SUCH_NICK); + goto out; + } + + COMMAND_ERROR(error); + goto out; + } + } + + idp = silc_id_payload_encode(server_entry->server_id, SILC_ID_SERVER); + } else { + idp = silc_id_payload_encode(client_entry->id, SILC_ID_CLIENT); } - idp = silc_id_payload_encode(client_entry->id, SILC_ID_CLIENT); 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, @@ -2163,8 +2445,364 @@ SILC_CLIENT_CMD_FUNC(getkey) silc_buffer_free(idp); /* Notify application */ - COMMAND; + COMMAND(SILC_STATUS_OK); + + out: + silc_free(nickname); + silc_client_command_free(cmd); +} + +/* Register a new command indicated by the `command' to the SILC client. + The `name' is optional command name. If provided the command may be + 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. + + 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 + command identifier `ident'. Application usually does not need it + and set it to zero value. */ + +bool silc_client_command_register(SilcClient client, + SilcCommand command, + const char *name, + SilcCommandCb command_function, + SilcCommandCb command_reply_function, + SilcUInt8 max_args, + SilcUInt16 ident) +{ + SilcClientCommand cmd; + + cmd = silc_calloc(1, sizeof(*cmd)); + cmd->cmd = command; + cmd->command = command_function; + cmd->reply = command_reply_function; + cmd->name = name ? strdup(name) : NULL; + cmd->max_args = max_args; + cmd->ident = ident; + + silc_list_add(client->internal->commands, cmd); + + return TRUE; +} + +/* Unregister a command indicated by the `command' with command function + `command_function' and command reply function `command_reply_function'. + Returns TRUE if the command was found and unregistered. */ + +bool silc_client_command_unregister(SilcClient client, + SilcCommand command, + SilcCommandCb command_function, + SilcCommandCb command_reply_function, + SilcUInt16 ident) +{ + SilcClientCommand cmd; + + silc_list_start(client->internal->commands); + while ((cmd = silc_list_get(client->internal->commands)) != SILC_LIST_END) { + if (cmd->cmd == command && cmd->command == command_function && + cmd->reply == command_reply_function && cmd->ident == ident) { + silc_list_del(client->internal->commands, cmd); + silc_free(cmd->name); + silc_free(cmd); + return TRUE; + } + } + + return FALSE; +} + +/* Private range commands, specific to this implementation (and compatible + with SILC Server). */ + +/* CONNECT command. Connects the server to another server. */ + +SILC_CLIENT_CMD_FUNC(connect) +{ + SilcClientCommandContext cmd = (SilcClientCommandContext)context; + SilcClientConnection conn = cmd->conn; + SilcBuffer buffer; + unsigned char port[4]; + SilcUInt32 tmp; + + if (!cmd->conn) { + SILC_NOT_CONNECTED(cmd->client, cmd->conn); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); + goto out; + } + + if (cmd->argc < 2) { + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /CONNECT []"); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); + goto out; + } + + if (cmd->argc == 3) { + tmp = atoi(cmd->argv[2]); + SILC_PUT32_MSB(tmp, port); + } + + if (cmd->argc == 3) + 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], + strlen(cmd->argv[1])); + silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL, + 0, NULL, NULL, buffer->data, buffer->len, TRUE); + silc_buffer_free(buffer); + + /* Notify application */ + COMMAND(SILC_STATUS_OK); out: silc_client_command_free(cmd); } + + +/* CLOSE command. Close server connection to the remote server */ + +SILC_CLIENT_CMD_FUNC(close) +{ + SilcClientCommandContext cmd = (SilcClientCommandContext)context; + SilcClientConnection conn = cmd->conn; + SilcBuffer buffer; + unsigned char port[4]; + SilcUInt32 tmp; + + if (!cmd->conn) { + SILC_NOT_CONNECTED(cmd->client, cmd->conn); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); + goto out; + } + + if (cmd->argc < 2) { + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /CLOSE []"); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); + goto out; + } + + if (cmd->argc == 3) { + tmp = atoi(cmd->argv[2]); + SILC_PUT32_MSB(tmp, port); + } + + if (cmd->argc == 3) + 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], + strlen(cmd->argv[1])); + silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL, + 0, NULL, NULL, buffer->data, buffer->len, TRUE); + silc_buffer_free(buffer); + + /* Notify application */ + COMMAND(SILC_STATUS_OK); + + out: + silc_client_command_free(cmd); +} + +/* SHUTDOWN command. Shutdowns the server. */ + +SILC_CLIENT_CMD_FUNC(shutdown) +{ + SilcClientCommandContext cmd = (SilcClientCommandContext)context; + + if (!cmd->conn) { + SILC_NOT_CONNECTED(cmd->client, cmd->conn); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_REGISTERED); + goto out; + } + + /* Send the command */ + silc_client_command_send(cmd->client, cmd->conn, + SILC_COMMAND_PRIV_SHUTDOWN, 0, 0); + + /* Notify application */ + COMMAND(SILC_STATUS_OK); + + out: + silc_client_command_free(cmd); +} + +/* Register all default commands provided by the client library for the + application. */ + +void silc_client_commands_register(SilcClient client) +{ + silc_list_init(client->internal->commands, struct SilcClientCommandStruct, + next); + + SILC_CLIENT_CMD(whois, WHOIS, "WHOIS", 3); + SILC_CLIENT_CMD(whowas, WHOWAS, "WHOWAS", 3); + SILC_CLIENT_CMD(identify, IDENTIFY, "IDENTIFY", 3); + SILC_CLIENT_CMD(nick, NICK, "NICK", 2); + SILC_CLIENT_CMD(list, LIST, "LIST", 2); + SILC_CLIENT_CMD(topic, TOPIC, "TOPIC", 3); + SILC_CLIENT_CMD(invite, INVITE, "INVITE", 3); + SILC_CLIENT_CMD(quit, QUIT, "QUIT", 2); + SILC_CLIENT_CMD(kill, KILL, "KILL", 4); + SILC_CLIENT_CMD(info, INFO, "INFO", 2); + SILC_CLIENT_CMD(stats, STATS, "STATS", 0); + SILC_CLIENT_CMD(ping, PING, "PING", 2); + SILC_CLIENT_CMD(oper, OPER, "OPER", 3); + SILC_CLIENT_CMD(join, JOIN, "JOIN", 9); + SILC_CLIENT_CMD(motd, MOTD, "MOTD", 2); + SILC_CLIENT_CMD(umode, UMODE, "UMODE", 2); + SILC_CLIENT_CMD(cmode, CMODE, "CMODE", 6); + SILC_CLIENT_CMD(cumode, CUMODE, "CUMODE", 9); + SILC_CLIENT_CMD(kick, KICK, "KICK", 4); + SILC_CLIENT_CMD(ban, BAN, "BAN", 3); + SILC_CLIENT_CMD(detach, DETACH, "DETACH", 0); + SILC_CLIENT_CMD(watch, WATCH, "WATCH", 3); + SILC_CLIENT_CMD(silcoper, SILCOPER, "SILCOPER", 3); + SILC_CLIENT_CMD(leave, LEAVE, "LEAVE", 2); + SILC_CLIENT_CMD(users, USERS, "USERS", 2); + SILC_CLIENT_CMD(getkey, GETKEY, "GETKEY", 2); + + SILC_CLIENT_CMD(connect, PRIV_CONNECT, "CONNECT", 3); + SILC_CLIENT_CMD(close, PRIV_CLOSE, "CLOSE", 3); + SILC_CLIENT_CMD(shutdown, PRIV_SHUTDOWN, "SHUTDOWN", 1); +} + +/* Unregister all commands. */ + +void silc_client_commands_unregister(SilcClient client) +{ + SILC_CLIENT_CMDU(whois, WHOIS, "WHOIS"); + SILC_CLIENT_CMDU(whowas, WHOWAS, "WHOWAS"); + SILC_CLIENT_CMDU(identify, IDENTIFY, "IDENTIFY"); + SILC_CLIENT_CMDU(nick, NICK, "NICK"); + SILC_CLIENT_CMDU(list, LIST, "LIST"); + SILC_CLIENT_CMDU(topic, TOPIC, "TOPIC"); + SILC_CLIENT_CMDU(invite, INVITE, "INVITE"); + SILC_CLIENT_CMDU(quit, QUIT, "QUIT"); + SILC_CLIENT_CMDU(kill, KILL, "KILL"); + SILC_CLIENT_CMDU(info, INFO, "INFO"); + SILC_CLIENT_CMDU(stats, STATS, "STATS"); + SILC_CLIENT_CMDU(ping, PING, "PING"); + SILC_CLIENT_CMDU(oper, OPER, "OPER"); + SILC_CLIENT_CMDU(join, JOIN, "JOIN"); + SILC_CLIENT_CMDU(motd, MOTD, "MOTD"); + SILC_CLIENT_CMDU(umode, UMODE, "UMODE"); + SILC_CLIENT_CMDU(cmode, CMODE, "CMODE"); + SILC_CLIENT_CMDU(cumode, CUMODE, "CUMODE"); + SILC_CLIENT_CMDU(kick, KICK, "KICK"); + SILC_CLIENT_CMDU(ban, BAN, "BAN"); + SILC_CLIENT_CMDU(detach, DETACH, "DETACH"); + SILC_CLIENT_CMDU(watch, WATCH, "WATCH"); + SILC_CLIENT_CMDU(silcoper, SILCOPER, "SILCOPER"); + SILC_CLIENT_CMDU(leave, LEAVE, "LEAVE"); + SILC_CLIENT_CMDU(users, USERS, "USERS"); + SILC_CLIENT_CMDU(getkey, GETKEY, "GETKEY"); + + SILC_CLIENT_CMDU(connect, PRIV_CONNECT, "CONNECT"); + SILC_CLIENT_CMDU(close, PRIV_CLOSE, "CLOSE"); + SILC_CLIENT_CMDU(shutdown, PRIV_SHUTDOWN, "SHUTDOWN"); +} + +/**** Client side incoming command handling **********************************/ + +void silc_client_command_process_whois(SilcClient client, + SilcSocketConnection sock, + SilcCommandPayload payload, + SilcArgumentPayload args); + +/* Client is able to receive some command packets even though they are + special case. Server may send WHOIS command to the client to retrieve + Requested Attributes information for WHOIS query the server is + processing. This function currently handles only the WHOIS command, + but if in the future for commands may arrive then this can be made + to support other commands too. */ + +void silc_client_command_process(SilcClient client, + SilcSocketConnection sock, + SilcPacketContext *packet) +{ + SilcCommandPayload payload; + SilcCommand command; + SilcArgumentPayload args; + + /* Get command payload from packet */ + payload = silc_command_payload_parse(packet->buffer->data, + packet->buffer->len); + if (!payload) { + /* Silently ignore bad reply packet */ + SILC_LOG_DEBUG(("Bad command packet")); + return; + } + + /* Get arguments */ + args = silc_command_get_args(payload); + + /* Get the command */ + command = silc_command_get(payload); + switch (command) { + + case SILC_COMMAND_WHOIS: + /* Ignore everything if requested by application */ + if (client->internal->params->ignore_requested_attributes) + break; + + silc_client_command_process_whois(client, sock, payload, args); + break; + + default: + break; + } + + silc_command_payload_free(payload); +} + +void silc_client_command_process_whois(SilcClient client, + SilcSocketConnection sock, + SilcCommandPayload payload, + SilcArgumentPayload args) +{ + SilcDList attrs; + unsigned char *tmp; + SilcUInt32 tmp_len; + SilcBuffer buffer, packet; + + SILC_LOG_DEBUG(("Received WHOIS command")); + + /* Try to take the Requested Attributes */ + tmp = silc_argument_get_arg_type(args, 3, &tmp_len); + if (!tmp) + return; + + attrs = silc_attribute_payload_parse(tmp, tmp_len); + if (!attrs) + return; + + /* Process requested attributes */ + buffer = silc_client_attributes_process(client, sock, attrs); + if (!buffer) { + silc_attribute_payload_list_free(attrs); + return; + } + + /* 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); +}