--- /dev/null
+/*
+
+ server_query.c
+
+ Author: Pekka Riikonen <priikone@silcnet.org>
+
+ Copyright (C) 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; 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
+ GNU General Public License for more details.
+
+*/
+/* $Id$ */
+
+#include "serverincludes.h"
+#include "server_internal.h"
+
+typedef struct {
+ void *id;
+ SilcIdType id_type;
+} *SilcServerQueryID;
+
+typedef struct {
+ SilcUInt32 index; /* Index to IDs */
+ bool from_cmd; /* TRUE if `index' is from command args,
+ otherwise from query->ids */
+ SilcStatus error; /* The actual error */
+} *SilcServerQueryError;
+
+typedef struct {
+ SilcCommand querycmd; /* Query command */
+ SilcServerCommandContext cmd; /* Command context for query */
+
+ char *nickname; /* Queried nickname */
+ char *nick_server; /* Queried nickname's server */
+ char *server_name; /* Queried server name */
+ char *channel_name; /* Queried channel name */
+ SilcServerQueryID ids; /* Queried IDs */
+ SilcUInt32 ids_count; /* number of queried IDs */
+ SilcUInt32 reply_count; /* Requested reply count */
+ SilcDList attrs; /* Requested Attributes in WHOIS */
+
+ SilcServerQueryError errors; /* Query errors */
+ SilcUInt32 errors_count; /* number of errors */
+} *SilcServerQuery;
+
+void silc_server_query_free(SilcServerQuery query);
+bool silc_server_query_check_error(SilcServer server,
+ SilcServerQuery query,
+ SilcServerCommandReplyContext cmdr);
+void silc_server_query_send_error(SilcServer server,
+ SilcServerQuery query,
+ SilcStatus error, ...);
+void silc_server_query_add_error(SilcServer server,
+ SilcServerQuery query,
+ bool from_cmd,
+ SilcUInt32 index,
+ SilcStatus error);
+void silc_server_query_send_router(SilcServer server, SilcServerQuery query);
+void silc_server_query_send_router_reply(void *context, void *reply);
+void silc_server_query_parse(SilcServer server, SilcServerQuery query);
+void silc_server_query_process(SilcServer server, SilcServerQuery query);
+
+
+/* Free the query context structure and all allocated resources. */
+
+void silc_server_query_free(SilcServerQuery query)
+{
+ int i;
+
+ silc_server_command_free(query->cmd);
+
+ silc_free(query->nickname);
+ silc_free(query->nick_server);
+ silc_free(query->server_name);
+ silc_free(query->channel_name);
+
+ for (i = 0; i < query->ids_count; i++)
+ silc_free(query->ids[i].id);
+ silc_free(query->ids);
+
+ if (query->attrs)
+ silc_attribute_payload_list_free(query->attrs);
+
+ silc_free(query->errors);
+
+ memset(query, 'F', sizeof(*query));
+ silc_free(query);
+}
+
+/* Check whether command reply contained error, and reply the error to
+ the original sender if it occurred. */
+
+bool silc_server_query_check_error(SilcServer server,
+ SilcServerQuery query,
+ SilcServerCommandReplyContext cmdr)
+{
+ if (!cmdr)
+ return FALSE;
+
+ if (!silc_command_get_status(cmdr->payload, NULL, NULL)) {
+ SilcBuffer buffer;
+
+ /* Send the same command reply payload which contains the error */
+ silc_command_set_command(cmdr->payload, query->querycmd);
+ silc_command_set_ident(cmdr->payload,
+ silc_command_get_ident(query->cmd->payload));
+ buffer = silc_command_payload_encode_payload(cmdr->payload);
+ silc_server_packet_send(server, query->cmd->sock,
+ SILC_PACKET_COMMAND_REPLY, 0,
+ buffer->data, buffer->len, FALSE);
+ silc_buffer_free(buffer);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+/* Send error reply indicated by the `error' to the original sender of
+ the query. */
+
+void silc_server_query_send_error(SilcServer server,
+ SilcServerQuery query,
+ SilcStatus error, ...)
+{
+ va_list va;
+ SilcBuffer packet;
+ unsigned char *data = NULL;
+ SilcUInt32 data_len = 0, data_type = 0, argc = 0;
+
+ va_start(va, error);
+ data_type = va_arg(va, SilcUInt32);
+ if (data_type) {
+ argc = 1;
+ data = va_arg(va, unsigned char *);
+ data_len = va_arg(va, SilcUInt32);
+ }
+
+ /* Send the command reply with error */
+ packet = silc_command_reply_payload_encode_va(
+ query->querycmd, error, 0,
+ silc_command_get_ident(query->cmd->payload),
+ argc, data_type, data, data_len);
+ silc_server_packet_send(server, query->cmd->sock,
+ SILC_PACKET_COMMAND_REPLY, 0,
+ packet->data, packet->len, FALSE);
+
+ silc_buffer_free(packet);
+ va_end(va);
+}
+
+/* Add error to error list. Multiple errors may occur during the query
+ processing and this function can be used to add one error. The
+ `type_index' is the index to the command context which includes the
+ argument which caused the error. */
+
+void silc_server_query_add_error(SilcServer server,
+ SilcServerQuery query,
+ bool from_cmd,
+ SilcUInt32 index,
+ SilcStatus error)
+{
+ query->errors = silc_realloc(query->errors, sizeof(*query->errors) *
+ (query->errors_count + 1));
+ if (!query->errors)
+ return;
+ query->errors[query->errors_count].index = index;
+ query->errors[query->errors_count].from_cmd = from_cmd;
+ query->errors[query->errors_count].error = error;
+ query->errors_count++;
+}
+
+/* Processes query as command. The `query' is the command that is
+ being processed indicated by the `cmd'. The `query' can be one of
+ the following: SILC_COMMAND_WHOIS, SILC_COMMAND_WHOWAS or
+ SILC_COMMAND_IDENTIFY. This function handles the reply sending
+ to the entity who sent this query to us automatically. Returns
+ TRUE if the query is being processed or FALSE on error. */
+
+bool silc_server_query_command(SilcServer server, SilcCommand querycmd,
+ SilcServerCommandContext cmd)
+{
+ SilcServerQuery query;
+
+ switch (querycmd) {
+
+ case SILC_COMMAND_WHOIS:
+ {
+ query = silc_calloc(1, sizeof(*query));
+ query->querycmd = querycmd;
+ query->cmd = silc_server_command_dup(cmd);
+
+ /* If we are normal server and query contains nickname, send it
+ directly to router. */
+ if (server->server_type == SILC_SERVER && !server->standalone &&
+ silc_argument_get_arg_type(cmd->args, 1, NULL)) {
+ silc_server_query_send_router(server, query);
+ break;
+ }
+
+ /* Now parse the WHOIS query */
+ silc_server_query_parse(server, query);
+ }
+ break;
+
+ case SILC_COMMAND_WHOWAS:
+ {
+ query = silc_calloc(1, sizeof(*query));
+ query->querycmd = querycmd;
+ query->cmd = silc_server_command_dup(cmd);
+
+ /* WHOWAS query is always sent to router if we are normal server */
+ if (server->server_type == SILC_SERVER && !server->standalone) {
+ silc_server_query_send_router(server, query);
+ break;
+ }
+
+ /* Now parse the WHOWAS query */
+ silc_server_query_parse(server, query);
+ }
+ break;
+
+ case SILC_COMMAND_IDENTIFY:
+ {
+ query = silc_calloc(1, sizeof(*query));
+ query->querycmd = querycmd;
+ query->cmd = silc_server_command_dup(cmd);
+
+ /* If we are normal server and query does not contain IDs, send it
+ directly to router (it contains nickname, server name or channel
+ name). */
+ if (server->server_type == SILC_SERVER && !server->standalone &&
+ !silc_argument_get_arg_type(cmd->args, 5, NULL)) {
+ silc_server_query_send_router(server, query);
+ break;
+ }
+
+ /* Now parse the IDENTIFY query */
+ silc_server_query_parse(server, query);
+ }
+ break;
+
+ default:
+ SILC_LOG_ERROR(("Bad query using %d command", querycmd));
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+/* Send the received query to our primary router since we could not
+ handle the query directly. We will reprocess the query after our
+ router replies back. */
+
+void silc_server_query_send_router(SilcServer server, SilcServerQuery query)
+{
+ SilcBuffer tmpbuf;
+ SilcUInt16 old_ident;
+
+ /* Send WHOIS command to our router */
+ old_ident = silc_command_get_ident(query->cmd->payload);
+ silc_command_set_ident(query->cmd->payload, ++server->cmd_ident);
+ tmpbuf = silc_command_payload_encode_payload(query->cmd->payload);
+ silc_server_packet_send(server,
+ SILC_PRIMARY_ROUTE(server),
+ SILC_PACKET_COMMAND, 0,
+ tmpbuf->data, tmpbuf->len, TRUE);
+ silc_command_set_ident(query->cmd->payload, old_ident);
+ silc_buffer_free(tmpbuf);
+
+ /* Continue parsing the query after received reply from router */
+ silc_server_command_pending(server, query->querycmd, server->cmd_ident,
+ silc_server_query_send_router_reply, query);
+}
+
+/* Reply callback called after primary router has replied to our initial
+ sending of the query to it. We will proceed the query in this function. */
+
+void silc_server_query_send_router_reply(void *context, void *reply)
+{
+ SilcServerQuery query = context;
+ SilcServer server = query->cmd->server;
+
+ /* Check if router sent error reply */
+ if (!silc_server_query_check_error(server, query, reply)) {
+ silc_server_query_free(query);
+ return;
+ }
+
+ /* Continue with parsing */
+ silc_server_query_parse(server, query);
+}
+
+/* Parse the command query and start processing the queries in detail. */
+
+void silc_server_query_parse(SilcServer server, SilcServerQuery query)
+{
+ SilcServerCommandContext cmd = query->cmd;
+ unsigned char *tmp;
+ SilcUInt32 tmp_len, argc = silc_argument_get_arg_num(cmd->args);
+ void *id;
+ SilcIdType id_type;
+ int i;
+
+ switch (query->querycmd) {
+
+ case SILC_COMMAND_WHOIS:
+ {
+ /* Get Client IDs if present. Take IDs always instead of nickname. */
+ tmp = silc_argument_get_arg_type(cmd->args, 4, &tmp_len);
+ if (!tmp) {
+
+ /* Get nickname */
+ tmp = silc_argument_get_arg_type(cmd->args, 1, &tmp_len);
+ if (!tmp) {
+ silc_server_query_send_error(server, query,
+ SILC_STATUS_ERR_NOT_ENOUGH_PARAMS, 0);
+ silc_server_query_free(query);
+ return;
+ }
+
+ /* Get the nickname@server string and parse it */
+ if (!silc_parse_userfqdn(tmp, &query->nickname, &query->nick_server)) {
+ silc_server_query_send_error(server, query,
+ SILC_STATUS_ERR_BAD_NICKNAME, 0);
+ silc_server_query_free(query);
+ return;
+ }
+
+ } else {
+ /* Parse the IDs included in the query */
+ query->ids = silc_calloc(argc, sizeof(*query->ids));
+
+ for (i = 0; i < argc; i++) {
+ tmp = silc_argument_get_arg_type(cmd->args, i + 4, &tmp_len);
+ if (!tmp)
+ continue;
+
+ id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
+ if (!id) {
+ silc_server_query_add_error(server, query, TRUE, i + 4,
+ SILC_STATUS_ERR_BAD_CLIENT_ID);
+ continue;
+ }
+
+ query->ids[query->ids_count].id = id;
+ query->ids[query->ids_count].id_type = SILC_ID_CLIENT;
+ query->ids_count++;
+ }
+ }
+
+ /* Get the max count of reply messages allowed */
+ tmp = silc_argument_get_arg_type(cmd->args, 2, &tmp_len);
+ if (tmp && tmp_len == sizeof(SilcUInt32))
+ SILC_GET32_MSB(query->reply_count, tmp);
+
+ /* Get requested attributes if set */
+ tmp = silc_argument_get_arg_type(cmd->args, 3, &tmp_len);
+ if (tmp)
+ query->attrs = silc_attribute_payload_parse_list(tmp, tmp_len);
+ }
+ break;
+
+ case SILC_COMMAND_WHOWAS:
+ {
+ /* Get nickname */
+ tmp = silc_argument_get_arg_type(cmd->args, 1, &tmp_len);
+ if (!tmp) {
+ silc_server_query_send_error(server, query,
+ SILC_STATUS_ERR_NOT_ENOUGH_PARAMS, 0);
+ silc_server_query_free(query);
+ return;
+ }
+
+ /* Get the nickname@server string and parse it */
+ if (!silc_parse_userfqdn(tmp, &query->nickname, &query->nick_server)) {
+ silc_server_query_send_error(server, query,
+ SILC_STATUS_ERR_BAD_NICKNAME, 0);
+ silc_server_query_free(query);
+ return;
+ }
+
+ /* Get the max count of reply messages allowed */
+ tmp = silc_argument_get_arg_type(cmd->args, 2, &tmp_len);
+ if (tmp && tmp_len == sizeof(SilcUInt32))
+ SILC_GET32_MSB(query->reply_count, tmp);
+ }
+ break;
+
+ case SILC_COMMAND_IDENTIFY:
+ {
+ /* Get IDs if present. Take IDs always instead of names. */
+ tmp = silc_argument_get_arg_type(cmd->args, 5, &tmp_len);
+ if (!tmp) {
+
+ /* Try get nickname */
+ tmp = silc_argument_get_arg_type(cmd->args, 1, &tmp_len);
+ if (tmp) {
+ /* Get the nickname@server string and parse it */
+ if (!silc_parse_userfqdn(tmp, &query->nickname, &query->nick_server))
+ silc_server_query_add_error(server, query, TRUE, 1,
+ SILC_STATUS_ERR_BAD_NICKNAME);
+ }
+
+ /* Try get server name */
+ tmp = silc_argument_get_arg_type(cmd->args, 2, &tmp_len);
+ if (tmp)
+ query->server_name = silc_memdup(tmp, tmp_len);
+
+ /* Get channel name */
+ tmp = silc_argument_get_arg_type(cmd->args, 3, &tmp_len);
+ if (tmp)
+ query->channel_name = silc_memdup(tmp, tmp_len);
+
+ } else {
+ /* Parse the IDs included in the query */
+ query->ids = silc_calloc(argc, sizeof(*query->ids));
+
+ for (i = 0; i < argc; i++) {
+ tmp = silc_argument_get_arg_type(cmd->args, i + 5, &tmp_len);
+ if (!tmp)
+ continue;
+
+ id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
+ if (!id) {
+ silc_server_query_add_error(server, query, TRUE, i + 5,
+ SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
+ continue;
+ }
+
+ query->ids[query->ids_count].id = id;
+ query->ids[query->ids_count].id_type = id_type;
+ query->ids_count++;
+ }
+ }
+
+ /* Get the max count of reply messages allowed */
+ tmp = silc_argument_get_arg_type(cmd->args, 4, &tmp_len);
+ if (tmp && tmp_len == sizeof(SilcUInt32))
+ SILC_GET32_MSB(query->reply_count, tmp);
+ }
+ break;
+ }
+
+ /* Start processing the query information */
+ silc_server_query_process(server, query);
+}
+
+/* Processes the parsed query. This does the actual finding of the
+ queried information and prepares for sending reply to the original
+ sender of the query command. It is guaranteed that this function
+ (which may be slow) is called only once for entire query. */
+
+void silc_server_query_process(SilcServer server, SilcServerQuery query)
+{
+ SilcServerCommandContext cmd = query->cmd;
+ bool check_global = FALSE;
+ void *entry;
+ SilcClientEntry *clients = NULL;
+ SilcChannelEntry *channels = NULL;
+ SilcServerEntry *servers = NULL;
+ SilcUInt32 clients_count = 0, channels_count = 0, servers_count = 0;
+ int i;
+
+ /* Check global lists if query is coming from client or we are not
+ normal server (we know global information). */
+ if (cmd->sock->type == SILC_SOCKET_TYPE_CLIENT)
+ check_global = TRUE;
+ else if (server->server_type != SILC_SERVER)
+ check_global = TRUE;
+
+ if (query->nickname) {
+ /* Get all clients matching nickname from local list */
+ if (!silc_idlist_get_clients_by_hash(server->local_list,
+ query->nickname, server->md5hash,
+ &clients, &clients_count))
+ silc_idlist_get_clients_by_nickname(server->local_list,
+ query->nickname,
+ query->nick_server,
+ &clients, &clients_count);
+
+ /* Check global list as well */
+ if (check_global) {
+ if (!silc_idlist_get_clients_by_hash(server->global_list,
+ query->nickname, server->md5hash,
+ &clients, &clients_count))
+ silc_idlist_get_clients_by_nickname(server->global_list,
+ query->nickname,
+ query->nick_server,
+ &clients, &clients_count);
+ }
+
+ if (!clients)
+ silc_server_query_add_error(server, query, TRUE, 1,
+ SILC_STATUS_ERR_NO_SUCH_NICK);
+ }
+
+ if (query->server_name) {
+ /* Find server by name */
+ entry = silc_idlist_find_server_by_name(server->local_list,
+ query->server_name, TRUE, NULL);
+ if (!entry && check_global)
+ entry = silc_idlist_find_server_by_name(server->global_list,
+ query->server_name, TRUE, NULL);
+ if (entry) {
+ servers = silc_realloc(servers, sizeof(*servers) * (servers_count + 1));
+ servers[servers_count++] = (SilcServerEntry)entry;
+ }
+
+ if (!servers)
+ silc_server_query_add_error(server, query, TRUE, 2,
+ SILC_STATUS_ERR_NO_SUCH_SERVER);
+ }
+
+ if (query->channel_name) {
+ /* Find channel by name */
+ entry = silc_idlist_find_channel_by_name(server->local_list,
+ query->channel_name, NULL);
+ if (!entry && check_global)
+ entry = silc_idlist_find_channel_by_name(server->global_list,
+ query->channel_name, NULL);
+ if (entry) {
+ channels = silc_realloc(channels, sizeof(*channels) *
+ (channels_count + 1));
+ channels[channels_count++] = (SilcChannelEntry)entry;
+ }
+
+ if (!channels)
+ silc_server_query_add_error(server, query, TRUE, 3,
+ SILC_STATUS_ERR_NO_SUCH_CHANNEL);
+ }
+
+ if (query->ids_count) {
+ /* Find entries by the queried IDs */
+ for (i = 0; i < query->ids_count; i++) {
+ void *id = query->ids[i].id;
+ if (!id)
+ continue;
+
+ switch (query->ids[i].id_type) {
+
+ case SILC_ID_CLIENT:
+ /* Get client entry */
+ entry = silc_idlist_find_client_by_id(server->local_list,
+ id, TRUE, NULL);
+ if (!entry && check_global)
+ entry = silc_idlist_find_client_by_id(server->global_list,
+ id, TRUE, NULL);
+ if (!entry) {
+ silc_server_query_add_error(server, query, FALSE, i,
+ SILC_STATUS_ERR_NO_SUCH_CLIENT_ID);
+ continue;
+ }
+
+ clients = silc_realloc(clients, sizeof(*clients) *
+ (clients_count + 1));
+ clients[clients_count++] = (SilcClientEntry)entry;
+ break;
+
+ case SILC_ID_SERVER:
+ /* Get server entry */
+ entry = silc_idlist_find_server_by_id(server->local_list,
+ id, TRUE, NULL);
+ if (!entry && check_global)
+ entry = silc_idlist_find_server_by_id(server->global_list,
+ id, TRUE, NULL);
+ if (!entry) {
+ silc_server_query_add_error(server, query, FALSE, i,
+ SILC_STATUS_ERR_NO_SUCH_SERVER_ID);
+ continue;
+ }
+
+ servers = silc_realloc(servers, sizeof(*servers) *
+ (servers_count + 1));
+ servers[servers_count++] = (SilcServerEntry)entry;
+ break;
+
+ case SILC_ID_CHANNEL:
+ /* Get channel entry */
+ entry = silc_idlist_find_channel_by_id(server->local_list, id, NULL);
+ if (!entry && check_global)
+ entry = silc_idlist_find_channel_by_id(server->global_list, id,
+ NULL);
+ if (!entry) {
+ silc_server_query_add_error(server, query, FALSE, i,
+ SILC_STATUS_ERR_NO_SUCH_CHANNEL_ID);
+ continue;
+ }
+
+ channels = silc_realloc(channels, sizeof(*channels) *
+ (channels_count + 1));
+ channels[channels_count++] = (SilcChannelEntry)entry;
+ break;
+
+ default:
+ break;
+ }
+ }
+ }
+
+ /* If nothing was found, then just send the errors */
+ if (!clients && !channels && !servers) {
+
+ silc_server_query_free(query);
+ return;
+ }
+
+ /* Now process all found information and if necessary do some more
+ querying. */
+
+}
+
+/* Find client by the Client ID indicated by the `client_id', and if not
+ found then query it by using WHOIS command. The client information
+ is also resolved if the cached information is incomplete or if the
+ `always_resolve' is set to TRUE. The indication whether requested
+ client was being resolved is saved into `resolved'. If the client
+ is not being resolved its entry is returned by this function. NULL
+ is returned if client is resolved. */
+
+SilcClientEntry silc_server_query_client(SilcServer server,
+ const SilcClientID *client_id,
+ bool always_resolve,
+ bool *resolved)
+{
+ SilcClientEntry client;
+
+ if (resolved)
+ *resolved = FALSE;
+
+ client = silc_idlist_find_client_by_id(server->local_list,
+ (SilcClientID *)client_id,
+ TRUE, NULL);
+ if (!client) {
+ client = silc_idlist_find_client_by_id(server->global_list,
+ (SilcClientID *)client_id,
+ TRUE, NULL);
+ if (!client && server->server_type == SILC_ROUTER)
+ return NULL;
+ }
+
+ if (!client && server->standalone)
+ return NULL;
+
+ if (!client || !client->nickname || !client->username ||
+ always_resolve) {
+ SilcBuffer buffer, idp;
+
+ if (client) {
+ client->data.status |= SILC_IDLIST_STATUS_RESOLVING;
+ client->data.status &= ~SILC_IDLIST_STATUS_RESOLVED;
+ client->resolve_cmd_ident = ++server->cmd_ident;
+ }
+
+ idp = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
+ buffer = silc_command_payload_encode_va(SILC_COMMAND_WHOIS,
+ server->cmd_ident, 1,
+ 4, idp->data, idp->len);
+ silc_server_packet_send(server, client ? client->router->connection :
+ SILC_PRIMARY_ROUTE(server),
+ SILC_PACKET_COMMAND, 0,
+ buffer->data, buffer->len, FALSE);
+ silc_buffer_free(idp);
+ silc_buffer_free(buffer);
+
+ if (resolved)
+ *resolved = TRUE;
+
+ return NULL;
+ }
+
+ return client;
+}
projects / silc.git / commitdiff