{ NULL, 0 },
};
+#define SILC_SERVER_COMMAND_CHECK_ARGC(command, context, min, max) \
+do { \
+ unsigned int _argc = silc_argument_get_arg_num(cmd->args); \
+ \
+ SILC_LOG_DEBUG(("Start")); \
+ \
+ if (_argc < min) { \
+ silc_server_command_send_status_reply(cmd, command, \
+ SILC_STATUS_ERR_NOT_ENOUGH_PARAMS); \
+ silc_server_command_free(cmd); \
+ return; \
+ } \
+ if (_argc > max) { \
+ silc_server_command_send_status_reply(cmd, command, \
+ SILC_STATUS_ERR_TOO_MANY_PARAMS); \
+ silc_server_command_free(cmd); \
+ return; \
+ } \
+} while(0)
+
/* Returns TRUE if the connection is registered. Unregistered connections
usually cannot send commands hence the check. */
silc_buffer_free(buffer);
}
-/* Server side of command WHOIS. Processes user's query and sends found
- results as command replies back to the client. */
+/******************************************************************************
-SILC_SERVER_CMD_FUNC(whois)
-{
- SilcServerCommandContext cmd = (SilcServerCommandContext)context;
- SilcServer server = cmd->server;
- char *tmp, *nick = NULL, *server_name = NULL;
- unsigned int i, argc, count = 0, len, clients_count;
- int use_id = FALSE;
- SilcClientID *client_id = NULL;
- SilcBuffer packet, idp;
- SilcClientEntry *clients = NULL, entry;
- SilcCommandStatus status;
+ WHOIS Functions
- SILC_LOG_DEBUG(("Start"));
+******************************************************************************/
- argc = silc_argument_get_arg_num(cmd->args);
- if (argc < 1) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_WHOIS,
- SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- goto out;
- }
- if (argc > 3) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_WHOIS,
- SILC_STATUS_ERR_TOO_MANY_PARAMS);
- goto out;
- }
+static int
+silc_server_command_whois_parse(SilcServerCommandContext cmd,
+ SilcClientID **client_id,
+ char **nickname,
+ char **server_name,
+ int *count)
+{
+ unsigned char *tmp;
+ unsigned int len;
+ unsigned int argc = silc_argument_get_arg_num(cmd->args);
/* If client ID is in the command it must be used instead of nickname */
tmp = silc_argument_get_arg_type(cmd->args, 2, &len);
if (!tmp) {
-
/* No ID, get the nickname@server string and parse it. */
tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
if (tmp) {
if (strchr(tmp, '@')) {
len = strcspn(tmp, "@");
- nick = silc_calloc(len + 1, sizeof(char));
- memcpy(nick, tmp, len);
- server_name = silc_calloc(strlen(tmp) - len, sizeof(char));
- memcpy(server_name, tmp + len + 1, strlen(tmp) - len - 1);
+ *nickname = silc_calloc(len + 1, sizeof(char));
+ memcpy(*nickname, tmp, len);
+ *server_name = silc_calloc(strlen(tmp) - len, sizeof(char));
+ memcpy(*server_name, tmp + len + 1, strlen(tmp) - len - 1);
} else {
- nick = strdup(tmp);
+ *nickname = strdup(tmp);
}
} else {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_WHOIS,
SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- goto out;
+ return FALSE;
}
} else {
/* Command includes ID, use that */
- client_id = silc_id_payload_parse_id(tmp, len);
- use_id = TRUE;
+ *client_id = silc_id_payload_parse_id(tmp, len);
}
/* Get the max count of reply messages allowed */
if (!tmp) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_WHOIS,
SILC_STATUS_ERR_TOO_MANY_PARAMS);
- if (nick)
- silc_free(nick);
- if (server_name)
- silc_free(server_name);
- goto out;
+ if (*nickname)
+ silc_free(*nickname);
+ if (*server_name)
+ silc_free(*server_name);
+
+ return FALSE;
}
- count = atoi(tmp);
+ *count = atoi(tmp);
}
- /* Protocol dictates that we must always send the received WHOIS request
- to our router if we are normal server, so let's do it now unless we
- are standalone. We will not send any replies to the client until we
- have received reply from the router. */
- if (!server->standalone) {
- SilcBuffer tmpbuf;
+ return TRUE;
+}
- silc_command_set_ident(cmd->payload, silc_rng_get_rn16(server->rng));
- tmpbuf = silc_command_payload_encode_payload(cmd->payload);
+static char
+silc_server_command_whois_check(SilcServerCommandContext cmd,
+ SilcClientEntry *clients,
+ unsigned int clients_count)
+{
+ SilcServer server = cmd->server;
+ int i;
+ SilcClientEntry entry;
- /* Send WHOIS command to our router */
- silc_server_packet_send(server, (SilcSocketConnection)
- server->router->connection,
- SILC_PACKET_COMMAND, cmd->packet->flags,
- tmpbuf->data, tmpbuf->len, TRUE);
- return;
- } else {
- /* We are standalone, let's just do local search and send reply to
- requesting client. */
+ for (i = 0; i < clients_count; i++) {
+ entry = clients[i];
- /* Get all clients matching that nickname */
- if (!use_id) {
- clients = silc_idlist_get_clients_by_nickname(server->local_list,
- nick, server_name,
- &clients_count);
- } else {
- entry = silc_idlist_find_client_by_id(server->local_list, client_id);
- if (entry) {
- clients = silc_calloc(1, sizeof(*clients));
- clients[0] = entry;
- clients_count = 1;
- }
- }
-
- /* If we are router then we will check our global list as well. */
- if (server->server_type == SILC_ROUTER) {
- entry =
- silc_idlist_find_client_by_nickname(server->global_list,
- nick, server_name);
- if (!entry) {
- silc_server_command_send_status_data(cmd, SILC_COMMAND_WHOIS,
- SILC_STATUS_ERR_NO_SUCH_NICK,
- 3, tmp, strlen(tmp));
- goto out;
- }
- goto ok;
- }
+ if (!entry->nickname || !entry->username || !entry->userinfo) {
+ SilcBuffer tmpbuf;
+ unsigned short old_ident;
-#if 0
- silc_server_command_send_status_data(cmd, SILC_COMMAND_WHOIS,
- SILC_STATUS_ERR_NO_SUCH_NICK,
- 3, tmp, strlen(tmp));
- goto out;
-#endif
+ old_ident = silc_command_get_ident(cmd->payload);
+ silc_command_set_ident(cmd->payload, silc_rng_get_rn16(server->rng));
+ tmpbuf = silc_command_payload_encode_payload(cmd->payload);
+
+ /* Send WHOIS command */
+ silc_server_packet_send(server, entry->router->connection,
+ SILC_PACKET_COMMAND, cmd->packet->flags,
+ tmpbuf->data, tmpbuf->len, TRUE);
+
+ /* Reprocess this packet after received reply */
+ silc_server_command_pending(server, SILC_COMMAND_WHOIS,
+ silc_command_get_ident(cmd->payload),
+ silc_server_command_whois, (void *)cmd);
+ cmd->pending = TRUE;
+
+ silc_command_set_ident(cmd->payload, old_ident);
+
+ silc_buffer_free(tmpbuf);
+ return FALSE;
+ }
}
- /* We are standalone and will send reply to client */
- ok:
-
+ return TRUE;
+}
+
+static void
+silc_server_command_whois_send_reply(SilcServerCommandContext cmd,
+ SilcClientEntry *clients,
+ unsigned int clients_count)
+{
+ SilcServer server = cmd->server;
+ char *tmp;
+ int i, count = 0, len;
+ SilcBuffer packet, idp;
+ SilcClientEntry entry;
+ SilcCommandStatus status;
+ unsigned short ident = silc_command_get_ident(cmd->payload);
+
status = SILC_STATUS_OK;
if (clients_count > 1)
status = SILC_STATUS_LIST_START;
tmp = silc_argument_get_first_arg(cmd->args, NULL);
/* XXX */
- if (cmd->sock->type == SILC_SOCKET_TYPE_CLIENT) {
+ {
char nh[256], uh[256];
unsigned char idle[4];
SilcSocketConnection hsock;
memset(nh, 0, sizeof(nh));
strncat(nh, entry->nickname, strlen(entry->nickname));
- strncat(nh, "@", 1);
- len = entry->router ? strlen(entry->router->server_name) :
- strlen(server->server_name);
- strncat(nh, entry->router ? entry->router->server_name :
- server->server_name, len);
+ if (!strchr(entry->nickname, '@')) {
+ strncat(nh, "@", 1);
+ len = entry->router ? strlen(entry->router->server_name) :
+ strlen(server->server_name);
+ strncat(nh, entry->router ? entry->router->server_name :
+ server->server_name, len);
+ }
strncat(uh, entry->username, strlen(entry->username));
- strncat(uh, "@", 1);
- hsock = (SilcSocketConnection)entry->connection;
- len = hsock->hostname ? strlen(hsock->hostname) : strlen(hsock->ip);
- strncat(uh, hsock->hostname ? hsock->hostname : hsock->ip, len);
+ if (!strchr(entry->username, '@')) {
+ strncat(uh, "@", 1);
+ hsock = (SilcSocketConnection)entry->connection;
+ len = strlen(hsock->hostname);
+ strncat(uh, hsock->hostname, len);
+ }
SILC_PUT32_MSB((time(NULL) - entry->data.last_receive), idle);
if (entry->userinfo)
packet =
silc_command_reply_payload_encode_va(SILC_COMMAND_WHOIS,
- status, 0, 5,
+ status, ident, 5,
2, idp->data, idp->len,
3, nh, strlen(nh),
4, uh, strlen(uh),
else
packet =
silc_command_reply_payload_encode_va(SILC_COMMAND_WHOIS,
- status, 0, 4,
+ status, ident, 4,
2, idp->data, idp->len,
3, nh, strlen(nh),
4, uh, strlen(uh),
7, idle, 4);
-
- } else {
- /* XXX */
- packet =
- silc_command_reply_payload_encode_va(SILC_COMMAND_WHOIS,
- status, 0, 3,
- 2, idp->data, idp->len,
- 3, entry->nickname,
- strlen(entry->nickname),
- 4, tmp, strlen(tmp)); /* XXX */
}
+
silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY,
0, packet->data, packet->len, FALSE);
silc_buffer_free(packet);
silc_buffer_free(idp);
}
+}
- silc_free(clients);
+static int
+silc_server_command_whois_from_client(SilcServerCommandContext cmd)
+{
+ SilcServer server = cmd->server;
+ char *nick = NULL, *server_name = NULL;
+ int count = 0, clients_count;
+ SilcClientID *client_id = NULL;
+ SilcClientEntry *clients = NULL, entry;
+ int ret = 0;
- if (client_id)
- silc_free(client_id);
+ /* Parse the whois request */
+ if (!silc_server_command_whois_parse(cmd, &client_id, &nick,
+ &server_name, &count))
+ return 0;
+
+ /* Protocol dictates that we must always send the received WHOIS request
+ to our router if we are normal server, so let's do it now unless we
+ are standalone. We will not send any replies to the client until we
+ have received reply from the router. */
+ if (server->server_type == SILC_SERVER &&
+ !cmd->pending && !server->standalone) {
+ SilcBuffer tmpbuf;
+ unsigned short old_ident;
+
+ old_ident = silc_command_get_ident(cmd->payload);
+ silc_command_set_ident(cmd->payload, silc_rng_get_rn16(server->rng));
+ tmpbuf = silc_command_payload_encode_payload(cmd->payload);
+
+ /* Send WHOIS command to our router */
+ silc_server_packet_send(server, (SilcSocketConnection)
+ server->router->connection,
+ SILC_PACKET_COMMAND, cmd->packet->flags,
+ tmpbuf->data, tmpbuf->len, TRUE);
+
+ /* Reprocess this packet after received reply from router */
+ silc_server_command_pending(server, SILC_COMMAND_WHOIS,
+ silc_command_get_ident(cmd->payload),
+ silc_server_command_whois, (void *)cmd);
+ cmd->pending = TRUE;
+
+ silc_command_set_ident(cmd->payload, old_ident);
+
+ silc_buffer_free(tmpbuf);
+ ret = -1;
+ goto out;
+ }
+
+ /* We are ready to process the command request. Let's search for the
+ requested client and send reply to the requesting client. */
+
+ /* Get all clients matching that ID or nickname from local list */
+ if (client_id) {
+ entry = silc_idlist_find_client_by_id(server->local_list, client_id, NULL);
+ if (entry) {
+ clients = silc_calloc(1, sizeof(*clients));
+ clients[0] = entry;
+ clients_count = 1;
+ }
+ } else {
+ clients = silc_idlist_get_clients_by_nickname(server->local_list,
+ nick, server_name,
+ &clients_count);
+ }
+
+ /* Check global list as well */
+ if (!clients) {
+ if (client_id) {
+ entry = silc_idlist_find_client_by_id(server->global_list,
+ client_id, NULL);
+ if (entry) {
+ clients = silc_calloc(1, sizeof(*clients));
+ clients[0] = entry;
+ clients_count = 1;
+ }
+ } else {
+ clients = silc_idlist_get_clients_by_nickname(server->global_list,
+ nick, server_name,
+ &clients_count);
+ }
+ }
+
+ if (!clients) {
+ /* Such a client really does not exist in the SILC network. */
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_WHOIS,
+ SILC_STATUS_ERR_NO_SUCH_NICK,
+ 3, nick, strlen(nick));
+ goto out;
+ }
+
+ /* Router always finds the client entry if it exists in the SILC network.
+ However, it might be incomplete entry and does not include all the
+ mandatory fields that WHOIS command reply requires. Check for these and
+ make query from the server who owns the client if some fields are
+ missing. */
+ if (server->server_type == SILC_ROUTER &&
+ !silc_server_command_whois_check(cmd, clients, clients_count)) {
+ ret = -1;
+ goto out;
+ }
+
+ /* Send the command reply to the client */
+ silc_server_command_whois_send_reply(cmd, clients, clients_count);
out:
- silc_server_command_free(cmd);
-}
+ if (clients)
+ silc_free(clients);
+ if (client_id)
+ silc_free(client_id);
+ if (nick)
+ silc_free(nick);
+ if (server_name)
+ silc_free(server_name);
-SILC_SERVER_CMD_FUNC(whowas)
-{
+ return ret;
}
-SILC_SERVER_CMD_FUNC(identify)
+static int
+silc_server_command_whois_from_server(SilcServerCommandContext cmd)
{
- SilcServerCommandContext cmd = (SilcServerCommandContext)context;
SilcServer server = cmd->server;
- char *tmp, *nick = NULL, *server_name = NULL;
- unsigned int argc, count = 0, len;
- int use_id = FALSE;
+ char *nick = NULL, *server_name = NULL;
+ int count = 0, clients_count;
SilcClientID *client_id = NULL;
- SilcClientEntry entry;
- SilcBuffer packet, idp;
-
- SILC_LOG_DEBUG(("Start"));
+ SilcClientEntry *clients = NULL, entry;
+ int ret = 0;
+
+ /* Parse the whois request */
+ if (!silc_server_command_whois_parse(cmd, &client_id, &nick,
+ &server_name, &count))
+ return 0;
+
+ /* Process the command request. Let's search for the requested client and
+ send reply to the requesting server. */
+
+ if (client_id) {
+ entry = silc_idlist_find_client_by_id(server->local_list, client_id, NULL);
+ if (entry) {
+ clients = silc_calloc(1, sizeof(*clients));
+ clients[0] = entry;
+ clients_count = 1;
+ }
+ } else {
+ clients = silc_idlist_get_clients_by_nickname(server->local_list,
+ nick, server_name,
+ &clients_count);
+ if (!clients)
+ clients = silc_idlist_get_clients_by_hash(server->local_list,
+ nick, server->md5hash,
+ &clients_count);
+ }
+
+ /* If we are router we will check our global list as well. */
+ if (!clients && server->server_type == SILC_ROUTER) {
+ if (client_id) {
+ entry = silc_idlist_find_client_by_id(server->global_list,
+ client_id, NULL);
+ if (entry) {
+ clients = silc_calloc(1, sizeof(*clients));
+ clients[0] = entry;
+ clients_count = 1;
+ }
+ } else {
+ clients = silc_idlist_get_clients_by_nickname(server->global_list,
+ nick, server_name,
+ &clients_count);
+ if (!clients)
+ clients = silc_idlist_get_clients_by_hash(server->global_list,
+ nick, server->md5hash,
+ &clients_count);
+ }
+ }
- argc = silc_argument_get_arg_num(cmd->args);
- if (argc < 1) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_IDENTIFY,
- SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
+ if (!clients) {
+ /* Such a client really does not exist in the SILC network. */
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_WHOIS,
+ SILC_STATUS_ERR_NO_SUCH_NICK,
+ 3, nick, strlen(nick));
goto out;
}
- if (argc > 3) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_IDENTIFY,
- SILC_STATUS_ERR_TOO_MANY_PARAMS);
+
+ /* Router always finds the client entry if it exists in the SILC network.
+ However, it might be incomplete entry and does not include all the
+ mandatory fields that WHOIS command reply requires. Check for these and
+ make query from the server who owns the client if some fields are
+ missing. */
+ if (server->server_type == SILC_ROUTER &&
+ !silc_server_command_whois_check(cmd, clients, clients_count)) {
+ ret = -1;
goto out;
}
+ /* Send the command reply to the client */
+ silc_server_command_whois_send_reply(cmd, clients, clients_count);
+
+ out:
+ if (clients)
+ silc_free(clients);
+ if (client_id)
+ silc_free(client_id);
+ if (nick)
+ silc_free(nick);
+ if (server_name)
+ silc_free(server_name);
+
+ return ret;
+}
+
+/* Server side of command WHOIS. Processes user's query and sends found
+ results as command replies back to the client. */
+
+SILC_SERVER_CMD_FUNC(whois)
+{
+ SilcServerCommandContext cmd = (SilcServerCommandContext)context;
+ int ret;
+
+ SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_WHOIS, cmd, 1, 3);
+
+ if (cmd->sock->type == SILC_SOCKET_TYPE_CLIENT)
+ ret = silc_server_command_whois_from_client(cmd);
+ else
+ ret = silc_server_command_whois_from_server(cmd);
+
+ if (!ret)
+ silc_server_command_free(cmd);
+}
+
+SILC_SERVER_CMD_FUNC(whowas)
+{
+}
+
+/******************************************************************************
+
+ IDENTIFY Functions
+
+******************************************************************************/
+
+static int
+silc_server_command_identify_parse(SilcServerCommandContext cmd,
+ SilcClientID **client_id,
+ char **nickname,
+ char **server_name,
+ int *count)
+{
+ unsigned char *tmp;
+ unsigned int len;
+ unsigned int argc = silc_argument_get_arg_num(cmd->args);
+
/* If client ID is in the command it must be used instead of nickname */
tmp = silc_argument_get_arg_type(cmd->args, 2, &len);
if (!tmp) {
-
- /* Get the nickname@server string and parse it. */
+ /* No ID, get the nickname@server string and parse it. */
tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
if (tmp) {
if (strchr(tmp, '@')) {
len = strcspn(tmp, "@");
- nick = silc_calloc(len + 1, sizeof(char));
- memcpy(nick, tmp, len);
- server_name = silc_calloc(strlen(tmp) - len, sizeof(char));
- memcpy(server_name, tmp + len + 1, strlen(tmp) - len - 1);
+ *nickname = silc_calloc(len + 1, sizeof(char));
+ memcpy(*nickname, tmp, len);
+ *server_name = silc_calloc(strlen(tmp) - len, sizeof(char));
+ memcpy(*server_name, tmp + len + 1, strlen(tmp) - len - 1);
} else {
- nick = strdup(tmp);
+ *nickname = strdup(tmp);
}
} else {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_IDENTIFY,
SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- goto out;
+ return FALSE;
}
} else {
/* Command includes ID, use that */
- client_id = silc_id_payload_parse_id(tmp, len);
- use_id = TRUE;
+ *client_id = silc_id_payload_parse_id(tmp, len);
}
/* Get the max count of reply messages allowed */
if (!tmp) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_IDENTIFY,
SILC_STATUS_ERR_TOO_MANY_PARAMS);
- goto out;
+ if (*nickname)
+ silc_free(*nickname);
+ if (*server_name)
+ silc_free(*server_name);
+
+ return FALSE;
}
- count = atoi(tmp);
+ *count = atoi(tmp);
}
- /* Find client */
- if (!use_id) {
- entry = silc_idlist_find_client_by_nickname(server->local_list,
- nick, NULL);
- if (!entry)
- entry = silc_idlist_find_client_by_hash(server->global_list,
- nick, server->md5hash);
- } else {
- entry = silc_idlist_find_client_by_id(server->local_list, client_id);
+ return TRUE;
+}
+
+/* Checks that all mandatory fields are present. If not then send WHOIS
+ request to the server who owns the client. We use WHOIS because we want
+ to get as much information as possible at once. */
+
+static char
+silc_server_command_identify_check(SilcServerCommandContext cmd,
+ SilcClientEntry *clients,
+ unsigned int clients_count)
+{
+ SilcServer server = cmd->server;
+ int i;
+ SilcClientEntry entry;
+
+ for (i = 0; i < clients_count; i++) {
+ entry = clients[i];
+
+ if (!entry->nickname) {
+ SilcBuffer tmpbuf;
+ unsigned short old_ident;
+
+ old_ident = silc_command_get_ident(cmd->payload);
+ silc_command_set_ident(cmd->payload, silc_rng_get_rn16(server->rng));
+ silc_command_set_command(cmd->payload, SILC_COMMAND_WHOIS);
+ tmpbuf = silc_command_payload_encode_payload(cmd->payload);
+
+ /* Send WHOIS request. We send WHOIS since we're doing the requesting
+ now anyway so make it a good one. */
+ silc_server_packet_send(server, entry->router->connection,
+ SILC_PACKET_COMMAND, cmd->packet->flags,
+ tmpbuf->data, tmpbuf->len, TRUE);
+
+ /* Reprocess this packet after received reply */
+ silc_server_command_pending(server, SILC_COMMAND_WHOIS,
+ silc_command_get_ident(cmd->payload),
+ silc_server_command_identify, (void *)cmd);
+ cmd->pending = TRUE;
+
+ /* Put old data back to the Command Payload we just changed */
+ silc_command_set_ident(cmd->payload, old_ident);
+ silc_command_set_command(cmd->payload, SILC_COMMAND_IDENTIFY);
+
+ silc_buffer_free(tmpbuf);
+ return FALSE;
+ }
}
- /* If client was not found and if we are normal server and are connected
- to a router we will make global query from the router. */
- if (!entry && server->server_type == SILC_SERVER && !server->standalone &&
- !cmd->pending) {
- SilcBuffer buffer = cmd->packet->buffer;
-
- SILC_LOG_DEBUG(("Requesting identify from router"));
+ return TRUE;
+}
+
+static void
+silc_server_command_identify_send_reply(SilcServerCommandContext cmd,
+ SilcClientEntry *clients,
+ unsigned int clients_count)
+{
+ SilcServer server = cmd->server;
+ char *tmp;
+ int i, count = 0, len;
+ SilcBuffer packet, idp;
+ SilcClientEntry entry;
+ SilcCommandStatus status;
+ unsigned short ident = silc_command_get_ident(cmd->payload);
+
+ status = SILC_STATUS_OK;
+ if (clients_count > 1)
+ status = SILC_STATUS_LIST_START;
+
+ for (i = 0; i < clients_count; i++) {
+ entry = clients[i];
+
+ if (count && i - 1 == count)
+ break;
+
+ if (clients_count > 2)
+ status = SILC_STATUS_LIST_ITEM;
+
+ if (clients_count > 1 && i == clients_count - 1)
+ status = SILC_STATUS_LIST_END;
+
+ /* Send IDENTIFY reply */
+ idp = silc_id_payload_encode(entry->id, SILC_ID_CLIENT);
+ tmp = silc_argument_get_first_arg(cmd->args, NULL);
+ /* XXX */
+ {
+ char nh[256], uh[256];
+ SilcSocketConnection hsock;
+
+ memset(uh, 0, sizeof(uh));
+ memset(nh, 0, sizeof(nh));
+
+ strncat(nh, entry->nickname, strlen(entry->nickname));
+ if (!strchr(entry->nickname, '@')) {
+ strncat(nh, "@", 1);
+ len = entry->router ? strlen(entry->router->server_name) :
+ strlen(server->server_name);
+ strncat(nh, entry->router ? entry->router->server_name :
+ server->server_name, len);
+ }
+
+ if (!entry->username) {
+ packet = silc_command_reply_payload_encode_va(SILC_COMMAND_IDENTIFY,
+ SILC_STATUS_OK, ident, 2,
+ 2, idp->data, idp->len,
+ 3, nh, strlen(nh));
+ } else {
+ strncat(uh, entry->username, strlen(entry->username));
+ if (!strchr(entry->username, '@')) {
+ strncat(uh, "@", 1);
+ hsock = (SilcSocketConnection)entry->connection;
+ len = strlen(hsock->hostname);
+ strncat(uh, hsock->hostname, len);
+ }
+
+ packet = silc_command_reply_payload_encode_va(SILC_COMMAND_IDENTIFY,
+ SILC_STATUS_OK, ident, 3,
+ 2, idp->data, idp->len,
+ 3, nh, strlen(nh),
+ 4, uh, strlen(uh));
+ }
+
+ silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY,
+ 0, packet->data, packet->len, FALSE);
+
+ silc_buffer_free(packet);
+ silc_buffer_free(idp);
+ }
+ }
+}
+
+static int
+silc_server_command_identify_from_client(SilcServerCommandContext cmd)
+{
+ SilcServer server = cmd->server;
+ char *nick = NULL, *server_name = NULL;
+ int count = 0, clients_count;
+ SilcClientID *client_id = NULL;
+ SilcClientEntry *clients = NULL, entry;
+ int ret = 0;
+
+ /* Parse the IDENTIFY request */
+ if (!silc_server_command_identify_parse(cmd, &client_id, &nick,
+ &server_name, &count))
+ return 0;
+
+ /* Protocol dictates that we must always send the received IDENTIFY request
+ to our router if we are normal server, so let's do it now unless we
+ are standalone. We will not send any replies to the client until we
+ have received reply from the router. */
+ if (server->server_type == SILC_SERVER &&
+ !cmd->pending && !server->standalone) {
+ SilcBuffer tmpbuf;
+ unsigned short old_ident;
+
+ old_ident = silc_command_get_ident(cmd->payload);
+ silc_command_set_ident(cmd->payload, silc_rng_get_rn16(server->rng));
+ tmpbuf = silc_command_payload_encode_payload(cmd->payload);
+
/* Send IDENTIFY command to our router */
- silc_buffer_push(buffer, buffer->data - buffer->head);
- silc_server_packet_forward(server, (SilcSocketConnection)
- server->router->connection,
- buffer->data, buffer->len, TRUE);
- return;
+ silc_server_packet_send(server, (SilcSocketConnection)
+ server->router->connection,
+ SILC_PACKET_COMMAND, cmd->packet->flags,
+ tmpbuf->data, tmpbuf->len, TRUE);
+
+ /* Reprocess this packet after received reply from router */
+ silc_server_command_pending(server, SILC_COMMAND_IDENTIFY,
+ silc_command_get_ident(cmd->payload),
+ silc_server_command_identify, (void *)cmd);
+ cmd->pending = TRUE;
+
+ silc_command_set_ident(cmd->payload, old_ident);
+
+ silc_buffer_free(tmpbuf);
+ ret = -1;
+ goto out;
}
- /* If we are router we have checked our local list by nickname and our
- global list by hash so far. It is possible that the client is still not
- found and we'll check it from local list by hash. */
- if (!entry && server->server_type == SILC_ROUTER)
- entry = silc_idlist_find_client_by_hash(server->local_list,
- nick, server->md5hash);
+ /* We are ready to process the command request. Let's search for the
+ requested client and send reply to the requesting client. */
- if (!entry) {
- /* The client definitely does not exist */
+ /* Get all clients matching that ID or nickname from local list */
+ if (client_id) {
+ entry = silc_idlist_find_client_by_id(server->local_list, client_id, NULL);
+ if (entry) {
+ clients = silc_calloc(1, sizeof(*clients));
+ clients[0] = entry;
+ clients_count = 1;
+ }
+ } else {
+ clients = silc_idlist_get_clients_by_nickname(server->local_list,
+ nick, server_name,
+ &clients_count);
+ }
+
+ /* Check global list as well */
+ if (!clients) {
+ if (client_id) {
+ entry = silc_idlist_find_client_by_id(server->global_list,
+ client_id, NULL);
+ if (entry) {
+ clients = silc_calloc(1, sizeof(*clients));
+ clients[0] = entry;
+ clients_count = 1;
+ }
+ } else {
+ clients = silc_idlist_get_clients_by_nickname(server->global_list,
+ nick, server_name,
+ &clients_count);
+ }
+ }
+
+ if (!clients) {
+ /* Such a client really does not exist in the SILC network. */
silc_server_command_send_status_data(cmd, SILC_COMMAND_IDENTIFY,
SILC_STATUS_ERR_NO_SUCH_NICK,
- 3, tmp, strlen(tmp));
+ 3, nick, strlen(nick));
goto out;
}
- /* Send IDENTIFY reply */
- idp = silc_id_payload_encode(entry->id, SILC_ID_CLIENT);
- tmp = silc_argument_get_first_arg(cmd->args, NULL);
- packet = silc_command_reply_payload_encode_va(SILC_COMMAND_IDENTIFY,
- SILC_STATUS_OK, 0, 2,
- 2, idp->data, idp->len,
- 3, nick, strlen(nick));
- if (cmd->packet->flags & SILC_PACKET_FLAG_FORWARDED) {
- void *id = silc_id_str2id(cmd->packet->src_id, cmd->packet->src_id_type);
- silc_server_packet_send_dest(server, cmd->sock,
- SILC_PACKET_COMMAND_REPLY, 0,
- id, cmd->packet->src_id_type,
- packet->data, packet->len, FALSE);
- silc_free(id);
- } else {
- silc_server_packet_send(server, cmd->sock,
- SILC_PACKET_COMMAND_REPLY, 0,
- packet->data, packet->len, FALSE);
+ /* Check that all mandatory fields are present and request those data
+ from the server who owns the client if necessary. */
+ if (!cmd->pending && server->server_type == SILC_ROUTER &&
+ !silc_server_command_identify_check(cmd, clients, clients_count)) {
+ ret = -1;
+ goto out;
}
- silc_buffer_free(packet);
- silc_buffer_free(idp);
+ /* Send the command reply to the client */
+ silc_server_command_identify_send_reply(cmd, clients, clients_count);
+
+ out:
+ if (clients)
+ silc_free(clients);
if (client_id)
silc_free(client_id);
+ if (nick)
+ silc_free(nick);
+ if (server_name)
+ silc_free(server_name);
+
+ return ret;
+}
+
+static int
+silc_server_command_identify_from_server(SilcServerCommandContext cmd)
+{
+ SilcServer server = cmd->server;
+ char *nick = NULL, *server_name = NULL;
+ int count = 0, clients_count;
+ SilcClientID *client_id = NULL;
+ SilcClientEntry *clients = NULL, entry;
+ int ret = 0;
+
+ /* Parse the IDENTIFY request */
+ if (!silc_server_command_identify_parse(cmd, &client_id, &nick,
+ &server_name, &count))
+ return 0;
+
+ /* Process the command request. Let's search for the requested client and
+ send reply to the requesting server. */
+
+ if (client_id) {
+ entry = silc_idlist_find_client_by_id(server->local_list, client_id, NULL);
+ if (entry) {
+ clients = silc_calloc(1, sizeof(*clients));
+ clients[0] = entry;
+ clients_count = 1;
+ }
+ } else {
+ clients = silc_idlist_get_clients_by_nickname(server->local_list,
+ nick, server_name,
+ &clients_count);
+ if (!clients)
+ clients = silc_idlist_get_clients_by_hash(server->local_list,
+ nick, server->md5hash,
+ &clients_count);
+ }
+
+ /* If we are router we will check our global list as well. */
+ if (!clients && server->server_type == SILC_ROUTER) {
+ if (client_id) {
+ entry = silc_idlist_find_client_by_id(server->global_list,
+ client_id, NULL);
+ if (entry) {
+ clients = silc_calloc(1, sizeof(*clients));
+ clients[0] = entry;
+ clients_count = 1;
+ }
+ } else {
+ clients = silc_idlist_get_clients_by_nickname(server->global_list,
+ nick, server_name,
+ &clients_count);
+ if (!clients)
+ clients = silc_idlist_get_clients_by_hash(server->global_list,
+ nick, server->md5hash,
+ &clients_count);
+ }
+ }
+
+ if (!clients) {
+ /* Such a client really does not exist in the SILC network. */
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_IDENTIFY,
+ SILC_STATUS_ERR_NO_SUCH_NICK,
+ 3, nick, strlen(nick));
+ goto out;
+ }
+
+ /* Check that all mandatory fields are present and request those data
+ from the server who owns the client if necessary. */
+ if (!cmd->pending && server->server_type == SILC_ROUTER &&
+ !silc_server_command_identify_check(cmd, clients, clients_count)) {
+ ret = -1;
+ goto out;
+ }
+
+ /* Send the command reply */
+ silc_server_command_identify_send_reply(cmd, clients, clients_count);
out:
+ if (clients)
+ silc_free(clients);
+ if (client_id)
+ silc_free(client_id);
if (nick)
silc_free(nick);
if (server_name)
silc_free(server_name);
- silc_server_command_free(cmd);
+
+ return ret;
+}
+
+SILC_SERVER_CMD_FUNC(identify)
+{
+ SilcServerCommandContext cmd = (SilcServerCommandContext)context;
+ int ret;
+
+ SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_IDENTIFY, cmd, 1, 3);
+
+ if (cmd->sock->type == SILC_SOCKET_TYPE_CLIENT)
+ ret = silc_server_command_identify_from_client(cmd);
+ else
+ ret = silc_server_command_identify_from_server(cmd);
+
+ if (!ret)
+ silc_server_command_free(cmd);
}
/* Checks string for bad characters and returns TRUE if they are found. */
SilcClientID *new_id;
char *nick;
- SILC_LOG_DEBUG(("Start"));
-
- /* Check number of arguments */
- if (silc_argument_get_arg_num(cmd->args) < 1) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_NICK,
- SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- goto out;
- }
+ SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_NICK, cmd, 1, 1);
/* Check nickname */
nick = silc_argument_get_arg_type(cmd->args, 1, NULL);
unsigned char *tmp;
unsigned int argc, tmp_len;
- /* Check number of arguments */
+ SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_TOPIC, cmd, 1, 2);
+
argc = silc_argument_get_arg_num(cmd->args);
- if (argc < 1) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_TOPIC,
- SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- goto out;
- }
- if (argc > 2) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_TOPIC,
- SILC_STATUS_ERR_TOO_MANY_PARAMS);
- goto out;
- }
/* Get Channel ID */
tmp = silc_argument_get_arg_type(cmd->args, 1, &tmp_len);
channel_id = silc_id_payload_parse_id(tmp, tmp_len);
/* Check whether the channel exists */
- channel = silc_idlist_find_channel_by_id(server->local_list, channel_id);
+ channel = silc_idlist_find_channel_by_id(server->local_list,
+ channel_id, NULL);
if (!channel) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_TOPIC,
SILC_STATUS_ERR_NO_SUCH_CHANNEL);
SilcChannelID *channel_id;
SilcBuffer sidp;
unsigned char *tmp;
- unsigned int argc, len;
+ unsigned int len;
- /* Check number of arguments */
- argc = silc_argument_get_arg_num(cmd->args);
- if (argc < 1) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_INVITE,
- SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- goto out;
- }
- if (argc > 2) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_INVITE,
- SILC_STATUS_ERR_TOO_MANY_PARAMS);
- goto out;
- }
+ SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_INVITE, cmd, 1, 2);
/* Get destination ID */
tmp = silc_argument_get_arg_type(cmd->args, 1, &len);
channel_id = silc_id_payload_parse_id(tmp, len);
/* Check whether the channel exists */
- channel = silc_idlist_find_channel_by_id(server->local_list, channel_id);
+ channel = silc_idlist_find_channel_by_id(server->local_list,
+ channel_id, NULL);
if (!channel) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_INVITE,
SILC_STATUS_ERR_NO_SUCH_CHANNEL);
if (chl->client == sender) {
if (chl->mode == SILC_CHANNEL_UMODE_NONE) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_INVITE,
- SILC_STATUS_ERR_NO_CHANNEL_PRIV);
+ SILC_STATUS_ERR_NO_CHANNEL_PRIV);
goto out;
}
break;
/* Find the connection data for the destination. If it is local we will
send it directly otherwise we will send it to router for routing. */
- dest = silc_idlist_find_client_by_id(server->local_list, dest_id);
+ dest = silc_idlist_find_client_by_id(server->local_list, dest_id, NULL);
if (dest)
dest_sock = (SilcSocketConnection)dest->connection;
else
- dest_sock = silc_server_get_route(server, dest_id, SILC_ID_CLIENT);
+ dest_sock = silc_server_route_get(server, dest_id, SILC_ID_CLIENT);
/* Check whether the requested client is already on the channel. */
/* XXX if we are normal server we don't know about global clients on
SilcServerCommandContext cmd = (SilcServerCommandContext)context;
SilcServer server = cmd->server;
SilcBuffer packet, idp;
- unsigned int argc;
char info_string[256], *dest_server;
- argc = silc_argument_get_arg_num(cmd->args);
- if (argc < 1) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_INFO,
- SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- goto out;
- }
- if (argc > 1) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_INFO,
- SILC_STATUS_ERR_TOO_MANY_PARAMS);
- goto out;
- }
+ SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_INFO, cmd, 1, 1);
/* Get server name */
dest_server = silc_argument_get_arg_type(cmd->args, 1, NULL);
SilcServerCommandContext cmd = (SilcServerCommandContext)context;
SilcServer server = cmd->server;
SilcServerID *id;
- unsigned int argc, len;
+ unsigned int len;
unsigned char *tmp;
- argc = silc_argument_get_arg_num(cmd->args);
- if (argc < 1) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_PING,
- SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- goto out;
- }
- if (argc > 2) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_PING,
- SILC_STATUS_ERR_TOO_MANY_PARAMS);
- goto out;
- }
+ SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_INFO, cmd, 1, 2);
/* Get Server ID */
tmp = silc_argument_get_arg_type(cmd->args, 1, &len);
client = (SilcClientEntry)cmd->sock->user_data;
/* Get channel entry */
- channel = silc_idlist_find_channel_by_name(server->local_list, channel_name);
+ channel = silc_idlist_find_channel_by_name(server->local_list,
+ channel_name, NULL);
if (channel) {
/* Join the client to the channel by adding it to channel's user list.
Add also the channel to client entry's channels list for fast cross-
SilcChannelClientEntry chl;
SilcBuffer reply, chidp, clidp;
+ SILC_LOG_DEBUG(("Start"));
+
if (!channel)
return;
real easy. */
if (cmd->packet->flags & SILC_PACKET_FLAG_FORWARDED) {
void *id = silc_id_str2id(cmd->packet->src_id, cmd->packet->src_id_type);
- client = silc_idlist_find_client_by_id(server->local_list, id);
+ client = silc_idlist_find_client_by_id(server->local_list, id, NULL);
if (!client) {
/* XXX */
SILC_LOG_ERROR(("Forwarded join command did not find the client who "
{
SilcServerCommandContext cmd = (SilcServerCommandContext)context;
SilcServer server = cmd->server;
- int argc, tmp_len;
+ int tmp_len;
char *tmp, *channel_name = NULL, *cipher = NULL;
SilcChannelEntry channel;
unsigned int umode = 0;
int created = FALSE;
- SILC_LOG_DEBUG(("Start"));
-
- /* Check number of parameters */
- argc = silc_argument_get_arg_num(cmd->args);
- if (argc < 1) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_JOIN,
- SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- goto out;
- }
- if (argc > 3) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_JOIN,
- SILC_STATUS_ERR_TOO_MANY_PARAMS);
- goto out;
- }
+ SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_JOIN, cmd, 1, 3);
/* Get channel name */
tmp = silc_argument_get_arg_type(cmd->args, 1, &tmp_len);
cipher = silc_argument_get_arg_type(cmd->args, 3, NULL);
/* See if the channel exists */
- channel = silc_idlist_find_channel_by_name(server->local_list, channel_name);
+ channel = silc_idlist_find_channel_by_name(server->local_list,
+ channel_name, NULL);
if (!channel) {
/* Channel not found */
/* We are router and the channel does not seem exist so we will check
our global list as well for the channel. */
channel = silc_idlist_find_channel_by_name(server->global_list,
- channel_name);
+ channel_name, NULL);
if (!channel) {
/* Channel really does not exist, create it */
channel = silc_server_create_new_channel(server, server->id, cipher,
{
SilcServerCommandContext cmd = (SilcServerCommandContext)context;
SilcServer server = cmd->server;
- unsigned int argc;
char *motd;
int motd_len;
- SILC_LOG_DEBUG(("Start"));
-
- argc = silc_argument_get_arg_num(cmd->args);
- if (argc < 1) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_LEAVE,
- SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- goto out;
- }
- if (argc > 2) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_LEAVE,
- SILC_STATUS_ERR_TOO_MANY_PARAMS);
- goto out;
- }
+ SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_MOTD, cmd, 1, 2);
/* XXX show currently only our motd */
SILC_GET32_MSB(mode_mask, tmp_mask);
/* Get channel entry */
- channel = silc_idlist_find_channel_by_id(server->local_list, channel_id);
+ channel = silc_idlist_find_channel_by_id(server->local_list,
+ channel_id, NULL);
if (!channel) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_CMODE,
SILC_STATUS_ERR_NO_SUCH_CHANNEL);
SilcChannelClientEntry chl;
SilcBuffer packet, idp;
unsigned char *tmp_id, *tmp_mask;
- unsigned int argc, target_mask, sender_mask, tmp_len;
+ unsigned int target_mask, sender_mask, tmp_len;
int notify = FALSE;
- SILC_LOG_DEBUG(("Start"));
-
- argc = silc_argument_get_arg_num(cmd->args);
- if (argc < 3) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_CUMODE,
- SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- goto out;
- }
- if (argc > 3) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_CUMODE,
- SILC_STATUS_ERR_TOO_MANY_PARAMS);
- goto out;
- }
+ SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_CUMODE, cmd, 3, 3);
/* Get Channel ID */
tmp_id = silc_argument_get_arg_type(cmd->args, 1, &tmp_len);
channel_id = silc_id_payload_parse_id(tmp_id, tmp_len);
/* Get channel entry */
- channel = silc_idlist_find_channel_by_id(server->local_list, channel_id);
+ channel = silc_idlist_find_channel_by_id(server->local_list,
+ channel_id, NULL);
if (!channel) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_CUMODE,
SILC_STATUS_ERR_NO_SUCH_CHANNEL);
client_id = silc_id_payload_parse_id(tmp_id, tmp_len);
/* Get target client's entry */
- target_client = silc_idlist_find_client_by_id(server->local_list, client_id);
+ target_client = silc_idlist_find_client_by_id(server->local_list,
+ client_id, NULL);
if (!target_client) {
/* XXX If target client is not one of mine send to primary route */
}
SilcChannelID *id;
SilcChannelEntry channel;
SilcBuffer packet;
- unsigned int i, argc, len;
+ unsigned int i, len;
unsigned char *tmp;
- SILC_LOG_DEBUG(("Start"));
-
- argc = silc_argument_get_arg_num(cmd->args);
- if (argc < 1) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_LEAVE,
- SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- goto out;
- }
- if (argc > 2) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_LEAVE,
- SILC_STATUS_ERR_TOO_MANY_PARAMS);
- goto out;
- }
+ SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_LEAVE, cmd, 1, 2);
/* Get Channel ID */
tmp = silc_argument_get_arg_type(cmd->args, 1, &len);
id = silc_id_payload_parse_id(tmp, len);
/* Get channel entry */
- channel = silc_idlist_find_channel_by_id(server->local_list, id);
+ channel = silc_idlist_find_channel_by_id(server->local_list, id, NULL);
if (!channel) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_LEAVE,
SILC_STATUS_ERR_NO_SUCH_CHANNEL);
SilcChannelClientEntry chl;
SilcChannelID *id;
SilcBuffer packet;
- unsigned int i, len, len2, tmp_len, argc;
+ unsigned int i, len, len2, tmp_len;
unsigned char *tmp;
char *name_list = NULL, *n;
SilcBuffer client_id_list;
SilcBuffer client_mode_list;
- SILC_LOG_DEBUG(("Start"));
-
- argc = silc_argument_get_arg_num(cmd->args);
- if (argc < 1) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_NAMES,
- SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
- goto out;
- }
- if (argc > 2) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_NAMES,
- SILC_STATUS_ERR_TOO_MANY_PARAMS);
- goto out;
- }
+ SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_NAMES, cmd, 1, 2);
/* Get Channel ID */
tmp = silc_argument_get_arg_type(cmd->args, 1, &tmp_len);
/* Check whether the channel exists. If we are normal server and the
channel does not exist we will send this same command to our router
which will know if the channel exists. */
- channel = silc_idlist_find_channel_by_id(server->local_list, id);
+ channel = silc_idlist_find_channel_by_id(server->local_list, id, NULL);
if (!channel) {
if (server->server_type == SILC_SERVER && !server->standalone) {
/* XXX Send names command */
projects / silc.git / blobdiff