X-Git-Url: http://git.silcnet.org/gitweb/?a=blobdiff_plain;f=lib%2Fsilcclient%2Fcommand.c;h=935e5fd03c6186c5c2209ac40effb67ecb90c6f9;hb=40f8443d8d3a6577336ee66d18e04d9ac4d956bb;hp=9373396e1ee91cc8fd04a0ca12d5cf045d959772;hpb=8763262ca87be2c00479b25c27dfa505fc4f349c;p=silc.git diff --git a/lib/silcclient/command.c b/lib/silcclient/command.c index 9373396e..935e5fd0 100644 --- a/lib/silcclient/command.c +++ b/lib/silcclient/command.c @@ -1,10 +1,10 @@ /* - command.c + command.c Author: Pekka Riikonen - Copyright (C) 1997 - 2002 Pekka Riikonen + Copyright (C) 1997 - 2005 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 @@ -18,15 +18,15 @@ */ /* $Id$ */ -#include "silcincludes.h" +#include "silc.h" #include "silcclient.h" #include "client_internal.h" #define SILC_NOT_CONNECTED(x, c) \ x->internal->ops->say((x), (c), SILC_CLIENT_MESSAGE_ERROR, \ - "You are not connected to a server, use /SERVER to connect"); + "You are not connected to a server, please connect to server"); -/* 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)) @@ -48,11 +48,13 @@ void silc_client_command_send(SilcClient client, SilcClientConnection conn, SilcBuffer packet; va_list ap; + assert(client && conn); + 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); } @@ -65,25 +67,93 @@ SilcClientCommand silc_client_command_find(SilcClient client, { SilcClientCommand cmd; + assert(client); + silc_list_start(client->internal->commands); while ((cmd = silc_list_get(client->internal->commands)) != SILC_LIST_END) { - if (cmd->name && !strcmp(cmd->name, name)) + if (cmd->name && !strcasecmp(cmd->name, name)) return cmd; } return NULL; } -/* Calls the command (executes it). Application can call this after - it has allocated the SilcClientCommandContext with the function - silc_client_command_alloc and found the command from the client - library by calling silc_client_command_find. This will execute - the command. */ +/* Executes a command */ -void silc_client_command_call(SilcClientCommand command, - SilcClientCommandContext cmd) +SilcBool silc_client_command_call(SilcClient client, + SilcClientConnection conn, + const char *command_line, ...) { - (*command->command)((void *)cmd, NULL); + 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 @@ -103,22 +173,13 @@ void silc_client_command_pending(SilcClientConnection conn, { SilcClientCommandPending *reply; - /* Check whether identical pending already exists for same command, - ident, callback and callback context. If it does then it would be - error to register it again. */ - silc_dlist_start(conn->pending_commands); - while ((reply = silc_dlist_get(conn->pending_commands)) != SILC_LIST_END) { - if (reply->reply_cmd == reply_cmd && reply->ident == ident && - reply->callback == callback && reply->context == context) - return; - } - + assert(conn); reply = silc_calloc(1, sizeof(*reply)); reply->reply_cmd = reply_cmd; reply->ident = ident; reply->context = context; reply->callback = callback; - silc_dlist_add(conn->pending_commands, reply); + silc_dlist_add(conn->internal->pending_commands, reply); } /* Deletes pending command by reply command type. */ @@ -129,14 +190,17 @@ void silc_client_command_pending_del(SilcClientConnection conn, { SilcClientCommandPending *r; - if (!conn->pending_commands) + if (!conn->internal->pending_commands) return; - 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; + 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); } } } @@ -147,7 +211,7 @@ void silc_client_command_pending_del(SilcClientConnection conn, SilcClientCommandPendingCallbacks silc_client_command_pending_check(SilcClientConnection conn, SilcClientCommandReplyContext ctx, - SilcCommand command, + SilcCommand command, SilcUInt16 ident, SilcUInt32 *callbacks_count) { @@ -155,13 +219,15 @@ silc_client_command_pending_check(SilcClientConnection conn, SilcClientCommandPendingCallbacks callbacks = NULL; int i = 0; - silc_dlist_start(conn->pending_commands); - while ((r = silc_dlist_get(conn->pending_commands)) != SILC_LIST_END) { + 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; i++; } @@ -192,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); @@ -209,15 +276,18 @@ SilcClientCommandContext silc_client_command_dup(SilcClientCommandContext ctx) 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) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; SilcClientConnection conn = cmd->conn; - SilcBuffer buffer; - unsigned char count[4]; + SilcBuffer buffer, attrs = NULL; + unsigned char count[4], *tmp = NULL; + int i; + SilcBool details = FALSE, nick = FALSE; + unsigned char *pubkey = NULL; if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); @@ -228,27 +298,82 @@ 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); goto out; } - 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 { - int c = atoi(cmd->argv[2]); - memset(count, 0, sizeof(count)); - SILC_PUT32_MSB(c, count); - buffer = silc_command_payload_encode_va(SILC_COMMAND_WHOIS, - ++conn->cmd_ident, 2, - 1, cmd->argv[1], cmd->argv_lens[1], - 2, count, sizeof(count)); + for (i = 1; i < cmd->argc; i++) { + if (!strcasecmp(cmd->argv[i], "-details")) { + details = TRUE; + } else if (!strcasecmp(cmd->argv[i], "-pubkey") && cmd->argc > i + 1) { + pubkey = cmd->argv[i + 1]; + i++; + } else { + /* We assume that the first parameter is the nickname, if it isn't + -details or -pubkey. The last parameter should always be the count */ + if (i == 1) { + nick = TRUE; + } else if (i == cmd->argc - 1) { + int c = atoi(cmd->argv[i]); + SILC_PUT32_MSB(c, count); + tmp = count; + } + } + } + + if (details) { + /* if pubkey is set, add all attributes to the + attrs buffer, except public key */ + if (pubkey) { + attrs = silc_client_attributes_request(SILC_ATTRIBUTE_USER_INFO, + SILC_ATTRIBUTE_SERVICE, + SILC_ATTRIBUTE_STATUS_MOOD, + SILC_ATTRIBUTE_STATUS_FREETEXT, + SILC_ATTRIBUTE_STATUS_MESSAGE, + SILC_ATTRIBUTE_PREFERRED_LANGUAGE, + SILC_ATTRIBUTE_PREFERRED_CONTACT, + SILC_ATTRIBUTE_TIMEZONE, + SILC_ATTRIBUTE_GEOLOCATION, + SILC_ATTRIBUTE_DEVICE_INFO, 0); + } else { + attrs = silc_client_attributes_request(0); + } + } + + if (pubkey) { + SilcAttributeObjPk obj; + SilcPublicKey pk; + + if (!silc_pkcs_load_public_key(pubkey, &pk, SILC_PKCS_FILE_PEM)) { + if (!silc_pkcs_load_public_key(pubkey, &pk, SILC_PKCS_FILE_BIN)) { + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR, + "Could not load public key %s, check the filename", + pubkey); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); + goto out; + } + } + + obj.type = "silc-rsa"; + obj.data = silc_pkcs_public_key_encode(pk, &obj.data_len); + + attrs = silc_attribute_payload_encode(attrs, + SILC_ATTRIBUTE_USER_PUBLIC_KEY, + SILC_ATTRIBUTE_FLAG_VALID, + &obj, sizeof(obj)); } + + buffer = silc_command_payload_encode_va(SILC_COMMAND_WHOIS, + ++conn->cmd_ident, 3, + 1, nick ? cmd->argv[1] : NULL, + nick ? cmd->argv_lens[1] : 0, + 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); @@ -278,7 +403,7 @@ SILC_CLIENT_CMD_FUNC(whowas) } 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 [@] []"); COMMAND_ERROR((cmd->argc < 2 ? SILC_STATUS_ERR_NOT_ENOUGH_PARAMS : SILC_STATUS_ERR_TOO_MANY_PARAMS)); @@ -288,7 +413,7 @@ SILC_CLIENT_CMD_FUNC(whowas) 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]); @@ -311,8 +436,8 @@ SILC_CLIENT_CMD_FUNC(whowas) 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. */ @@ -334,7 +459,7 @@ SILC_CLIENT_CMD_FUNC(identify) 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]); @@ -342,7 +467,7 @@ SILC_CLIENT_CMD_FUNC(identify) 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], @@ -374,23 +499,23 @@ SILC_CLIENT_CMD_FUNC(nick) } if (cmd->argc < 2) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "Usage: /NICK "); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; } - if (!strcmp(conn->nickname, cmd->argv[1])) + if (silc_utf8_strcasecmp(conn->nickname, cmd->argv[1])) 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); } @@ -404,7 +529,7 @@ SILC_CLIENT_CMD_FUNC(nick) /* 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, @@ -422,10 +547,8 @@ SILC_CLIENT_CMD_FUNC(list) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; SilcClientConnection conn = cmd->conn; - SilcIDCacheEntry id_cache = NULL; SilcChannelEntry channel; SilcBuffer buffer, idp = NULL; - char *name; if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); @@ -434,20 +557,17 @@ SILC_CLIENT_CMD_FUNC(list) } if (cmd->argc == 2) { - name = cmd->argv[1]; - /* Get the Channel ID of the channel */ - if (silc_idcache_find_by_name_one(conn->channel_cache, name, &id_cache)) { - channel = (SilcChannelEntry)id_cache->context; - idp = silc_id_payload_encode(id_cache->id, SILC_ID_CHANNEL); - } + channel = silc_client_get_channel(cmd->client, cmd->conn, cmd->argv[1]); + if (channel) + idp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL); } 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); @@ -471,7 +591,6 @@ SILC_CLIENT_CMD_FUNC(topic) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; SilcClientConnection conn = cmd->conn; - SilcIDCacheEntry id_cache = NULL; SilcChannelEntry channel; SilcBuffer buffer, idp; char *name; @@ -492,8 +611,6 @@ SILC_CLIENT_CMD_FUNC(topic) if (cmd->argv[1][0] == '*') { if (!conn->current_channel) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "You are not on any channel"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } @@ -503,35 +620,30 @@ SILC_CLIENT_CMD_FUNC(topic) } if (!conn->current_channel) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "You are not on that channel"); 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)) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "You are not on that channel"); + 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; - /* Send TOPIC 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); 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); @@ -553,10 +665,11 @@ SILC_CLIENT_CMD_FUNC(invite) SilcClientConnection conn = cmd->conn; SilcClientEntry client_entry = NULL; SilcChannelEntry channel; - SilcBuffer buffer, clidp, chidp; - SilcUInt32 type = 0; + 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); @@ -574,8 +687,6 @@ SILC_CLIENT_CMD_FUNC(invite) if (cmd->argv[1][0] == '*') { if (!conn->current_channel) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "You are not on any channel"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } @@ -586,8 +697,6 @@ SILC_CLIENT_CMD_FUNC(invite) channel = silc_client_get_channel(cmd->client, conn, name); if (!channel) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "You are on that channel"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } @@ -602,30 +711,53 @@ SILC_CLIENT_CMD_FUNC(invite) 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; } } 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); } } @@ -633,25 +765,30 @@ SILC_CLIENT_CMD_FUNC(invite) 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, - ++conn->cmd_ident, 3, + buffer = silc_command_payload_encode_va(SILC_COMMAND_INVITE, + ++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, + buffer = silc_command_payload_encode_va(SILC_COMMAND_INVITE, + ++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, + 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(SILC_STATUS_OK); @@ -671,14 +808,14 @@ SILC_TASK_CALLBACK(silc_client_command_quit_cb) QuitInternal q = (QuitInternal)context; /* Close connection */ - q->client->internal->ops->disconnect(q->client, q->conn); + 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); } /* Command QUIT. Closes connection with current server. */ - + SILC_CLIENT_CMD_FUNC(quit) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; @@ -692,14 +829,16 @@ SILC_CLIENT_CMD_FUNC(quit) } 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); + &cmd->argv_types[1], + ++cmd->conn->cmd_ident); 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, + NULL, NULL, NULL, + ++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); @@ -731,7 +870,7 @@ SILC_TASK_CALLBACK(silc_client_command_kill_remove_later) 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); @@ -739,7 +878,7 @@ SILC_TASK_CALLBACK(silc_client_command_kill_remove_later) 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 */ @@ -755,7 +894,7 @@ SILC_TASK_CALLBACK(silc_client_command_kill_remove_later) SILC_CLIENT_CMD_FUNC(kill_remove) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; - SilcClientCommandReplyContext reply = + SilcClientCommandReplyContext reply = (SilcClientCommandReplyContext)context2; SilcStatus status; @@ -779,9 +918,9 @@ 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; - char *nickname = NULL; + char *nickname = NULL, *comment = NULL; if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); @@ -790,8 +929,8 @@ SILC_CLIENT_CMD_FUNC(kill) } if (cmd->argc < 2) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /KILL []"); + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + "Usage: /KILL [] [-pubkey]"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; } @@ -803,7 +942,7 @@ SILC_CLIENT_CMD_FUNC(kill) 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) { @@ -813,30 +952,43 @@ SILC_CLIENT_CMD_FUNC(kill) /* 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; } + 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, - ++conn->cmd_ident, 1, - 1, idp->data, idp->len); - else - buffer = silc_command_payload_encode_va(SILC_COMMAND_KILL, - ++conn->cmd_ident, 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(SILC_STATUS_OK); @@ -873,12 +1025,13 @@ SILC_CLIENT_CMD_FUNC(info) /* 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, + ++conn->cmd_ident, 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, + NULL, NULL, NULL, ++conn->cmd_ident); + 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) @@ -891,14 +1044,46 @@ SILC_CLIENT_CMD_FUNC(info) silc_client_command_free(cmd); } -/* Command PING. Sends ping to server. This is used to test the +/* 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); +} + +/* Command PING. Sends ping to server. This is used to test the communication channel. */ SILC_CLIENT_CMD_FUNC(ping) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; SilcClientConnection conn = cmd->conn; - SilcBuffer buffer; + SilcBuffer buffer, idp; void *id; int i; @@ -908,14 +1093,16 @@ SILC_CLIENT_CMD_FUNC(ping) 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)); - silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL, + buffer = silc_command_payload_encode_va(SILC_COMMAND_PING, + ++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); id = silc_id_str2id(conn->remote_id_data, conn->remote_id_data_len, SILC_ID_SERVER); @@ -926,23 +1113,25 @@ SILC_CLIENT_CMD_FUNC(ping) } /* 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); + 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(SILC_STATUS_OK); @@ -957,7 +1146,7 @@ SILC_CLIENT_CMD_FUNC(join) 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; @@ -971,7 +1160,7 @@ SILC_CLIENT_CMD_FUNC(join) 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)) @@ -991,23 +1180,51 @@ SILC_CLIENT_CMD_FUNC(join) } else if (!strcasecmp(cmd->argv[i], "-hmac") && cmd->argc > i + 1) { hmac = cmd->argv[i + 1]; i++; - } else if (!strcasecmp(cmd->argv[i], "-founder") && cmd->argc > i + 1) { - if (!strcasecmp(cmd->argv[i + 1], "-pubkey")) { - auth = silc_auth_public_key_auth_generate(cmd->client->public_key, - cmd->client->private_key, - cmd->client->rng, conn->hash, - conn->local_id, - SILC_ID_CLIENT); - } else { - auth = silc_auth_payload_encode(SILC_AUTH_PASSWORD, NULL, 0, - cmd->argv[i + 1], - cmd->argv_lens[i + 1]); + } 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); + } else if (!strcasecmp(cmd->argv[i], "-auth")) { + SilcPublicKey pubkey = cmd->client->public_key; + SilcPrivateKey privkey = cmd->client->private_key; + unsigned char *pk, pkhash[SILC_HASH_MAXLEN], *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; } - i++; + + 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); } 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], @@ -1022,20 +1239,24 @@ SILC_CLIENT_CMD_FUNC(join) /* 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, ++conn->cmd_ident, 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); /* Notify application */ @@ -1069,14 +1290,16 @@ SILC_CLIENT_CMD_FUNC(motd) /* 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, + ++conn->cmd_ident, 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, + ++conn->cmd_ident, 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); @@ -1106,7 +1329,7 @@ SILC_CLIENT_CMD_FUNC(umode) } if (cmd->argc < 2) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "Usage: /UMODE +|-"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; @@ -1220,11 +1443,11 @@ SILC_CLIENT_CMD_FUNC(umode) /* 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); @@ -1245,7 +1468,7 @@ 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; SilcUInt32 mode, add, type, len, arg_len = 0; int i; @@ -1257,7 +1480,7 @@ SILC_CLIENT_CMD_FUNC(cmode) } if (cmd->argc < 3) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "Usage: /CMODE +|- [{ }]"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; @@ -1265,8 +1488,6 @@ SILC_CLIENT_CMD_FUNC(cmode) if (cmd->argv[1][0] == '*') { if (!conn->current_channel) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "You are not on any channel"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } @@ -1277,8 +1498,6 @@ SILC_CLIENT_CMD_FUNC(cmode) channel = silc_client_get_channel(cmd->client, conn, name); if (!channel) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "You are on that channel"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } @@ -1348,7 +1567,7 @@ SILC_CLIENT_CMD_FUNC(cmode) 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 +|- [{ }]"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; @@ -1366,7 +1585,7 @@ SILC_CLIENT_CMD_FUNC(cmode) 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 +|- [{ }]"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; @@ -1382,7 +1601,7 @@ SILC_CLIENT_CMD_FUNC(cmode) 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 +|- [{ }]"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; @@ -1398,7 +1617,7 @@ SILC_CLIENT_CMD_FUNC(cmode) 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 +|- [{ }]"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; @@ -1411,32 +1630,94 @@ 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) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "Usage: /CMODE +|- [{ }]"); - COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); + 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 { + mode &= ~SILC_CHANNEL_MODE_FOUNDER_AUTH; + } + break; + case 'C': + if (add) { + int k; + SilcBool 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 (!strcasecmp(cmd->argv[3], "-pubkey")) { - auth = silc_auth_public_key_auth_generate(cmd->client->public_key, - cmd->client->private_key, - cmd->client->rng, - 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 >= 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_FOUNDER_AUTH; + mode &= ~SILC_CHANNEL_MODE_CHANNEL_AUTH; } break; default: @@ -1452,24 +1733,26 @@ SILC_CLIENT_CMD_FUNC(cmode) /* Send the command packet. We support sending only one mode at once that requires an argument. */ if (type && arg) { - buffer = - silc_command_payload_encode_va(SILC_COMMAND_CMODE, 0, 3, - 1, chidp->data, chidp->len, + buffer = + silc_command_payload_encode_va(SILC_COMMAND_CMODE, ++conn->cmd_ident, 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, - 1, chidp->data, chidp->len, + buffer = + silc_command_payload_encode_va(SILC_COMMAND_CMODE, ++conn->cmd_ident, 2, + 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 (auth) - silc_buffer_free(auth); + silc_buffer_free(auth); + silc_buffer_free(pk); /* Notify application */ COMMAND(SILC_STATUS_OK); @@ -1501,7 +1784,7 @@ SILC_CLIENT_CMD_FUNC(cumode) } if (cmd->argc < 4) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "Usage: /CUMODE +|- [@]"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; @@ -1509,8 +1792,6 @@ SILC_CLIENT_CMD_FUNC(cumode) if (cmd->argv[1][0] == '*') { if (!conn->current_channel) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "You are not on any channel"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } @@ -1521,8 +1802,6 @@ SILC_CLIENT_CMD_FUNC(cumode) channel = silc_client_get_channel(cmd->client, conn, name); if (!channel) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "You are on that channel"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } @@ -1545,14 +1824,14 @@ SILC_CLIENT_CMD_FUNC(cumode) /* 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) @@ -1582,19 +1861,27 @@ SILC_CLIENT_CMD_FUNC(cumode) 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, - cmd->client->rng, - 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; @@ -1624,6 +1911,12 @@ SILC_CLIENT_CMD_FUNC(cumode) 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(SILC_STATUS_ERR_UNKNOWN_MODE); goto out; @@ -1637,22 +1930,23 @@ 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, - auth ? 4 : 3, - 1, chidp->data, chidp->len, + buffer = silc_command_payload_encode_va(SILC_COMMAND_CUMODE, + ++conn->cmd_ident, + 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); @@ -1668,7 +1962,6 @@ 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; @@ -1682,7 +1975,7 @@ SILC_CLIENT_CMD_FUNC(kick) } if (cmd->argc < 3) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "Usage: /KICK []"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; @@ -1690,8 +1983,6 @@ SILC_CLIENT_CMD_FUNC(kick) if (cmd->argv[1][0] == '*') { if (!conn->current_channel) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "You are not on any channel"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } @@ -1701,22 +1992,17 @@ SILC_CLIENT_CMD_FUNC(kick) } if (!conn->current_channel) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "You are not on that channel"); 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)) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "You are not on that channel"); + 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; - /* Parse the typed nickname. */ if (client->internal->params->nickname_parse) client->internal->params->nickname_parse(cmd->argv[2], &nickname); @@ -1724,27 +2010,29 @@ SILC_CLIENT_CMD_FUNC(kick) 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; } /* Send KICK 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); 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, + ++conn->cmd_ident, 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, + ++conn->cmd_ident, 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); @@ -1771,7 +2059,8 @@ static void silc_client_command_oper_send(unsigned char *data, /* 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->hash, + cmd->client->rng, + conn->internal->hash, conn->local_id, SILC_ID_CLIENT); } else { @@ -1780,14 +2069,17 @@ static void silc_client_command_oper_send(unsigned char *data, 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, + ++conn->cmd_ident, 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); silc_buffer_free(buffer); + silc_buffer_clear(auth); silc_buffer_free(auth); /* Notify application */ @@ -1808,7 +2100,7 @@ SILC_CLIENT_CMD_FUNC(oper) } if (cmd->argc < 2) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "Usage: /OPER [-pubkey]"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; @@ -1829,7 +2121,7 @@ SILC_CLIENT_CMD_FUNC(oper) } static void silc_client_command_silcoper_send(unsigned char *data, - SilcUInt32 data_len, + SilcUInt32 data_len, void *context) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; @@ -1840,7 +2132,8 @@ static void silc_client_command_silcoper_send(unsigned char *data, /* 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->hash, + cmd->client->rng, + conn->internal->hash, conn->local_id, SILC_ID_CLIENT); } else { @@ -1849,14 +2142,17 @@ static void silc_client_command_silcoper_send(unsigned char *data, 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, + ++conn->cmd_ident, 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); silc_buffer_free(buffer); + silc_buffer_clear(auth); silc_buffer_free(auth); /* Notify application */ @@ -1877,7 +2173,7 @@ SILC_CLIENT_CMD_FUNC(silcoper) } if (cmd->argc < 2) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "Usage: /SILCOPER [-pubkey]"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; @@ -1904,9 +2200,10 @@ 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); @@ -1915,7 +2212,7 @@ SILC_CLIENT_CMD_FUNC(ban) } if (cmd->argc < 2) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "Usage: /BAN " "[+|-[[@[![@hostname>]]]]]"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); @@ -1924,8 +2221,6 @@ SILC_CLIENT_CMD_FUNC(ban) if (cmd->argv[1][0] == '*') { if (!conn->current_channel) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "You are not on any channel"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } @@ -1936,8 +2231,6 @@ SILC_CLIENT_CMD_FUNC(ban) channel = silc_client_get_channel(cmd->client, conn, name); if (!channel) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "You are noton that channel"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } @@ -1945,25 +2238,51 @@ SILC_CLIENT_CMD_FUNC(ban) 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 */ - buffer = silc_command_payload_encode_va(SILC_COMMAND_BAN, - ++conn->cmd_ident, 2, + buffer = silc_command_payload_encode_va(SILC_COMMAND_BAN, + ++conn->cmd_ident, 3, 1, chidp->data, chidp->len, - type, ban, ban ? strlen(ban) : 0); - silc_client_packet_send(cmd->client, conn->sock, SILC_PACKET_COMMAND, NULL, + 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(SILC_STATUS_OK); @@ -1988,7 +2307,7 @@ SILC_CLIENT_CMD_FUNC(detach) 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); @@ -2005,8 +2324,10 @@ SILC_CLIENT_CMD_FUNC(watch) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; SilcClientConnection conn = cmd->conn; - SilcBuffer buffer, idp = NULL; + SilcBuffer buffer, idp = NULL, args = NULL; int type = 0; + const char *pubkey = NULL; + SilcBool pubkey_add = TRUE; if (!cmd->conn) { SILC_NOT_CONNECTED(cmd->client, cmd->conn); @@ -2025,19 +2346,51 @@ SILC_CLIENT_CMD_FUNC(watch) type = 2; } else if (!strcasecmp(cmd->argv[1], "-del")) { type = 3; + } else if (!strcasecmp(cmd->argv[1], "-pubkey") && cmd->argc >= 3) { + type = 4; + pubkey = cmd->argv[2] + 1; + if (cmd->argv[2][0] == '-') + pubkey_add = FALSE; } else { COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; } - buffer = silc_command_payload_encode_va(SILC_COMMAND_WATCH, + if (pubkey) { + SilcPublicKey pk; + + if (!silc_pkcs_load_public_key(pubkey, &pk, SILC_PKCS_FILE_PEM)) { + if (!silc_pkcs_load_public_key(pubkey, &pk, SILC_PKCS_FILE_BIN)) { + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_ERROR, + "Could not load public key %s, check the filename", + pubkey); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); + goto out; + } + } + + args = silc_buffer_alloc_size(2); + silc_buffer_format(args, + SILC_STR_UI_SHORT(1), + SILC_STR_END); + buffer = silc_pkcs_public_key_payload_encode(pk); + args = silc_argument_payload_encode_one(args, buffer->data, buffer->len, + pubkey_add ? 0x00 : 0x01); + silc_buffer_free(buffer); + silc_pkcs_public_key_free(pk); + } + + buffer = silc_command_payload_encode_va(SILC_COMMAND_WATCH, ++conn->cmd_ident, 2, 1, idp->data, idp->len, - type, cmd->argv[2], + type, + pubkey ? args->data : cmd->argv[2], + pubkey ? args->len : 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); + silc_buffer_free(args); /* Notify application */ COMMAND(SILC_STATUS_OK); @@ -2055,7 +2408,6 @@ SILC_CLIENT_CMD_FUNC(leave) SilcClientCommandContext cmd = (SilcClientCommandContext)context; SilcClientConnection conn = cmd->conn; SilcChannelEntry channel; - SilcChannelUser chu; SilcBuffer buffer, idp; char *name; @@ -2066,7 +2418,7 @@ SILC_CLIENT_CMD_FUNC(leave) } if (cmd->argc != 2) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "Usage: /LEAVE "); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; @@ -2074,8 +2426,6 @@ SILC_CLIENT_CMD_FUNC(leave) if (cmd->argv[1][0] == '*') { if (!conn->current_channel) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "You are not on any channel"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } @@ -2087,25 +2437,16 @@ SILC_CLIENT_CMD_FUNC(leave) /* Get the channel entry */ channel = silc_client_get_channel(cmd->client, conn, name); if (!channel) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "You are not on that channel"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); 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, + ++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); @@ -2116,8 +2457,6 @@ SILC_CLIENT_CMD_FUNC(leave) if (conn->current_channel == channel) conn->current_channel = NULL; - silc_client_del_channel(cmd->client, cmd->conn, channel); - out: silc_client_command_free(cmd); } @@ -2139,7 +2478,7 @@ SILC_CLIENT_CMD_FUNC(users) } if (cmd->argc != 2) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "Usage: /USERS "); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; @@ -2147,8 +2486,6 @@ SILC_CLIENT_CMD_FUNC(users) if (cmd->argv[1][0] == '*') { if (!conn->current_channel) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, - "You are not on any channel"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ON_CHANNEL); goto out; } @@ -2158,11 +2495,11 @@ SILC_CLIENT_CMD_FUNC(users) } /* 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); @@ -2194,7 +2531,7 @@ SILC_CLIENT_CMD_FUNC(getkey) } 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 "); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; @@ -2221,14 +2558,14 @@ SILC_CLIENT_CMD_FUNC(getkey) 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; @@ -2236,16 +2573,16 @@ SILC_CLIENT_CMD_FUNC(getkey) 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; } @@ -2253,9 +2590,9 @@ SILC_CLIENT_CMD_FUNC(getkey) /* 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; @@ -2271,9 +2608,10 @@ SILC_CLIENT_CMD_FUNC(getkey) 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, + ++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); @@ -2286,20 +2624,61 @@ SILC_CLIENT_CMD_FUNC(getkey) silc_client_command_free(cmd); } +/* Command SERVICE. Negotiates service agreement with server. */ +/* XXX incomplete */ + +SILC_CLIENT_CMD_FUNC(service) +{ + SilcClientCommandContext cmd = (SilcClientCommandContext)context; + SilcClientConnection conn = cmd->conn; + SilcBuffer buffer; + char *name; + + 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: /SERVICE [] [-pubkey]"); + COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); + goto out; + } + + name = cmd->argv[1]; + + /* Send SERVICE command to the server */ + buffer = silc_command_payload_encode_va(SILC_COMMAND_SERVICE, + ++conn->cmd_ident, 1, + 1, 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(SILC_STATUS_OK); + + out: + 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. + 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. */ -bool silc_client_command_register(SilcClient client, +SilcBool silc_client_command_register(SilcClient client, SilcCommand command, const char *name, SilcCommandCb command_function, @@ -2326,7 +2705,7 @@ bool silc_client_command_register(SilcClient client, `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, +SilcBool silc_client_command_unregister(SilcClient client, SilcCommand command, SilcCommandCb command_function, SilcCommandCb command_reply_function, @@ -2368,7 +2747,7 @@ SILC_CLIENT_CMD_FUNC(connect) } if (cmd->argc < 2) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "Usage: /CONNECT []"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; @@ -2380,13 +2759,15 @@ SILC_CLIENT_CMD_FUNC(connect) } 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, + ++conn->cmd_ident, 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], + buffer = silc_command_payload_encode_va(SILC_COMMAND_PRIV_CONNECT, + ++conn->cmd_ident, 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); @@ -2401,7 +2782,7 @@ SILC_CLIENT_CMD_FUNC(connect) /* CLOSE command. Close server connection to the remote server */ - + SILC_CLIENT_CMD_FUNC(close) { SilcClientCommandContext cmd = (SilcClientCommandContext)context; @@ -2417,7 +2798,7 @@ SILC_CLIENT_CMD_FUNC(close) } if (cmd->argc < 2) { - SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, + SAY(cmd->client, conn, SILC_CLIENT_MESSAGE_INFO, "Usage: /CLOSE []"); COMMAND_ERROR(SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); goto out; @@ -2429,13 +2810,15 @@ SILC_CLIENT_CMD_FUNC(close) } 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, + ++conn->cmd_ident, 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], + buffer = silc_command_payload_encode_va(SILC_COMMAND_PRIV_CLOSE, + ++conn->cmd_ident, 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); @@ -2447,7 +2830,7 @@ SILC_CLIENT_CMD_FUNC(close) out: silc_client_command_free(cmd); } - + /* SHUTDOWN command. Shutdowns the server. */ SILC_CLIENT_CMD_FUNC(shutdown) @@ -2461,7 +2844,7 @@ 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 */ @@ -2476,10 +2859,10 @@ SILC_CLIENT_CMD_FUNC(shutdown) 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); + SILC_CLIENT_CMD(whois, WHOIS, "WHOIS", 5); SILC_CLIENT_CMD(whowas, WHOWAS, "WHOWAS", 3); SILC_CLIENT_CMD(identify, IDENTIFY, "IDENTIFY", 3); SILC_CLIENT_CMD(nick, NICK, "NICK", 2); @@ -2487,15 +2870,16 @@ void silc_client_commands_register(SilcClient client) 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", 3); + 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", 4); - SILC_CLIENT_CMD(cumode, CUMODE, "CUMODE", 5); + 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); @@ -2504,6 +2888,7 @@ void silc_client_commands_register(SilcClient client) SILC_CLIENT_CMD(leave, LEAVE, "LEAVE", 2); SILC_CLIENT_CMD(users, USERS, "USERS", 2); SILC_CLIENT_CMD(getkey, GETKEY, "GETKEY", 2); + SILC_CLIENT_CMD(service, SERVICE, "SERVICE", 10); SILC_CLIENT_CMD(connect, PRIV_CONNECT, "CONNECT", 3); SILC_CLIENT_CMD(close, PRIV_CLOSE, "CLOSE", 3); @@ -2524,6 +2909,7 @@ void silc_client_commands_unregister(SilcClient client) 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"); @@ -2539,8 +2925,103 @@ void silc_client_commands_unregister(SilcClient client) SILC_CLIENT_CMDU(leave, LEAVE, "LEAVE"); SILC_CLIENT_CMDU(users, USERS, "USERS"); SILC_CLIENT_CMDU(getkey, GETKEY, "GETKEY"); + SILC_CLIENT_CMDU(service, SERVICE, "SERVICE"); 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); +}