Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
- Copyright (C) 1997 - 2000 Pekka Riikonen
+ Copyright (C) 1997 - 2001 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
unsigned int arg_type,
unsigned char *arg,
unsigned int arg_len);
-static void silc_server_command_free(SilcServerCommandContext cmd);
void silc_server_command_send_users(SilcServer server,
SilcSocketConnection sock,
SilcChannelEntry channel,
/* Allocate command context. This must be free'd by the
command routine receiving it. */
- ctx = silc_calloc(1, sizeof(*ctx));
+ ctx = silc_server_command_alloc();
ctx->server = server;
- ctx->sock = sock;
+ ctx->sock = silc_socket_dup(sock);
ctx->packet = silc_packet_context_dup(packet); /* Save original packet */
/* Parse the command payload in the packet */
SILC_LOG_ERROR(("Bad command payload, packet dropped"));
silc_buffer_free(packet->buffer);
silc_packet_context_free(packet);
+ silc_socket_free(ctx->sock);
silc_free(ctx);
return;
}
}
}
+/* Allocate Command Context */
+
+SilcServerCommandContext silc_server_command_alloc()
+{
+ SilcServerCommandContext ctx = silc_calloc(1, sizeof(*ctx));
+ ctx->users++;
+ return ctx;
+}
+
+/* Free's the command context allocated before executing the command */
+
+void silc_server_command_free(SilcServerCommandContext ctx)
+{
+ ctx->users--;
+ SILC_LOG_DEBUG(("Command context %p refcnt %d->%d", ctx, ctx->users + 1,
+ ctx->users));
+ if (ctx->users < 1) {
+ if (ctx->payload)
+ silc_command_free_payload(ctx->payload);
+ if (ctx->packet)
+ silc_packet_context_free(ctx->packet);
+ if (ctx->sock)
+ silc_socket_free(ctx->sock); /* Decrease reference counter */
+ silc_free(ctx);
+ }
+}
+
+/* Duplicate Command Context by adding reference counter. The context won't
+ be free'd untill it hits zero. */
+
+SilcServerCommandContext
+silc_server_command_dup(SilcServerCommandContext ctx)
+{
+ ctx->users++;
+ SILC_LOG_DEBUG(("Command context %p refcnt %d->%d", ctx, ctx->users - 1,
+ ctx->users));
+ return ctx;
+}
+
/* Add new pending command to be executed when reply to a command has been
received. The `reply_cmd' is the command that will call the `callback'
with `context' when reply has been received. If `ident' is non-zero
void silc_server_command_pending(SilcServer server,
SilcCommand reply_cmd,
unsigned short ident,
+ SilcServerPendingDestructor destructor,
SilcCommandCb callback,
void *context)
{
reply->ident = ident;
reply->context = context;
reply->callback = callback;
+ reply->destructor = destructor;
silc_dlist_add(server->pending_commands, reply);
}
if (r->reply_cmd == command && r->ident == ident) {
ctx->context = r->context;
ctx->callback = r->callback;
+ ctx->destructor = r->destructor;
ctx->ident = ident;
return TRUE;
}
return FALSE;
}
-/* Free's the command context allocated before executing the command */
+/* Destructor function for pending callbacks. This is called when using
+ pending commands to free the context given for the pending command. */
-static void silc_server_command_free(SilcServerCommandContext cmd)
+static void silc_server_command_destructor(void *context)
{
- if (cmd) {
- if (cmd->payload)
- silc_command_free_payload(cmd->payload);
- if (cmd->packet)
- silc_packet_context_free(cmd->packet);
- silc_free(cmd);
- }
+ silc_server_command_free((SilcServerCommandContext)context);
}
/* Sends simple status message as command reply packet */
*client_id = silc_calloc(1, sizeof(**client_id));
(*client_id)[0] = silc_id_payload_parse_id(tmp, len);
+ if ((*client_id)[0] == NULL) {
+ silc_free(*client_id);
+ return FALSE;
+ }
*client_id_count = 1;
/* Take all ID's from the command packet */
if (argc > 3) {
- for (k = 1, i = 4; i < argc; i++) {
+ for (k = 1, i = 4; i < argc + 1; i++) {
tmp = silc_argument_get_arg_type(cmd->args, i, &len);
if (tmp) {
*client_id = silc_realloc(*client_id, sizeof(**client_id) *
(*client_id_count + 1));
- (*client_id)[k++] = silc_id_payload_parse_id(tmp, len);
+ (*client_id)[k] = silc_id_payload_parse_id(tmp, len);
+ if ((*client_id)[k] == NULL) {
+ /* Cleanup all and fail */
+ for (i = 0; i < *client_id_count; i++)
+ silc_free((*client_id)[i]);
+ silc_free(*client_id);
+ return FALSE;
+ }
(*client_id_count)++;
+ k++;
}
}
}
for (i = 0; i < clients_count; i++) {
entry = clients[i];
- if (!entry->nickname || !entry->username || !entry->userinfo) {
+ if (!entry->nickname || !entry->username) {
SilcBuffer tmpbuf;
unsigned short old_ident;
/* 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);
+ silc_server_command_destructor,
+ silc_server_command_whois,
+ silc_server_command_dup(cmd));
cmd->pending = TRUE;
silc_command_set_ident(cmd->payload, old_ident);
if (clients_count > 1 && i == clients_count - 1)
status = SILC_STATUS_LIST_END;
+ /* Sanity check, however these should never fail. However, as
+ this sanity check has been added here they have failed. */
+ if (!entry->nickname || !entry->username)
+ continue;
+
/* Send WHOIS reply */
idp = silc_id_payload_encode(entry->id, SILC_ID_CLIENT);
tmp = silc_argument_get_first_arg(cmd->args, NULL);
memset(uh, 0, sizeof(uh));
memset(nh, 0, sizeof(nh));
-
+
strncat(nh, entry->nickname, strlen(entry->nickname));
if (!strchr(entry->nickname, '@')) {
strncat(nh, "@", 1);
/* 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);
+ silc_server_command_destructor,
+ silc_server_command_whois,
+ silc_server_command_dup(cmd));
cmd->pending = TRUE;
silc_command_set_ident(cmd->payload, old_ident);
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)) {
+ if (!silc_server_command_whois_check(cmd, clients, clients_count)) {
ret = -1;
goto out;
}
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)) {
+ if (!silc_server_command_whois_check(cmd, clients, clients_count)) {
ret = -1;
goto out;
}
SILC_SERVER_CMD_FUNC(whois)
{
SilcServerCommandContext cmd = (SilcServerCommandContext)context;
- int ret;
+ int ret = 0;
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_WHOIS, cmd, 1, 3);
+ SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_WHOIS, cmd, 1, 3328);
if (cmd->sock->type == SILC_SOCKET_TYPE_CLIENT)
ret = silc_server_command_whois_from_client(cmd);
- else
+ else if ((cmd->sock->type == SILC_SOCKET_TYPE_SERVER) ||
+ (cmd->sock->type == SILC_SOCKET_TYPE_ROUTER))
ret = silc_server_command_whois_from_server(cmd);
if (!ret)
/* 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);
+ silc_server_command_destructor,
+ silc_server_command_identify,
+ silc_server_command_dup(cmd));
+
cmd->pending = TRUE;
/* Put old data back to the Command Payload we just changed */
/* 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);
+ silc_server_command_destructor,
+ silc_server_command_identify,
+ silc_server_command_dup(cmd));
cmd->pending = TRUE;
silc_command_set_ident(cmd->payload, old_ident);
/* 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)) {
+ if (!silc_server_command_identify_check(cmd, clients, clients_count)) {
ret = -1;
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)) {
+ if (!silc_server_command_identify_check(cmd, clients, clients_count)) {
ret = -1;
goto out;
}
SILC_SERVER_CMD_FUNC(identify)
{
SilcServerCommandContext cmd = (SilcServerCommandContext)context;
- int ret;
+ int ret = 0;
- SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_IDENTIFY, cmd, 1, 3);
+ SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_IDENTIFY, cmd, 1, 3328);
if (cmd->sock->type == SILC_SOCKET_TYPE_CLIENT)
ret = silc_server_command_identify_from_client(cmd);
- else
+ else if ((cmd->sock->type == SILC_SOCKET_TYPE_SERVER) |
+ (cmd->sock->type == SILC_SOCKET_TYPE_ROUTER))
ret = silc_server_command_identify_from_server(cmd);
if (!ret)
/* Send notify about nickname change to our router. We send the new
ID and ask to replace it with the old one. If we are router the
- packet is broadcasted. */
- if (!cmd->server->standalone)
- silc_server_send_replace_id(server, server->router->connection,
- server->server_type == SILC_SERVER ?
- FALSE : TRUE, client->id,
- SILC_ID_CLIENT, SILC_ID_CLIENT_LEN,
- new_id, SILC_ID_CLIENT, SILC_ID_CLIENT_LEN);
+ packet is broadcasted. Send NICK_CHANGE notify. */
+ if (!server->standalone)
+ silc_server_send_notify_nick_change(server, server->router->connection,
+ server->server_type == SILC_SERVER ?
+ FALSE : TRUE, client->id,
+ new_id, SILC_ID_CLIENT_LEN);
/* Remove old cache entry */
silc_idcache_del_by_id(server->local_list->clients, SILC_ID_CLIENT,
nidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
- /* Send NICK_CHANGE notify */
+ /* Send NICK_CHANGE notify to the client's channels */
silc_server_send_notify_on_channels(server, client,
SILC_NOTIFY_TYPE_NICK_CHANGE, 2,
oidp->data, oidp->len,
goto out;
}
channel_id = silc_id_payload_parse_id(tmp, tmp_len);
+ if (!channel_id) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_TOPIC,
+ SILC_STATUS_ERR_NO_CHANNEL_ID);
+ goto out;
+ }
/* Check whether the channel exists */
channel = silc_idlist_find_channel_by_id(server->local_list,
/* See whether has rights to change topic */
silc_list_start(channel->user_list);
- while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END) {
- if (chl->client == client) {
- if (chl->mode == SILC_CHANNEL_UMODE_NONE) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_TOPIC,
- SILC_STATUS_ERR_NO_CHANNEL_PRIV);
- goto out;
- } else {
- break;
- }
+ while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END)
+ if (chl->client == client)
+ break;
+
+ if (chl->mode == SILC_CHANNEL_UMODE_NONE) {
+ if (channel->mode & SILC_CHANNEL_MODE_TOPIC) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_TOPIC,
+ SILC_STATUS_ERR_NO_CHANNEL_PRIV);
+ goto out;
}
}
silc_free(channel->topic);
channel->topic = strdup(tmp);
+ /* Send TOPIC_SET notify type to the network */
+ if (!server->standalone)
+ silc_server_send_notify_topic_set(server, server->router->connection,
+ server->server_type == SILC_ROUTER ?
+ TRUE : FALSE, channel, client->id,
+ SILC_ID_CLIENT_LEN, channel->topic);
+
idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
/* Send notify about topic change to all clients on the channel */
- silc_server_send_notify_to_channel(server, channel, TRUE,
+ silc_server_send_notify_to_channel(server, NULL, channel, TRUE,
SILC_NOTIFY_TYPE_TOPIC_SET, 2,
idp->data, idp->len,
channel->topic, strlen(channel->topic));
goto out;
}
dest_id = silc_id_payload_parse_id(tmp, len);
+ if (!dest_id) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_INVITE,
+ SILC_STATUS_ERR_NO_CLIENT_ID);
+ goto out;
+ }
/* Get Channel ID */
tmp = silc_argument_get_arg_type(cmd->args, 2, &len);
goto out;
}
channel_id = silc_id_payload_parse_id(tmp, len);
+ if (!channel_id) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_INVITE,
+ SILC_STATUS_ERR_NO_CHANNEL_ID);
+ goto out;
+ }
/* Check whether the channel exists */
channel = silc_idlist_find_channel_by_id(server->local_list,
sidp = silc_id_payload_encode(sender->id, SILC_ID_CLIENT);
/* Send notify to the client that is invited to the channel */
- silc_server_send_notify_dest(server, dest_sock, dest_id, SILC_ID_CLIENT,
+ silc_server_send_notify_dest(server, dest_sock, FALSE, dest_id,
+ SILC_ID_CLIENT,
SILC_NOTIFY_TYPE_INVITE, 2,
sidp->data, sidp->len, tmp, len);
silc_server_command_free(cmd);
}
+typedef struct {
+ SilcServer server;
+ SilcSocketConnection sock;
+ char *signoff;
+} *QuitInternal;
+
/* Quits connection to client. This gets called if client won't
close the connection even when it has issued QUIT command. */
SILC_TASK_CALLBACK(silc_server_command_quit_cb)
{
- SilcServer server = (SilcServer)context;
- SilcSocketConnection sock = server->sockets[fd];
+ QuitInternal q = (QuitInternal)context;
/* Free all client specific data, such as client entry and entires
on channels this client may be on. */
- silc_server_free_sock_user_data(server, sock);
+ silc_server_free_client_data(q->server, q->sock, q->sock->user_data,
+ q->signoff);
+ q->sock->user_data = NULL;
/* Close the connection on our side */
- silc_server_close_connection(server, sock);
+ silc_server_close_connection(q->server, q->sock);
+
+ silc_free(q->signoff);
+ silc_free(q);
}
/* Quits SILC session. This is the normal way to disconnect client. */
SilcServerCommandContext cmd = (SilcServerCommandContext)context;
SilcServer server = cmd->server;
SilcSocketConnection sock = cmd->sock;
+ QuitInternal q;
+ unsigned char *tmp = NULL;
+ unsigned int len = 0;
- SILC_LOG_DEBUG(("Start"));
+ SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_QUIT, cmd, 0, 1);
+
+ /* Get destination ID */
+ tmp = silc_argument_get_arg_type(cmd->args, 1, &len);
+ if (len > 128)
+ tmp = NULL;
+
+ q = silc_calloc(1, sizeof(*q));
+ q->server = server;
+ q->sock = sock;
+ q->signoff = tmp ? strdup(tmp) : NULL;
/* We quit the connection with little timeout */
silc_task_register(server->timeout_queue, sock->sock,
- silc_server_command_quit_cb, server,
- 0, 300000, SILC_TASK_TIMEOUT, SILC_TASK_PRI_LOW);
+ silc_server_command_quit_cb, (void *)q,
+ 0, 200000, SILC_TASK_TIMEOUT, SILC_TASK_PRI_LOW);
silc_server_command_free(cmd);
}
SILC_STATUS_ERR_NO_SERVER_ID);
goto out;
}
- id = silc_id_str2id(tmp, SILC_ID_SERVER);
+ id = silc_id_str2id(tmp, len, SILC_ID_SERVER);
if (!id)
goto out;
SilcBuffer buffer, idp;
SilcPacketContext *packet = silc_packet_context_alloc();
+ SILC_LOG_DEBUG(("Start"));
+
/* Create USERS command packet and process it. */
idp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL);
buffer = silc_command_payload_encode_va(SILC_COMMAND_USERS, 0, 1,
packet->sock = sock;
packet->type = SILC_PACKET_COMMAND;
- cmd = silc_calloc(1, sizeof(*cmd));
+ cmd = silc_server_command_alloc();
cmd->payload = silc_command_payload_parse(buffer);
+ if (!cmd->payload) {
+ silc_free(cmd);
+ silc_buffer_free(buffer);
+ silc_buffer_free(idp);
+ silc_packet_context_free(packet);
+ return;
+ }
cmd->args = silc_command_get_args(cmd->payload);
cmd->server = server;
- cmd->sock = sock;
+ cmd->sock = silc_socket_dup(sock);
cmd->packet = silc_packet_context_dup(packet);
cmd->pending = FALSE;
/* If this function was called from pending command then instead of
processing the command now, register a pending command callback which
will process it after we've received the automatic USERS command
- reply. */
- silc_server_command_pending(server, SILC_COMMAND_USERS, 0,
- silc_server_command_users, (void *)cmd);
+ reply which server will send in JOIN. */
+ silc_server_command_pending(server, SILC_COMMAND_USERS, 0, NULL,
+ silc_server_command_users, cmd);
cmd->pending = TRUE;
- silc_free(buffer);
- silc_free(idp);
+ silc_buffer_free(buffer);
+ silc_buffer_free(idp);
return;
}
/* Process USERS command. */
silc_server_command_users((void *)cmd);
-
- silc_free(buffer);
- silc_free(idp);
+
+ silc_buffer_free(buffer);
+ silc_buffer_free(idp);
silc_packet_context_free(packet);
}
/* Send the channel key. This is broadcasted to the channel but is not
sent to the client who is joining to the channel. */
- silc_server_send_channel_key(server, channel,
+ silc_server_send_channel_key(server, NULL, channel,
server->server_type == SILC_ROUTER ?
FALSE : server->standalone);
if (!cmd->pending) {
/* Send JOIN notify to locally connected clients on the channel */
- silc_server_send_notify_to_channel(server, channel, FALSE,
- SILC_NOTIFY_TYPE_JOIN, 1,
- clidp->data, clidp->len);
+ silc_server_send_notify_to_channel(server, NULL, channel, FALSE,
+ SILC_NOTIFY_TYPE_JOIN, 2,
+ clidp->data, clidp->len,
+ chidp->data, chidp->len);
- /* Send NEW_CHANNEL_USER packet to our primary router */
+ /* Send JOIN notify packet to our primary router */
if (!server->standalone)
- silc_server_send_new_channel_user(server, server->router->connection,
- server->server_type == SILC_SERVER ?
- FALSE : TRUE,
- channel->id, SILC_ID_CHANNEL_LEN,
- client->id, SILC_ID_CLIENT_LEN);
+ silc_server_send_notify_join(server, server->router->connection,
+ server->server_type == SILC_ROUTER ?
+ TRUE : FALSE, channel, client->id,
+ SILC_ID_CLIENT_LEN);
}
/* Send USERS command reply to the joined channel so the user sees who
goto out;
}
client_id = silc_id_payload_parse_id(tmp, tmp_len);
- if (!client_id)
+ if (!client_id) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_JOIN,
+ SILC_STATUS_ERR_NOT_ENOUGH_PARAMS);
goto out;
+ }
/* Get cipher name */
cipher = silc_argument_get_arg_type(cmd->args, 4, NULL);
the channel by ourselves. */
if (server->standalone) {
channel = silc_server_create_new_channel(server, server->id, cipher,
- channel_name);
+ channel_name, TRUE);
umode = (SILC_CHANNEL_UMODE_CHANOP | SILC_CHANNEL_UMODE_CHANFO);
created = TRUE;
/* Reprocess this packet after received reply from router */
silc_server_command_pending(server, SILC_COMMAND_JOIN,
silc_command_get_ident(cmd->payload),
- silc_server_command_join, context);
+ silc_server_command_destructor,
+ silc_server_command_join,
+ silc_server_command_dup(cmd));
cmd->pending = TRUE;
return;
}
if (!channel) {
/* Channel really does not exist, create it */
channel = silc_server_create_new_channel(server, server->id, cipher,
- channel_name);
+ channel_name, TRUE);
umode = (SILC_CHANNEL_UMODE_CHANOP | SILC_CHANNEL_UMODE_CHANFO);
created = TRUE;
}
if (!channel) {
/* Channel really does not exist, create it */
channel = silc_server_create_new_channel(server, server->id, cipher,
- channel_name);
+ channel_name, TRUE);
umode = (SILC_CHANNEL_UMODE_CHANOP | SILC_CHANNEL_UMODE_CHANFO);
created = TRUE;
}
goto out;
}
channel_id = silc_id_payload_parse_id(tmp_id, tmp_len2);
+ if (!channel_id) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_CMODE,
+ SILC_STATUS_ERR_NO_CHANNEL_ID);
+ goto out;
+ }
/* Get the channel mode mask */
tmp_mask = silc_argument_get_arg_type(cmd->args, 2, &tmp_len);
/* Send CMODE_CHANGE notify */
cidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
- silc_server_send_notify_to_channel(server, channel, TRUE,
+ silc_server_send_notify_to_channel(server, NULL, channel, FALSE,
SILC_NOTIFY_TYPE_CMODE_CHANGE, 2,
cidp->data, cidp->len,
tmp_mask, tmp_len);
- silc_free(cidp);
+
+ /* Set CMODE notify type to network */
+ if (!server->standalone)
+ silc_server_send_notify_cmode(server, server->router->connection,
+ server->server_type == SILC_ROUTER ?
+ TRUE : FALSE, channel,
+ mode_mask, client->id, SILC_ID_CLIENT_LEN);
/* Send command reply to sender */
packet = silc_command_reply_payload_encode_va(SILC_COMMAND_CMODE,
silc_buffer_free(packet);
silc_free(channel_id);
+ silc_free(cidp);
out:
silc_server_command_free(cmd);
SilcClientEntry target_client;
SilcChannelClientEntry chl;
SilcBuffer packet, idp;
- unsigned char *tmp_id, *tmp_mask;
- unsigned int target_mask, sender_mask, tmp_len;
+ unsigned char *tmp_id, *tmp_ch_id, *tmp_mask;
+ unsigned int target_mask, sender_mask, tmp_len, tmp_ch_len;
int notify = FALSE;
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);
- if (!tmp_id) {
+ tmp_ch_id = silc_argument_get_arg_type(cmd->args, 1, &tmp_ch_len);
+ if (!tmp_ch_id) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_CUMODE,
+ SILC_STATUS_ERR_NO_CHANNEL_ID);
+ goto out;
+ }
+ channel_id = silc_id_payload_parse_id(tmp_ch_id, tmp_ch_len);
+ if (!channel_id) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_CUMODE,
SILC_STATUS_ERR_NO_CHANNEL_ID);
goto out;
}
- channel_id = silc_id_payload_parse_id(tmp_id, tmp_len);
/* Get channel entry */
channel = silc_idlist_find_channel_by_id(server->local_list,
goto out;
}
client_id = silc_id_payload_parse_id(tmp_id, tmp_len);
+ if (!client_id) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_CUMODE,
+ SILC_STATUS_ERR_NO_CHANNEL_ID);
+ goto out;
+ }
/* Get target client's entry */
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 */
+ target_client = silc_idlist_find_client_by_id(server->global_list,
+ client_id, NULL);
}
/* Check whether target client is on the channel */
}
}
+ idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
+
/* Send notify to channel, notify only if mode was actually changed. */
if (notify) {
- idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
- silc_server_send_notify_to_channel(server, channel, TRUE,
+ silc_server_send_notify_to_channel(server, NULL, channel, FALSE,
SILC_NOTIFY_TYPE_CUMODE_CHANGE, 3,
idp->data, idp->len,
- tmp_mask, 4, tmp_id, tmp_len);
- silc_buffer_free(idp);
+ tmp_mask, 4,
+ tmp_id, tmp_len);
+
+ /* Set CUMODE notify type to network */
+ if (!server->standalone)
+ silc_server_send_notify_cumode(server, server->router->connection,
+ server->server_type == SILC_ROUTER ?
+ TRUE : FALSE, channel,
+ target_mask, client->id,
+ SILC_ID_CLIENT_LEN,
+ target_client->id,
+ SILC_ID_CLIENT_LEN);
}
/* Send command reply to sender */
silc_buffer_free(packet);
silc_free(channel_id);
silc_free(client_id);
+ silc_buffer_free(idp);
out:
silc_server_command_free(cmd);
goto out;
}
id = silc_id_payload_parse_id(tmp, len);
+ if (!id) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_LEAVE,
+ SILC_STATUS_ERR_NO_CHANNEL_ID);
+ goto out;
+ }
/* Get channel entry */
channel = silc_idlist_find_channel_by_id(server->local_list, id, NULL);
}
/* Notify routers that they should remove this client from their list
- of clients on the channel. */
+ of clients on the channel. Send LEAVE notify type. */
if (!server->standalone)
- silc_server_send_remove_channel_user(server,
- server->router->connection,
- server->server_type == SILC_ROUTER ?
- TRUE : FALSE, id_entry->id, id);
+ silc_server_send_notify_leave(server, server->router->connection,
+ server->server_type == SILC_ROUTER ?
+ TRUE : FALSE, channel, id_entry->id,
+ SILC_ID_CLIENT_LEN);
/* Remove client from channel */
i = silc_server_remove_from_one_channel(server, sock, channel, id_entry,
silc_server_packet_send(server,
cmd->server->router->connection,
SILC_PACKET_CHANNEL_KEY, 0, packet->data,
- packet->len, TRUE);
+ packet->len, FALSE);
} else {
}
goto out;
}
id = silc_id_payload_parse_id(channel_id, channel_id_len);
+ if (!id) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_USERS,
+ SILC_STATUS_ERR_NO_CHANNEL_ID);
+ goto out;
+ }
/* If we are server and we don't know about this channel we will send
the command to our router. If we know about the channel then we also
/* Reprocess this packet after received reply */
silc_server_command_pending(server, SILC_COMMAND_USERS,
silc_command_get_ident(cmd->payload),
- silc_server_command_users, (void *)cmd);
+ silc_server_command_destructor,
+ silc_server_command_users,
+ silc_server_command_dup(cmd));
cmd->pending = TRUE;
silc_command_set_ident(cmd->payload, ident);
projects / silc.git / blobdiff