Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1997 - 2002 Pekka Riikonen
+ Copyright (C) 1997 - 2003 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
SilcSocketConnection sock,
SilcServerCommandContext cmd,
SilcCommand command);
-static void
+static void
silc_server_command_send_status_reply(SilcServerCommandContext cmd,
SilcCommand command,
SilcStatus status,
SilcStatus error);
-static void
+static void
silc_server_command_send_status_data(SilcServerCommandContext cmd,
SilcCommand command,
SilcStatus status,
SILC_SERVER_CMD(users, USERS, SILC_CF_LAG | SILC_CF_REG),
SILC_SERVER_CMD(getkey, GETKEY, SILC_CF_LAG | SILC_CF_REG),
- SILC_SERVER_CMD(connect, PRIV_CONNECT,
+ SILC_SERVER_CMD(connect, PRIV_CONNECT,
SILC_CF_LAG | SILC_CF_REG | SILC_CF_OPER),
SILC_SERVER_CMD(close, PRIV_CLOSE,
SILC_CF_LAG | SILC_CF_REG | SILC_CF_OPER),
- SILC_SERVER_CMD(shutdown, PRIV_SHUTDOWN, SILC_CF_LAG | SILC_CF_REG |
+ SILC_SERVER_CMD(shutdown, PRIV_SHUTDOWN, SILC_CF_LAG | SILC_CF_REG |
SILC_CF_OPER),
{ NULL, 0 },
/* Performs several checks to the command. It first checks whether this
command was called as pending command callback. If it was then it checks
whether error occurred in the command reply where the pending command
- callback was called.
+ callback was called.
It also checks that the requested command includes correct amount
of arguments. */
SILC_LOG_DEBUG(("Client entry is invalid"));
silc_server_command_free(timeout->ctx);
silc_free(timeout);
+ return;
}
/* Update access time */
SILC_LOG_DEBUG(("Calling %s command",
silc_get_command_name(timeout->cmd->cmd)));
timeout->cmd->cb(timeout->ctx, NULL);
- } else if (silc_server_is_registered(timeout->ctx->server,
- timeout->ctx->sock,
- timeout->ctx,
+ } else if (silc_server_is_registered(timeout->ctx->server,
+ timeout->ctx->sock,
+ timeout->ctx,
timeout->cmd->cmd)) {
SILC_LOG_DEBUG(("Calling %s command",
silc_get_command_name(timeout->cmd->cmd)));
ctx->server = server;
ctx->sock = silc_socket_dup(sock);
ctx->packet = silc_packet_context_dup(packet); /* Save original packet */
-
+
/* Parse the command payload in the packet */
ctx->payload = silc_command_payload_parse(packet->buffer->data,
packet->buffer->len);
if (!client) {
SILC_LOG_DEBUG(("Client entry is invalid"));
silc_server_command_free(ctx);
+ return;
}
timeout = silc_calloc(1, sizeof(*timeout));
if (!fast && ((cmd->flags & SILC_CF_LAG_STRICT) ||
(client->fast_command > 5 && cmd->flags & SILC_CF_LAG)))
- silc_schedule_task_add(server->schedule, sock->sock,
+ silc_schedule_task_add(server->schedule, sock->sock,
silc_server_command_process_timeout, timeout,
(client->fast_command < 3 ? 0 :
2 - (time(NULL) - client->last_command)),
(client->fast_command < 3 ? 200000 : 0),
SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
else
- silc_schedule_task_add(server->schedule, sock->sock,
+ silc_schedule_task_add(server->schedule, sock->sock,
silc_server_command_process_timeout, timeout,
0, 1, SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
return;
/* Duplicate Command Context by adding reference counter. The context won't
be free'd untill it hits zero. */
-SilcServerCommandContext
+SilcServerCommandContext
silc_server_command_dup(SilcServerCommandContext ctx)
{
ctx->users++;
cmdr = silc_calloc(1, sizeof(*cmdr));
cmdr->server = server;
cmdr->ident = reply->ident;
-
+
/* Check for pending commands and mark to be exeucted */
- cmdr->callbacks =
+ cmdr->callbacks =
silc_server_command_pending_check(server, reply->reply_cmd,
reply->ident, &cmdr->callbacks_count);
SilcServerCommandPendingCallbacks
silc_server_command_pending_check(SilcServer server,
- SilcCommand command,
+ SilcCommand command,
SilcUInt16 ident,
SilcUInt32 *callbacks_count)
{
/* Sends simple status message as command reply packet */
-static void
+static void
silc_server_command_send_status_reply(SilcServerCommandContext cmd,
SilcCommand command,
SilcStatus status,
SILC_LOG_DEBUG(("Sending command status %d", status));
- buffer =
+ buffer =
silc_command_reply_payload_encode_va(command, status, error,
silc_command_get_ident(cmd->payload),
0);
silc_server_packet_send(cmd->server, cmd->sock,
- SILC_PACKET_COMMAND_REPLY, 0,
+ SILC_PACKET_COMMAND_REPLY, 0,
buffer->data, buffer->len, FALSE);
silc_buffer_free(buffer);
}
/* Sends command status reply with one extra argument. The argument
type must be sent as argument. */
-static void
+static void
silc_server_command_send_status_data(SilcServerCommandContext cmd,
SilcCommand command,
SilcStatus status,
SILC_LOG_DEBUG(("Sending command status %d", status));
- buffer =
+ buffer =
silc_command_reply_payload_encode_va(command, status, 0,
silc_command_get_ident(cmd->payload),
1, arg_type, arg, arg_len);
silc_server_packet_send(cmd->server, cmd->sock,
- SILC_PACKET_COMMAND_REPLY, 0,
+ SILC_PACKET_COMMAND_REPLY, 0,
+ buffer->data, buffer->len, FALSE);
+ silc_buffer_free(buffer);
+}
+
+static void
+silc_server_command_send_status_data2(SilcServerCommandContext cmd,
+ SilcCommand command,
+ SilcStatus status,
+ SilcStatus error,
+ SilcUInt32 arg_type1,
+ const unsigned char *arg1,
+ SilcUInt32 arg_len1,
+ SilcUInt32 arg_type2,
+ const unsigned char *arg2,
+ SilcUInt32 arg_len2)
+{
+ SilcBuffer buffer;
+
+ SILC_LOG_DEBUG(("Sending command status %d", status));
+
+ buffer =
+ silc_command_reply_payload_encode_va(command, status, 0,
+ silc_command_get_ident(cmd->payload),
+ 2, arg_type1, arg1, arg_len1,
+ arg_type2, arg2, arg_len2);
+ silc_server_packet_send(cmd->server, cmd->sock,
+ SILC_PACKET_COMMAND_REPLY, 0,
buffer->data, buffer->len, FALSE);
silc_buffer_free(buffer);
}
/* This function can be called to check whether in the command reply
an error occurred. This function has no effect if this is called
- when the command function was not called as pending command callback.
+ when the command function was not called as pending command callback.
This returns TRUE if error had occurred. */
static bool
/* Send the same command reply payload */
silc_command_set_command(cmdr->payload, silc_command_get(cmd->payload));
- silc_command_set_ident(cmdr->payload,
+ silc_command_set_ident(cmdr->payload,
silc_command_get_ident(cmd->payload));
buffer = silc_command_payload_encode_payload(cmdr->payload);
silc_server_packet_send(cmd->server, cmd->sock,
- SILC_PACKET_COMMAND_REPLY, 0,
+ SILC_PACKET_COMMAND_REPLY, 0,
buffer->data, buffer->len, FALSE);
silc_buffer_free(buffer);
return TRUE;
/* Check nickname */
nick = silc_argument_get_arg_type(cmd->args, 1, &nick_len);
+ if (!nick) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_NICK,
+ SILC_STATUS_ERR_BAD_NICKNAME, 0);
+ goto out;
+ }
if (nick_len > 128)
nick[128] = '\0';
if (silc_server_name_bad_chars(nick, nick_len) == TRUE) {
}
/* Create new Client ID */
- while (!silc_id_create_client_id(cmd->server, cmd->server->id,
- cmd->server->rng,
+ while (!silc_id_create_client_id(cmd->server, cmd->server->id,
+ cmd->server->rng,
cmd->server->md5hash, nick,
&new_id)) {
nickfail++;
client->nickname = strdup(nick);
/* Update client cache */
- silc_idcache_add(server->local_list->clients, client->nickname,
+ silc_idcache_add(server->local_list->clients, client->nickname,
client->id, (void *)client, 0, NULL);
nidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
/* Send NICK_CHANGE notify to the client's channels */
- silc_server_send_notify_on_channels(server, NULL, client,
+ silc_server_send_notify_on_channels(server, NULL, client,
SILC_NOTIFY_TYPE_NICK_CHANGE, 3,
- oidp->data, oidp->len,
+ oidp->data, oidp->len,
nidp->data, nidp->len,
- client->nickname,
+ client->nickname,
strlen(client->nickname));
/* Check if anyone is watching the new nickname */
send_reply:
/* Send the new Client ID as reply command back to client */
- packet = silc_command_reply_payload_encode_va(SILC_COMMAND_NICK,
+ packet = silc_command_reply_payload_encode_va(SILC_COMMAND_NICK,
SILC_STATUS_OK, 0, ident, 2,
2, nidp->data, nidp->len,
3, nick, strlen(nick));
silc_buffer_free(nidp);
if (oidp)
silc_buffer_free(oidp);
-
+
out:
silc_server_command_free(cmd);
}
static void
silc_server_command_list_send_reply(SilcServerCommandContext cmd,
- SilcChannelEntry *lch,
+ SilcChannelEntry *lch,
SilcUInt32 lch_count,
SilcChannelEntry *gch,
SilcUInt32 gch_count)
}
/* Send the reply */
- packet =
- silc_command_reply_payload_encode_va(SILC_COMMAND_LIST,
+ packet =
+ silc_command_reply_payload_encode_va(SILC_COMMAND_LIST,
status, 0, ident, 4,
2, idp->data, idp->len,
- 3, entry->channel_name,
+ 3, entry->channel_name,
strlen(entry->channel_name),
4, topic, topic ? strlen(topic) : 0,
5, usercount, 4);
- silc_server_packet_send(cmd->server, cmd->sock,
- SILC_PACKET_COMMAND_REPLY, 0, packet->data,
+ silc_server_packet_send(cmd->server, cmd->sock,
+ SILC_PACKET_COMMAND_REPLY, 0, packet->data,
packet->len, FALSE);
silc_buffer_free(packet);
silc_buffer_free(idp);
}
/* Send the reply */
- packet =
- silc_command_reply_payload_encode_va(SILC_COMMAND_LIST,
+ packet =
+ silc_command_reply_payload_encode_va(SILC_COMMAND_LIST,
status, 0, ident, 4,
2, idp->data, idp->len,
- 3, entry->channel_name,
+ 3, entry->channel_name,
strlen(entry->channel_name),
4, topic, topic ? strlen(topic) : 0,
5, usercount, 4);
- silc_server_packet_send(cmd->server, cmd->sock,
- SILC_PACKET_COMMAND_REPLY, 0, packet->data,
+ silc_server_packet_send(cmd->server, cmd->sock,
+ SILC_PACKET_COMMAND_REPLY, 0, packet->data,
packet->len, FALSE);
silc_buffer_free(packet);
silc_buffer_free(idp);
/* If we are normal server, send the command to router, since we
want to know all channels in the network. */
- if (!cmd->pending && server->server_type != SILC_ROUTER &&
+ if (!cmd->pending && server->server_type != SILC_ROUTER &&
!server->standalone) {
SilcBuffer tmpbuf;
SilcUInt16 old_ident;
-
+
old_ident = silc_command_get_ident(cmd->payload);
silc_command_set_ident(cmd->payload, ++server->cmd_ident);
tmpbuf = silc_command_payload_encode_payload(cmd->payload);
tmpbuf->data, tmpbuf->len, TRUE);
/* Reprocess this packet after received reply from router */
- silc_server_command_pending(server, SILC_COMMAND_LIST,
+ silc_server_command_pending(server, SILC_COMMAND_LIST,
silc_command_get_ident(cmd->payload),
- silc_server_command_list,
+ silc_server_command_list,
silc_server_command_dup(cmd));
cmd->pending = TRUE;
silc_command_set_ident(cmd->payload, old_ident);
/* Get the channels from local list */
lchannels = silc_idlist_get_channels(server->local_list, channel_id,
&lch_count);
-
+
/* Get the channels from global list */
gchannels = silc_idlist_get_channels(server->global_list, channel_id,
&gch_count);
/* Send the reply */
- silc_server_command_list_send_reply(cmd, lchannels, lch_count,
+ silc_server_command_list_send_reply(cmd, lchannels, lch_count,
gchannels, gch_count);
silc_free(lchannels);
}
/* Check whether the channel exists */
- channel = silc_idlist_find_channel_by_id(server->local_list,
+ channel = silc_idlist_find_channel_by_id(server->local_list,
channel_id, NULL);
if (!channel) {
- channel = silc_idlist_find_channel_by_id(server->global_list,
+ channel = silc_idlist_find_channel_by_id(server->global_list,
channel_id, NULL);
if (!channel) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_TOPIC,
- SILC_STATUS_ERR_NO_SUCH_CHANNEL,
- 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_TOPIC,
+ SILC_STATUS_ERR_NO_SUCH_CHANNEL_ID,
+ 0, 2, tmp, tmp_len);
goto out;
}
}
/* See whether the client is on channel and has rights to change topic */
if (!silc_server_client_on_channel(client, channel, &chl)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_TOPIC,
- SILC_STATUS_ERR_NOT_ON_CHANNEL,
- 0);
+ tmp = silc_argument_get_arg_type(cmd->args, 1, &tmp_len);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_TOPIC,
+ SILC_STATUS_ERR_NOT_ON_CHANNEL,
+ 0, 2, tmp, tmp_len);
goto out;
}
if (channel->mode & SILC_CHANNEL_MODE_TOPIC &&
!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
!(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_TOPIC,
- SILC_STATUS_ERR_NO_CHANNEL_PRIV,
- 0);
+ tmp = silc_argument_get_arg_type(cmd->args, 1, &tmp_len);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_TOPIC,
+ SILC_STATUS_ERR_NO_CHANNEL_PRIV,
+ 0, 2, tmp, tmp_len);
goto out;
}
/* Send notify about topic change to all clients on the channel */
idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
- silc_server_send_notify_to_channel(server, NULL, channel, FALSE,
+ silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
SILC_NOTIFY_TYPE_TOPIC_SET, 2,
idp->data, idp->len,
channel->topic,
/* Send the topic to client as reply packet */
idp = silc_id_payload_encode(channel_id, SILC_ID_CHANNEL);
- packet = silc_command_reply_payload_encode_va(SILC_COMMAND_TOPIC,
- SILC_STATUS_OK, 0, ident, 2,
+ packet = silc_command_reply_payload_encode_va(SILC_COMMAND_TOPIC,
+ SILC_STATUS_OK, 0, ident, 2,
2, idp->data, idp->len,
- 3, channel->topic,
- channel->topic ?
+ 3, channel->topic,
+ channel->topic ?
strlen(channel->topic) : 0);
silc_server_packet_send(cmd->server, cmd->sock, SILC_PACKET_COMMAND_REPLY,
0, packet->data, packet->len, FALSE);
silc_server_command_free(cmd);
}
-/* Server side of INVITE command. Invites some client to join some channel.
+/* Server side of INVITE command. Invites some client to join some channel.
This command is also used to manage the invite list of the channel. */
SILC_SERVER_CMD_FUNC(invite)
SilcChannelEntry channel;
SilcChannelID *channel_id = NULL;
SilcIDListData idata;
- SilcBuffer idp, idp2, packet;
- unsigned char *tmp, *add, *del;
- SilcUInt32 len;
- SilcUInt16 ident = silc_command_get_ident(cmd->payload);
+ SilcArgumentPayload args;
+ SilcHashTableList htl;
+ SilcBuffer packet, list, tmp2;
+ SilcBufferStruct alist;
+ unsigned char *tmp, *atype = NULL;
+ SilcUInt32 len, type, len2;
+ SilcUInt16 argc = 0, ident = silc_command_get_ident(cmd->payload);
SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_INVITE, cmd, 1, 4);
}
/* Get the channel entry */
- channel = silc_idlist_find_channel_by_id(server->local_list,
+ channel = silc_idlist_find_channel_by_id(server->local_list,
channel_id, NULL);
if (!channel) {
- channel = silc_idlist_find_channel_by_id(server->global_list,
+ channel = silc_idlist_find_channel_by_id(server->global_list,
channel_id, NULL);
if (!channel) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_INVITE,
- SILC_STATUS_ERR_NO_SUCH_CHANNEL,
- 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_INVITE,
+ SILC_STATUS_ERR_NO_SUCH_CHANNEL_ID,
+ 0, 2, tmp, len);
goto out;
}
}
/* Check whether the sender of this command is on the channel. */
sender = (SilcClientEntry)sock->user_data;
if (!sender || !silc_server_client_on_channel(sender, channel, &chl)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_INVITE,
- SILC_STATUS_ERR_NOT_ON_CHANNEL, 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_INVITE,
+ SILC_STATUS_ERR_NOT_ON_CHANNEL, 0,
+ 2, tmp, len);
goto out;
}
if (channel->mode & SILC_CHANNEL_MODE_INVITE &&
!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
!(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_INVITE,
- SILC_STATUS_ERR_NO_CHANNEL_PRIV,
- 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_INVITE,
+ SILC_STATUS_ERR_NO_CHANNEL_PRIV,
+ 0, 2, tmp, len);
goto out;
}
/* Get destination client ID */
tmp = silc_argument_get_arg_type(cmd->args, 2, &len);
if (tmp) {
- char invite[512];
bool resolve;
dest_id = silc_id_payload_parse_id(tmp, len, NULL);
dest = silc_server_query_client(server, dest_id, FALSE, &resolve);
if (!dest) {
if (server->server_type != SILC_SERVER || !resolve || cmd->pending) {
- silc_server_command_send_status_reply(
+ silc_server_command_send_status_data(
cmd, SILC_COMMAND_INVITE,
- SILC_STATUS_ERR_NO_SUCH_CLIENT_ID, 0);
+ SILC_STATUS_ERR_NO_SUCH_CLIENT_ID, 0,
+ 2, tmp, len);
goto out;
}
-
+
/* The client info is being resolved. Reprocess this packet after
receiving the reply to the query. */
- silc_server_command_pending(server, SILC_COMMAND_WHOIS,
+ silc_server_command_pending(server, SILC_COMMAND_WHOIS,
server->cmd_ident,
- silc_server_command_invite,
+ silc_server_command_invite,
silc_server_command_dup(cmd));
cmd->pending = TRUE;
- silc_free(channel_id);
- silc_free(dest_id);
goto out;
}
/* Check whether the requested client is already on the channel. */
if (silc_server_client_on_channel(dest, channel, NULL)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_INVITE,
+ atype = silc_argument_get_arg_type(cmd->args, 1, &len2);
+ silc_server_command_send_status_data2(cmd, SILC_COMMAND_INVITE,
SILC_STATUS_ERR_USER_ON_CHANNEL,
- 0);
+ 0, 2, tmp, len,
+ 3, atype, len2);
goto out;
}
-
+
/* Get route to the client */
- dest_sock = silc_server_get_client_route(server, NULL, 0, dest_id,
+ dest_sock = silc_server_get_client_route(server, NULL, 0, dest_id,
&idata, NULL);
if (!dest_sock) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_INVITE,
- SILC_STATUS_ERR_NO_SUCH_CLIENT_ID,
- 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_INVITE,
+ SILC_STATUS_ERR_NO_SUCH_CLIENT_ID,
+ 0, 2, tmp, len);
goto out;
}
- memset(invite, 0, sizeof(invite));
- silc_strncat(invite, sizeof(invite),
- dest->nickname, strlen(dest->nickname));
- silc_strncat(invite, sizeof(invite), "!", 1);
- silc_strncat(invite, sizeof(invite),
- dest->username, strlen(dest->username));
- if (!strchr(dest->username, '@')) {
- silc_strncat(invite, sizeof(invite), "@", 1);
- silc_strncat(invite, sizeof(invite), cmd->sock->hostname,
- strlen(cmd->sock->hostname));
- }
+ /* Add the client to the invite list */
- len = strlen(invite);
+ /* Allocate hash table for invite list if it doesn't exist yet */
if (!channel->invite_list)
- channel->invite_list = silc_calloc(len + 2,
- sizeof(*channel->invite_list));
- else
- channel->invite_list = silc_realloc(channel->invite_list,
- sizeof(*channel->invite_list) *
- (len +
- strlen(channel->invite_list) + 2));
- strncat(channel->invite_list, invite, len);
- strncat(channel->invite_list, ",", 1);
+ channel->invite_list =
+ silc_hash_table_alloc(0, silc_hash_ptr,
+ NULL, NULL, NULL,
+ silc_server_inviteban_destruct, channel, TRUE);
+
+ /* Check if the ID is in the list already */
+ silc_hash_table_list(channel->invite_list, &htl);
+ while (silc_hash_table_get(&htl, (void **)&type, (void **)&tmp2)) {
+ if (type == 3 && !memcmp(tmp2->data, tmp, len)) {
+ tmp = NULL;
+ break;
+ }
+ }
+ silc_hash_table_list_reset(&htl);
+
+ /* Add new Client ID to invite list */
+ if (tmp) {
+ list = silc_buffer_alloc_size(len);
+ silc_buffer_put(list, tmp, len);
+ silc_hash_table_add(channel->invite_list, (void *)3, list);
+ }
if (!(dest->mode & SILC_UMODE_BLOCK_INVITE)) {
/* Send notify to the client that is invited to the channel */
+ SilcBuffer idp, idp2;
idp = silc_id_payload_encode(channel_id, SILC_ID_CHANNEL);
idp2 = silc_id_payload_encode(sender->id, SILC_ID_CLIENT);
- silc_server_send_notify_dest(server, dest_sock, FALSE, dest_id,
+ silc_server_send_notify_dest(server, dest_sock, FALSE, dest_id,
SILC_ID_CLIENT,
- SILC_NOTIFY_TYPE_INVITE, 3,
- idp->data, idp->len,
- channel->channel_name,
+ SILC_NOTIFY_TYPE_INVITE, 3,
+ idp->data, idp->len,
+ channel->channel_name,
strlen(channel->channel_name),
idp2->data, idp2->len);
silc_buffer_free(idp);
}
}
- /* Add the client to the invite list of the channel */
- add = silc_argument_get_arg_type(cmd->args, 3, &len);
- if (add) {
- if (!channel->invite_list)
- channel->invite_list = silc_calloc(len + 2,
- sizeof(*channel->invite_list));
- else
- channel->invite_list = silc_realloc(channel->invite_list,
- sizeof(*channel->invite_list) *
- (len +
- strlen(channel->invite_list) + 2));
- if (add[len - 1] == ',')
- add[len - 1] = '\0';
-
- strncat(channel->invite_list, add, len);
- strncat(channel->invite_list, ",", 1);
- }
-
- /* Get the invite to be removed and remove it from the list */
- del = silc_argument_get_arg_type(cmd->args, 4, &len);
- if (del && channel->invite_list) {
- char *start, *end, *n;
-
- if (!strncmp(channel->invite_list, del,
- strlen(channel->invite_list) - 1)) {
- silc_free(channel->invite_list);
- channel->invite_list = NULL;
- } else {
- start = strstr(channel->invite_list, del);
- if (start && strlen(start) >= len) {
- end = start + len;
- n = silc_calloc(strlen(channel->invite_list) - len, sizeof(*n));
- strncat(n, channel->invite_list, start - channel->invite_list);
- strncat(n, end + 1, ((channel->invite_list +
- strlen(channel->invite_list)) - end) - 1);
- silc_free(channel->invite_list);
- channel->invite_list = n;
+ /* Get the invite information */
+ tmp = silc_argument_get_arg_type(cmd->args, 4, &len2);
+ if (tmp && len2 > 2) {
+ /* Parse the arguments to see they are constructed correctly */
+ SILC_GET16_MSB(argc, tmp);
+ args = silc_argument_payload_parse(tmp + 2, len2 - 2, argc);
+ if (!args) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_INVITE,
+ SILC_STATUS_ERR_NOT_ENOUGH_PARAMS,
+ 0);
+ goto out;
+ }
+
+ /* Get the type of action */
+ atype = silc_argument_get_arg_type(cmd->args, 3, &len);
+ if (atype && len == 1) {
+ if (atype[0] == 0x00) {
+ /* Allocate hash table for invite list if it doesn't exist yet */
+ if (!channel->invite_list)
+ channel->invite_list =
+ silc_hash_table_alloc(0, silc_hash_ptr,
+ NULL, NULL, NULL,
+ silc_server_inviteban_destruct, channel,
+ TRUE);
+
+ /* Check for resource limit */
+ if (silc_hash_table_count(channel->invite_list) > 64) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_INVITE,
+ SILC_STATUS_ERR_RESOURCE_LIMIT,
+ 0);
+ goto out;
+ }
}
+
+ /* Now add or delete the information. */
+ silc_server_inviteban_process(server, channel->invite_list,
+ (SilcUInt8)atype[0], args);
+ }
+ silc_argument_payload_free(args);
+ }
+
+ /* Encode invite list */
+ list = NULL;
+ if (channel->invite_list && silc_hash_table_count(channel->invite_list)) {
+ list = silc_buffer_alloc_size(2);
+ silc_buffer_format(list,
+ SILC_STR_UI_SHORT(silc_hash_table_count(
+ channel->invite_list)),
+ SILC_STR_END);
+ silc_hash_table_list(channel->invite_list, &htl);
+ while (silc_hash_table_get(&htl, (void **)&type, (void **)&tmp2))
+ list = silc_argument_payload_encode_one(list, tmp2->data, tmp2->len,
+ type);
+ silc_hash_table_list_reset(&htl);
+ }
+
+ /* The notify is sent to local servers (not clients), and to network. */
+ if (atype && tmp && len2) {
+ silc_buffer_set(&alist, tmp, len2);
+
+ /* Send to local servers if we are router */
+ if (server->server_type == SILC_ROUTER) {
+ SilcBuffer idp, idp2;
+ idp = silc_id_payload_encode(channel_id, SILC_ID_CHANNEL);
+ idp2 = silc_id_payload_encode(sender->id, SILC_ID_CLIENT);
+ silc_server_send_notify_to_channel(server, NULL, channel, FALSE, FALSE,
+ SILC_NOTIFY_TYPE_INVITE, 5,
+ idp->data, idp->len,
+ channel->channel_name,
+ strlen(channel->channel_name),
+ idp2->data, idp2->len,
+ atype, 1,
+ tmp ? alist.data : NULL,
+ tmp ? alist.len : 0);
+ silc_buffer_free(idp);
+ silc_buffer_free(idp2);
}
+
+ /* Send to network */
+ silc_server_send_notify_invite(server, SILC_PRIMARY_ROUTE(server),
+ SILC_BROADCAST(server), channel,
+ sender->id, atype,
+ tmp ? &alist : NULL);
}
- /* Send notify to the primary router */
- silc_server_send_notify_invite(server, SILC_PRIMARY_ROUTE(server),
- SILC_BROADCAST(server), channel,
- sender->id, add, del);
+ /* Send invite list back only if the list was modified, or no arguments
+ was given. */
+ type = 0;
+ argc = silc_argument_get_arg_num(cmd->args);
+ if (argc == 1)
+ type = 1;
+ if (silc_argument_get_arg_type(cmd->args, 3, &len))
+ type = 1;
/* Send command reply */
tmp = silc_argument_get_arg_type(cmd->args, 1, &len);
-
- packet =
- silc_command_reply_payload_encode_va(SILC_COMMAND_INVITE,
- SILC_STATUS_OK, 0, ident, 2,
- 2, tmp, len,
- 3, channel->invite_list,
- channel->invite_list ?
- strlen(channel->invite_list) : 0);
- silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
+ packet = silc_command_reply_payload_encode_va(SILC_COMMAND_INVITE,
+ SILC_STATUS_OK, 0, ident, 2,
+ 2, tmp, len,
+ 3, type && list ?
+ list->data : NULL,
+ type && list ? list->len : 0);
+ silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
packet->data, packet->len, FALSE);
silc_buffer_free(packet);
+ silc_buffer_free(list);
out:
silc_free(dest_id);
}
/* Quits SILC session. This is the normal way to disconnect client. */
-
+
SILC_SERVER_CMD_FUNC(quit)
{
SilcServerCommandContext cmd = (SilcServerCommandContext)context;
}
client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
if (!client_id) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_KILL,
- SILC_STATUS_ERR_NO_SUCH_CLIENT_ID,
- 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_KILL,
+ SILC_STATUS_ERR_NO_SUCH_CLIENT_ID,
+ 0, 2, tmp, tmp_len);
goto out;
}
/* Get the client entry */
- remote_client = silc_idlist_find_client_by_id(server->local_list,
+ remote_client = silc_idlist_find_client_by_id(server->local_list,
client_id, TRUE, NULL);
if (!remote_client) {
- remote_client = silc_idlist_find_client_by_id(server->global_list,
+ remote_client = silc_idlist_find_client_by_id(server->global_list,
client_id, TRUE, NULL);
if (!remote_client) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_KILL,
- SILC_STATUS_ERR_NO_SUCH_CLIENT_ID,
- 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_KILL,
+ SILC_STATUS_ERR_NO_SUCH_CLIENT_ID,
+ 0, 2, tmp, tmp_len);
goto out;
}
}
server->sha1hash, remote_client->id,
SILC_ID_CLIENT)) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_KILL,
- SILC_STATUS_ERR_AUTH_FAILED,
- 0);
+ SILC_STATUS_ERR_AUTH_FAILED, 0);
goto out;
}
/* Send reply to the sender */
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_KILL,
- SILC_STATUS_OK, 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_KILL,
+ SILC_STATUS_OK, 0,
+ 2, tmp, tmp_len);
/* Do normal signoff for the destination client */
sock = remote_client->connection;
+ silc_server_remove_from_channels(server, NULL, remote_client,
+ TRUE, (char *)"Killed", TRUE, TRUE);
silc_server_free_client_data(server, NULL, remote_client, TRUE,
comment ? comment :
(unsigned char *)"Killed");
/* Router operator killing */
/* Send reply to the sender */
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_KILL,
- SILC_STATUS_OK, 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_KILL,
+ SILC_STATUS_OK, 0,
+ 2, tmp, tmp_len);
/* Check if anyone is watching this nickname */
if (server->server_type == SILC_ROUTER)
silc_server_command_free(cmd);
}
-/* Server side of command INFO. This sends information about us to
- the client. If client requested specific server we will send the
+/* Server side of command INFO. This sends information about us to
+ the client. If client requested specific server we will send the
command to that server. */
SILC_SERVER_CMD_FUNC(info)
entry = silc_idlist_find_server_by_id(server->global_list,
server_id, TRUE, NULL);
if (!entry && server->server_type != SILC_SERVER) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_INFO,
- SILC_STATUS_ERR_NO_SUCH_SERVER,
- 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_INFO,
+ SILC_STATUS_ERR_NO_SUCH_SERVER_ID,
+ 0, 2, tmp, tmp_len);
goto out;
}
}
if (server->server_type != SILC_SERVER && cmd->sock->user_data == entry)
goto out;
- if ((!dest_server && !server_id && !entry) || (entry &&
+ if ((!dest_server && !server_id && !entry) || (entry &&
entry == server->id_entry) ||
- (dest_server && !cmd->pending &&
+ (dest_server && !cmd->pending &&
!strncasecmp(dest_server, server->server_name, strlen(dest_server)))) {
/* Send our reply */
char info_string[256];
memset(info_string, 0, sizeof(info_string));
- snprintf(info_string, sizeof(info_string),
+ snprintf(info_string, sizeof(info_string),
"location: %s server: %s admin: %s <%s>",
server->config->server_info->location,
server->config->server_info->server_type,
tmpbuf->data, tmpbuf->len, TRUE);
/* Reprocess this packet after received reply from router */
- silc_server_command_pending(server, SILC_COMMAND_INFO,
+ silc_server_command_pending(server, SILC_COMMAND_INFO,
silc_command_get_ident(cmd->payload),
silc_server_command_info,
silc_server_command_dup(cmd));
tmpbuf->data, tmpbuf->len, TRUE);
/* Reprocess this packet after received reply from router */
- silc_server_command_pending(server, SILC_COMMAND_INFO,
+ silc_server_command_pending(server, SILC_COMMAND_INFO,
silc_command_get_ident(cmd->payload),
silc_server_command_info,
silc_server_command_dup(cmd));
silc_free(server_id);
if (!entry) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_INFO,
- SILC_STATUS_ERR_NO_SUCH_SERVER, 0);
+ if (dest_server)
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_INFO,
+ SILC_STATUS_ERR_NO_SUCH_SERVER, 0,
+ 2, dest_server,
+ strlen(dest_server));
goto out;
}
packet = silc_command_reply_payload_encode_va(SILC_COMMAND_INFO,
SILC_STATUS_OK, 0, ident, 3,
2, idp->data, idp->len,
- 3, server_name,
+ 3, server_name,
strlen(server_name),
- 4, server_info,
- server_info ?
+ 4, server_info,
+ server_info ?
strlen(server_info) : 0);
- silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
+ 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);
tmp = silc_argument_get_arg_type(cmd->args, 1, &tmp_len);
if (!tmp) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_PING,
- SILC_STATUS_ERR_NO_SERVER_ID, 0);
+ SILC_STATUS_ERR_NOT_ENOUGH_PARAMS,
+ 0);
goto out;
}
server_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
silc_server_command_send_status_reply(cmd, SILC_COMMAND_PING,
SILC_STATUS_OK, 0);
} else {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_PING,
- SILC_STATUS_ERR_NO_SUCH_SERVER, 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_PING,
+ SILC_STATUS_ERR_NO_SUCH_SERVER_ID, 0,
+ 2, tmp, tmp_len);
goto out;
}
/* Get Server ID */
tmp = silc_argument_get_arg_type(cmd->args, 1, &tmp_len);
if (!tmp) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_PING,
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_STATS,
SILC_STATUS_ERR_NO_SERVER_ID, 0);
goto out;
}
/* The ID must be ours */
if (!SILC_ID_SERVER_COMPARE(server->id, server_id)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_PING,
- SILC_STATUS_ERR_NO_SUCH_SERVER, 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_STATS,
+ SILC_STATUS_ERR_NO_SUCH_SERVER_ID, 0,
+ 2, tmp, tmp_len);
silc_free(server_id);
goto out;
}
/* If we are router then just send everything we got. If we are normal
server then we'll send this to our router to get all the latest
statistical information. */
- if (!cmd->pending && server->server_type != SILC_ROUTER &&
+ if (!cmd->pending && server->server_type != SILC_ROUTER &&
!server->standalone) {
/* Send request to our router */
- SilcBuffer idp = silc_id_payload_encode(server->router->id,
+ SilcBuffer idp = silc_id_payload_encode(server->router->id,
SILC_ID_SERVER);
- packet = silc_command_payload_encode_va(SILC_COMMAND_STATS,
+ packet = silc_command_payload_encode_va(SILC_COMMAND_STATS,
++server->cmd_ident, 1,
1, idp->data, idp->len);
silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
packet->len, FALSE);
/* Reprocess this packet after received reply from router */
- silc_server_command_pending(server, SILC_COMMAND_STATS,
+ silc_server_command_pending(server, SILC_COMMAND_STATS,
server->cmd_ident,
silc_server_command_stats,
silc_server_command_dup(cmd));
SILC_STR_UI_INT(server->stat.router_ops),
SILC_STR_END);
- packet = silc_command_reply_payload_encode_va(SILC_COMMAND_STATS,
+ packet = silc_command_reply_payload_encode_va(SILC_COMMAND_STATS,
SILC_STATUS_OK, 0, ident, 2,
2, tmp, tmp_len,
3, stats->data, stats->len);
has been either created or resolved from ID lists. This joins the sent
client to the channel. */
-static void silc_server_command_join_channel(SilcServer server,
+static void silc_server_command_join_channel(SilcServer server,
SilcServerCommandContext cmd,
SilcChannelEntry channel,
SilcClientID *client_id,
bool create_key,
SilcUInt32 umode,
const unsigned char *auth,
- SilcUInt32 auth_len)
+ SilcUInt32 auth_len,
+ const unsigned char *cauth,
+ SilcUInt32 cauth_len)
{
SilcSocketConnection sock = cmd->sock;
unsigned char *tmp;
unsigned char *passphrase = NULL, mode[4], tmp2[4], tmp3[4];
SilcClientEntry client;
SilcChannelClientEntry chl;
- SilcBuffer reply, chidp, clidp, keyp = NULL, user_list, mode_list;
+ SilcBuffer reply, chidp, clidp, keyp = NULL;
+ SilcBuffer user_list, mode_list, invite_list, ban_list;
SilcUInt16 ident = silc_command_get_ident(cmd->payload);
char check[512], check2[512];
bool founder = FALSE;
bool resolve;
- SilcBuffer fkey = NULL;
+ SilcBuffer fkey = NULL, chpklist = NULL;
const char *cipher;
SILC_LOG_DEBUG(("Joining client to channel"));
if (!client)
return;
} else {
- client = silc_server_query_client(server, client_id, FALSE,
+ client = silc_server_query_client(server, client_id, FALSE,
&resolve);
if (!client) {
if (!resolve || cmd->pending) {
/* The client info is being resolved. Reprocess this packet after
receiving the reply to the query. */
- silc_server_command_pending(server, SILC_COMMAND_WHOIS,
+ silc_server_command_pending(server, SILC_COMMAND_WHOIS,
server->cmd_ident,
- silc_server_command_join,
+ silc_server_command_join,
silc_server_command_dup(cmd));
cmd->pending = TRUE;
goto out;
}
- if (auth && auth_len && !client->data.public_key) {
+ if (!client->data.public_key &&
+ (auth || cauth || channel->ban_list ||
+ (channel->mode & SILC_CHANNEL_MODE_INVITE))) {
if (cmd->pending == 2)
goto out;
- /* We must retrieve the detached client's public key by sending
+ /* We must retrieve the client's public key by sending
GETKEY command. Reprocess this packet after receiving the key */
clidp = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
silc_server_send_command(server, cmd->sock,
silc_buffer_free(clidp);
silc_server_command_pending(server, SILC_COMMAND_GETKEY,
server->cmd_ident,
- silc_server_command_join,
+ silc_server_command_join,
silc_server_command_dup(cmd));
cmd->pending = 2;
goto out;
SilcHashTableList htl;
if (channel->founder_key && idata->public_key &&
- silc_pkcs_public_key_compare(channel->founder_key,
+ silc_pkcs_public_key_compare(channel->founder_key,
idata->public_key)) {
/* Check whether the client is to become founder */
if (silc_auth_verify_data(auth, auth_len, SILC_AUTH_PUBLIC_KEY,
silc_strncat(check2, sizeof(check2),
cmd->sock->hostname, strlen(cmd->sock->hostname));
}
-
+
/* Check invite list if channel is invite-only channel */
if (channel->mode & SILC_CHANNEL_MODE_INVITE) {
if (!channel->invite_list ||
- (!silc_string_match(channel->invite_list, check) &&
- !silc_string_match(channel->invite_list, check2))) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_JOIN,
- SILC_STATUS_ERR_NOT_INVITED, 0);
+ !silc_hash_table_count(channel->invite_list) ||
+ (!silc_server_inviteban_match(server, channel->invite_list,
+ 3, client->id) &&
+ !silc_server_inviteban_match(server, channel->invite_list,
+ 2, client->data.public_key) &&
+ !silc_server_inviteban_match(server, channel->invite_list,
+ 1, client->nickname) &&
+ !silc_server_inviteban_match(server, channel->invite_list,
+ 1, check) &&
+ !silc_server_inviteban_match(server, channel->invite_list,
+ 1, check2))) {
+ chidp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_JOIN,
+ SILC_STATUS_ERR_NOT_INVITED, 0,
+ 2, chidp->data, chidp->len);
+ silc_buffer_free(chidp);
goto out;
}
}
/* Check ban list if it exists. If the client's nickname, server,
username and/or hostname is in the ban list the access to the
channel is denied. */
- if (channel->ban_list) {
- if (silc_string_match(channel->ban_list, check) ||
- silc_string_match(channel->ban_list, check2)) {
- silc_server_command_send_status_reply(
+ if (channel->ban_list && silc_hash_table_count(channel->ban_list)) {
+ if (silc_server_inviteban_match(server, channel->ban_list,
+ 3, client->id) ||
+ silc_server_inviteban_match(server, channel->ban_list,
+ 2, client->data.public_key) ||
+ silc_server_inviteban_match(server, channel->ban_list,
+ 1, client->nickname) ||
+ silc_server_inviteban_match(server, channel->ban_list,
+ 1, check) ||
+ silc_server_inviteban_match(server, channel->ban_list,
+ 1, check2)) {
+ chidp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL);
+ silc_server_command_send_status_data(
cmd, SILC_COMMAND_JOIN,
- SILC_STATUS_ERR_BANNED_FROM_CHANNEL, 0);
+ SILC_STATUS_ERR_BANNED_FROM_CHANNEL, 0,
+ 2, chidp->data, chidp->len);
+ silc_buffer_free(chidp);
goto out;
}
}
-
+
/* Check user count limit if set. */
if (channel->mode & SILC_CHANNEL_MODE_ULIMIT) {
- if (silc_hash_table_count(channel->user_list) + 1 >
+ if (silc_hash_table_count(channel->user_list) + 1 >
channel->user_limit) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_JOIN,
- SILC_STATUS_ERR_CHANNEL_IS_FULL,
- 0);
+ chidp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_JOIN,
+ SILC_STATUS_ERR_CHANNEL_IS_FULL,
+ 0, 2, chidp->data, chidp->len);
+ silc_buffer_free(chidp);
goto out;
}
}
tmp = silc_argument_get_arg_type(cmd->args, 3, &tmp_len);
if (tmp)
passphrase = silc_memdup(tmp, tmp_len);
-
+
if (!passphrase || !channel->passphrase ||
memcmp(passphrase, channel->passphrase, strlen(channel->passphrase))) {
+ chidp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_JOIN,
+ SILC_STATUS_ERR_BAD_PASSWORD, 0,
+ 2, chidp->data, chidp->len);
+ silc_buffer_free(chidp);
+ goto out;
+ }
+ }
+
+ /* Verify channel authentication with channel public keys if set. */
+ if (channel->mode & SILC_CHANNEL_MODE_CHANNEL_AUTH) {
+ if (!silc_server_verify_channel_auth(server, channel, client->id,
+ cauth, cauth_len)) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_JOIN,
- SILC_STATUS_ERR_BAD_PASSWORD, 0);
+ SILC_STATUS_ERR_PERM_DENIED, 0);
goto out;
}
}
/* Check whether the client already is on the channel */
if (silc_server_client_on_channel(client, channel, NULL)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_JOIN,
- SILC_STATUS_ERR_USER_ON_CHANNEL, 0);
+ clidp = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
+ chidp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL);
+ silc_server_command_send_status_data2(cmd, SILC_COMMAND_JOIN,
+ SILC_STATUS_ERR_USER_ON_CHANNEL, 0,
+ 2, clidp->data, clidp->len,
+ 3, chidp->data, chidp->len);
+ silc_buffer_free(clidp);
+ silc_buffer_free(chidp);
goto out;
}
/* Send the channel key. This is broadcasted to the channel but is not
sent to the client who is joining to the channel. */
if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY))
- silc_server_send_channel_key(server, NULL, channel,
- server->server_type == SILC_ROUTER ?
+ silc_server_send_channel_key(server, NULL, channel,
+ server->server_type == SILC_ROUTER ?
FALSE : !server->standalone);
}
tmp = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
cipher = silc_cipher_get_name(channel->channel_key);
keyp = silc_channel_key_payload_encode(silc_id_get_len(channel->id,
- SILC_ID_CHANNEL),
+ SILC_ID_CHANNEL),
tmp,
strlen(cipher), cipher,
channel->key_len / 8, channel->key);
if (channel->founder_key)
fkey = silc_pkcs_public_key_payload_encode(channel->founder_key);
- reply =
+ /* Encode invite list */
+ invite_list = NULL;
+ if (channel->invite_list && silc_hash_table_count(channel->invite_list)) {
+ SilcHashTableList htl;
+
+ invite_list = silc_buffer_alloc_size(2);
+ silc_buffer_format(invite_list,
+ SILC_STR_UI_SHORT(silc_hash_table_count(
+ channel->invite_list)),
+ SILC_STR_END);
+
+ silc_hash_table_list(channel->invite_list, &htl);
+ while (silc_hash_table_get(&htl, (void **)&tmp_len, (void **)&reply))
+ invite_list = silc_argument_payload_encode_one(invite_list,
+ reply->data,
+ reply->len, tmp_len);
+ silc_hash_table_list_reset(&htl);
+ }
+
+ /* Encode ban list */
+ ban_list = NULL;
+ if (channel->ban_list && silc_hash_table_count(channel->ban_list)) {
+ SilcHashTableList htl;
+
+ ban_list = silc_buffer_alloc_size(2);
+ silc_buffer_format(ban_list,
+ SILC_STR_UI_SHORT(silc_hash_table_count(
+ channel->ban_list)),
+ SILC_STR_END);
+
+ silc_hash_table_list(channel->ban_list, &htl);
+ while (silc_hash_table_get(&htl, (void **)&tmp_len, (void **)&reply))
+ ban_list = silc_argument_payload_encode_one(ban_list,
+ reply->data,
+ reply->len, tmp_len);
+ silc_hash_table_list_reset(&htl);
+ }
+
+ if (channel->channel_pubkeys)
+ chpklist = silc_server_get_channel_pk_list(server, channel, FALSE, FALSE);
+
+ reply =
silc_command_reply_payload_encode_va(SILC_COMMAND_JOIN,
- SILC_STATUS_OK, 0, ident, 14,
+ SILC_STATUS_OK, 0, ident, 15,
2, channel->channel_name,
strlen(channel->channel_name),
3, chidp->data, chidp->len,
4, clidp->data, clidp->len,
5, mode, 4,
6, tmp2, 4,
- 7, keyp ? keyp->data : NULL,
+ 7, keyp ? keyp->data : NULL,
keyp ? keyp->len : 0,
- 8, channel->ban_list,
- channel->ban_list ?
- strlen(channel->ban_list) : 0,
- 9, channel->invite_list,
- channel->invite_list ?
- strlen(channel->invite_list) : 0,
+ 8, ban_list ? ban_list->data : NULL,
+ ban_list ? ban_list->len : 0,
+ 9, invite_list ? invite_list->data :
+ NULL,
+ invite_list ? invite_list->len : 0,
10, channel->topic,
channel->topic ?
strlen(channel->topic) : 0,
hmac)),
12, tmp3, 4,
13, user_list->data, user_list->len,
- 14, mode_list->data,
+ 14, mode_list->data,
mode_list->len,
15, fkey ? fkey->data : NULL,
- fkey ? fkey->len : 0);
+ fkey ? fkey->len : 0,
+ 16, chpklist ? chpklist->data : NULL,
+ chpklist ? chpklist->len : 0);
/* Send command reply */
- silc_server_packet_send(server, sock, SILC_PACKET_COMMAND_REPLY, 0,
+ silc_server_packet_send(server, sock, SILC_PACKET_COMMAND_REPLY, 0,
reply->data, reply->len, FALSE);
/* Send JOIN notify to locally connected clients on the channel. If
we are router then this will send it to local clients and local
servers. */
SILC_LOG_DEBUG(("Send JOIN notify to channel"));
- silc_server_send_notify_to_channel(server, NULL, channel, FALSE,
+ silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
SILC_NOTIFY_TYPE_JOIN, 2,
clidp->data, clidp->len,
chidp->data, chidp->len);
if (founder) {
SILC_PUT32_MSB(chl->mode, mode);
SILC_LOG_DEBUG(("Send CUMODE_CHANGE notify to channel"));
- silc_server_send_notify_to_channel(server, NULL, channel, FALSE,
+ silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
SILC_NOTIFY_TYPE_CUMODE_CHANGE, 4,
clidp->data, clidp->len,
mode, 4, clidp->data, clidp->len,
silc_buffer_free(user_list);
silc_buffer_free(mode_list);
silc_buffer_free(fkey);
+ silc_buffer_free(chpklist);
+ silc_buffer_free(invite_list);
+ silc_buffer_free(ban_list);
out:
+ if (passphrase)
+ memset(passphrase, 0, strlen(passphrase));
silc_free(passphrase);
}
-/* Server side of command JOIN. Joins client into requested channel. If
+/* Server side of command JOIN. Joins client into requested channel. If
the channel does not exist it will be created. */
SILC_SERVER_CMD_FUNC(join)
{
SilcServerCommandContext cmd = (SilcServerCommandContext)context;
SilcServer server = cmd->server;
- unsigned char *auth;
- SilcUInt32 tmp_len, auth_len;
+ unsigned char *auth, *cauth;
+ SilcUInt32 tmp_len, auth_len, cauth_len;
char *tmp, *channel_name = NULL, *cipher, *hmac;
SilcChannelEntry channel;
SilcUInt32 umode = 0;
bool created = FALSE, create_key = TRUE;
SilcClientID *client_id;
- SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_JOIN, cmd, 2, 6);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_JOIN, cmd, 2, 7);
/* Get channel name */
tmp = silc_argument_get_arg_type(cmd->args, 1, &tmp_len);
if (tmp_len > 256)
channel_name[255] = '\0';
- if (silc_server_name_bad_chars(channel_name, tmp_len) == TRUE) {
+ if (silc_server_name_bad_chchars(channel_name, tmp_len) == TRUE) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_JOIN,
SILC_STATUS_ERR_BAD_CHANNEL, 0);
goto out;
cipher = silc_argument_get_arg_type(cmd->args, 4, NULL);
hmac = silc_argument_get_arg_type(cmd->args, 5, NULL);
auth = silc_argument_get_arg_type(cmd->args, 6, &auth_len);
+ cauth = silc_argument_get_arg_type(cmd->args, 7, &cauth_len);
/* See if the channel exists */
- channel = silc_idlist_find_channel_by_name(server->local_list,
+ channel = silc_idlist_find_channel_by_name(server->local_list,
channel_name, NULL);
if (cmd->sock->type == SILC_SOCKET_TYPE_CLIENT) {
silc_free(client_id);
client_id = silc_id_dup(entry->id, SILC_ID_CLIENT);
- if (!channel ||
+ if (!channel ||
(channel->disabled && server->server_type != SILC_ROUTER)) {
/* Channel not found or not valid */
- /* If we are standalone server we don't have a router, we just create
+ /* If we are standalone server we don't have a router, we just create
the channel by ourselves (unless it existed). */
if (server->standalone) {
if (!channel) {
- channel = silc_server_create_new_channel(server, server->id, cipher,
+ channel = silc_server_create_new_channel(server, server->id, cipher,
hmac, channel_name, TRUE);
if (!channel) {
- silc_server_command_send_status_reply(
+ silc_server_command_send_status_data(
cmd, SILC_COMMAND_JOIN,
SILC_STATUS_ERR_UNKNOWN_ALGORITHM,
- 0);
+ 0, 2, cipher, strlen(cipher));
silc_free(client_id);
goto out;
}
-
+
umode = (SILC_CHANNEL_UMODE_CHANOP | SILC_CHANNEL_UMODE_CHANFO);
created = TRUE;
create_key = FALSE;
}
} else {
- /* The channel does not exist on our server. If we are normal server
+ /* The channel does not exist on our server. If we are normal server
we will send JOIN command to our router which will handle the
- joining procedure (either creates the channel if it doesn't exist
+ joining procedure (either creates the channel if it doesn't exist
or joins the client to it). */
if (server->server_type != SILC_ROUTER) {
SilcBuffer tmpbuf;
silc_free(client_id);
goto out;
}
-
+
old_ident = silc_command_get_ident(cmd->payload);
silc_command_set_ident(cmd->payload, ++server->cmd_ident);
tmpbuf = silc_command_payload_encode_payload(cmd->payload);
-
+
/* Send JOIN command to our router */
silc_server_packet_send(server, (SilcSocketConnection)
SILC_PRIMARY_ROUTE(server),
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_JOIN,
+ silc_server_command_pending(server, SILC_COMMAND_JOIN,
silc_command_get_ident(cmd->payload),
silc_server_command_join,
silc_server_command_dup(cmd));
silc_free(client_id);
goto out;
}
-
+
/* 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 = silc_idlist_find_channel_by_name(server->global_list,
channel_name, NULL);
if (!channel) {
/* Channel really does not exist, create it */
- channel = silc_server_create_new_channel(server, server->id, cipher,
+ channel = silc_server_create_new_channel(server, server->id, cipher,
hmac, channel_name, TRUE);
if (!channel) {
- silc_server_command_send_status_reply(
+ silc_server_command_send_status_data(
cmd, SILC_COMMAND_JOIN,
- SILC_STATUS_ERR_UNKNOWN_ALGORITHM, 0);
+ SILC_STATUS_ERR_UNKNOWN_ALGORITHM, 0,
+ 2, cipher, strlen(cipher));
silc_free(client_id);
goto out;
}
silc_free(client_id);
goto out;
}
-
+
/* 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 = silc_idlist_find_channel_by_name(server->global_list,
channel_name, NULL);
if (!channel) {
/* Channel really does not exist, create it */
- channel = silc_server_create_new_channel(server, server->id, cipher,
+ channel = silc_server_create_new_channel(server, server->id, cipher,
hmac, channel_name, TRUE);
if (!channel) {
- silc_server_command_send_status_reply(
+ silc_server_command_send_status_data(
cmd, SILC_COMMAND_JOIN,
- SILC_STATUS_ERR_UNKNOWN_ALGORITHM, 0);
+ SILC_STATUS_ERR_UNKNOWN_ALGORITHM, 0,
+ 2, cipher, strlen(cipher));
silc_free(client_id);
goto out;
}
/* Join to the channel */
silc_server_command_join_channel(server, cmd, channel, client_id,
created, create_key, umode,
- auth, auth_len);
+ auth, auth_len, cauth, cauth_len);
silc_free(client_id);
char *motd, *dest_server;
SilcUInt32 motd_len;
SilcUInt16 ident = silc_command_get_ident(cmd->payload);
-
+
SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_MOTD, cmd, 1, 1);
/* Get server name */
dest_server = silc_argument_get_arg_type(cmd->args, 1, NULL);
if (!dest_server) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_MOTD,
- SILC_STATUS_ERR_NO_SUCH_SERVER, 0);
+ SILC_STATUS_ERR_NOT_ENOUGH_PARAMS,
+ 0);
goto out;
}
&motd_len);
if (!motd)
goto out;
-
+
motd[motd_len] = 0;
packet = silc_command_reply_payload_encode_va(SILC_COMMAND_MOTD,
- SILC_STATUS_OK, 0,
+ SILC_STATUS_OK, 0,
ident, 2,
2, idp, idp->len,
3, motd, motd_len);
} else {
/* No motd */
packet = silc_command_reply_payload_encode_va(SILC_COMMAND_MOTD,
- SILC_STATUS_OK, 0,
+ SILC_STATUS_OK, 0,
ident, 1,
2, idp, idp->len);
}
- silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
+ 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);
dest_server, TRUE, NULL);
}
- if (server->server_type != SILC_SERVER && !cmd->pending &&
+ if (server->server_type != SILC_SERVER && !cmd->pending &&
entry && !entry->motd) {
/* Send to the server */
SilcBuffer tmpbuf;
tmpbuf->data, tmpbuf->len, TRUE);
/* Reprocess this packet after received reply from router */
- silc_server_command_pending(server, SILC_COMMAND_MOTD,
+ silc_server_command_pending(server, SILC_COMMAND_MOTD,
silc_command_get_ident(cmd->payload),
silc_server_command_motd,
silc_server_command_dup(cmd));
tmpbuf->data, tmpbuf->len, TRUE);
/* Reprocess this packet after received reply from router */
- silc_server_command_pending(server, SILC_COMMAND_MOTD,
+ silc_server_command_pending(server, SILC_COMMAND_MOTD,
silc_command_get_ident(cmd->payload),
silc_server_command_motd,
silc_server_command_dup(cmd));
}
if (!entry) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_MOTD,
- SILC_STATUS_ERR_NO_SUCH_SERVER, 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_MOTD,
+ SILC_STATUS_ERR_NO_SUCH_SERVER, 0,
+ 2, dest_server,
+ strlen(dest_server));
goto out;
}
SILC_STATUS_OK, 0, ident, 2,
2, idp, idp->len,
3, entry->motd,
- entry->motd ?
+ entry->motd ?
strlen(entry->motd) : 0);
- silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
+ 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);
packet = silc_command_reply_payload_encode_va(SILC_COMMAND_UMODE,
SILC_STATUS_OK, 0, ident, 1,
2, m, sizeof(m));
- silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
+ silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
packet->data, packet->len, FALSE);
silc_buffer_free(packet);
SilcChannelEntry channel;
SilcChannelClientEntry chl;
SilcBuffer packet, cidp;
- unsigned char *tmp, *tmp_id, *tmp_mask;
+ unsigned char *tmp, *tmp_id, *tmp_mask, *chpkdata = NULL;
char *cipher = NULL, *hmac = NULL, *passphrase = NULL;
- SilcUInt32 mode_mask = 0, old_mask = 0, tmp_len, tmp_len2;
+ SilcUInt32 mode_mask = 0, old_mask = 0, tmp_len, tmp_len2, chpklen;
SilcUInt16 ident = silc_command_get_ident(cmd->payload);
- bool set_mask = FALSE;
+ bool set_mask = FALSE, set_chpk = FALSE;
SilcPublicKey founder_key = NULL;
- SilcBuffer fkey = NULL;
+ SilcBuffer fkey = NULL, chpklist = NULL;
+ SilcBufferStruct chpk;
if (!client) {
silc_server_command_free(cmd);
return;
}
- SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_CMODE, cmd, 1, 7);
+ SILC_SERVER_COMMAND_CHECK(SILC_COMMAND_CMODE, cmd, 1, 9);
/* Get Channel ID */
tmp_id = silc_argument_get_arg_type(cmd->args, 1, &tmp_len2);
}
/* Get channel entry */
- channel = silc_idlist_find_channel_by_id(server->local_list,
+ channel = silc_idlist_find_channel_by_id(server->local_list,
channel_id, NULL);
if (!channel) {
- channel = silc_idlist_find_channel_by_id(server->global_list,
+ channel = silc_idlist_find_channel_by_id(server->global_list,
channel_id, NULL);
if (!channel) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_CMODE,
- SILC_STATUS_ERR_NO_SUCH_CHANNEL,
- 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_CMODE,
+ SILC_STATUS_ERR_NO_SUCH_CHANNEL_ID,
+ 0, 2, tmp_id, tmp_len2);
silc_free(channel_id);
silc_server_command_free(cmd);
return;
/* Check whether this client is on the channel */
if (!silc_server_client_on_channel(client, channel, &chl)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_CMODE,
- SILC_STATUS_ERR_NOT_ON_CHANNEL, 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_CMODE,
+ SILC_STATUS_ERR_NOT_ON_CHANNEL, 0,
+ 2, tmp_id, tmp_len2);
goto out;
}
/* Check that client has rights to change any requested channel modes */
- if (set_mask && !silc_server_check_cmode_rights(server, channel, chl,
+ if (set_mask && !silc_server_check_cmode_rights(server, channel, chl,
mode_mask)) {
SILC_LOG_DEBUG(("Client does not have rights to change mode"));
- silc_server_command_send_status_reply(
+ silc_server_command_send_status_data(
cmd, SILC_COMMAND_CMODE,
- (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) ?
+ (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) ?
SILC_STATUS_ERR_NO_CHANNEL_PRIV :
- SILC_STATUS_ERR_NO_CHANNEL_FOPRIV), 0);
+ SILC_STATUS_ERR_NO_CHANNEL_FOPRIV), 0,
+ 2, tmp_id, tmp_len2);
goto out;
}
/* If mode mask was not sent as argument then merely return the current
- mode mask to the sender. */
+ mode mask, founder key and channel public key list to the sender. */
if (!set_mask) {
unsigned char m[4];
SILC_PUT32_MSB(channel->mode, m);
- packet = silc_command_reply_payload_encode_va(SILC_COMMAND_CMODE,
- SILC_STATUS_OK, 0, ident, 2,
- 2, tmp_id, tmp_len2,
- 3, m, sizeof(m));
+ if (channel->founder_key)
+ fkey = silc_pkcs_public_key_payload_encode(channel->founder_key);
+ if (channel->channel_pubkeys)
+ chpklist = silc_server_get_channel_pk_list(server, channel,
+ FALSE, FALSE);
+ packet =
+ silc_command_reply_payload_encode_va(SILC_COMMAND_CMODE,
+ SILC_STATUS_OK, 0, ident, 4,
+ 2, tmp_id, tmp_len2,
+ 3, m, sizeof(m),
+ 4, fkey ? fkey->data : NULL,
+ fkey ? fkey->len : 0,
+ 5, chpklist ? chpklist->data : NULL,
+ chpklist ? chpklist->len : 0);
silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
packet->data, packet->len, FALSE);
silc_buffer_free(packet);
/* The mode is removed and we need to generate and distribute
new channel key. Clients are not using private channel keys
anymore after this. */
-
+
/* Re-generate channel key */
if (!silc_server_create_channel_key(server, channel, 0))
goto out;
-
+
/* Send the channel key. This sends it to our local clients and if
we are normal server to our router as well. */
- silc_server_send_channel_key(server, NULL, channel,
- server->server_type == SILC_ROUTER ?
+ silc_server_send_channel_key(server, NULL, channel,
+ server->server_type == SILC_ROUTER ?
FALSE : !server->standalone);
cipher = (char *)silc_cipher_get_name(channel->channel_key);
if (mode_mask & SILC_CHANNEL_MODE_ULIMIT) {
/* User limit is set on channel */
SilcUInt32 user_limit;
-
+
/* Get user limit */
tmp = silc_argument_get_arg_type(cmd->args, 3, NULL);
if (!tmp) {
if (mode_mask & SILC_CHANNEL_MODE_PASSPHRASE) {
if (!(channel->mode & SILC_CHANNEL_MODE_PASSPHRASE)) {
/* Passphrase has been set to channel */
-
+
/* Get the passphrase */
tmp = silc_argument_get_arg_type(cmd->args, 4, NULL);
if (!tmp) {
/* Delete old cipher and allocate the new one */
if (!silc_cipher_alloc(cipher, &newkey)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_CMODE,
- SILC_STATUS_ERR_UNKNOWN_ALGORITHM, 0);
+ silc_server_command_send_status_data(
+ cmd, SILC_COMMAND_CMODE,
+ SILC_STATUS_ERR_UNKNOWN_ALGORITHM, 0,
+ 2, cipher, strlen(cipher));
goto out;
}
/* Send the channel key. This sends it to our local clients and if
we are normal server to our router as well. */
- silc_server_send_channel_key(server, NULL, channel,
- server->server_type == SILC_ROUTER ?
+ silc_server_send_channel_key(server, NULL, channel,
+ server->server_type == SILC_ROUTER ?
FALSE : !server->standalone);
}
} else {
if (channel->mode & SILC_CHANNEL_MODE_CIPHER) {
- /* Cipher mode is unset. Remove the cipher and revert back to
+ /* Cipher mode is unset. Remove the cipher and revert back to
default cipher */
SilcCipher newkey, oldkey;
cipher = channel->cipher;
/* Delete old cipher and allocate default one */
if (!silc_cipher_alloc(cipher ? cipher : SILC_DEFAULT_CIPHER, &newkey)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_CMODE,
- SILC_STATUS_ERR_UNKNOWN_ALGORITHM, 0);
+ silc_server_command_send_status_data(
+ cmd, SILC_COMMAND_CMODE,
+ SILC_STATUS_ERR_UNKNOWN_ALGORITHM, 0,
+ 2, cipher, strlen(cipher));
goto out;
}
channel->channel_key = oldkey;
goto out;
}
-
+
/* Remove old channel key for good */
silc_cipher_free(oldkey);
/* Send the channel key. This sends it to our local clients and if
we are normal server to our router as well. */
- silc_server_send_channel_key(server, NULL, channel,
- server->server_type == SILC_ROUTER ?
+ silc_server_send_channel_key(server, NULL, channel,
+ server->server_type == SILC_ROUTER ?
FALSE : !server->standalone);
}
}
/* Delete old hmac and allocate the new one */
if (!silc_hmac_alloc(hmac, NULL, &newhmac)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_CMODE,
- SILC_STATUS_ERR_UNKNOWN_ALGORITHM, 0);
+ silc_server_command_send_status_data(
+ cmd, SILC_COMMAND_CMODE,
+ SILC_STATUS_ERR_UNKNOWN_ALGORITHM, 0,
+ 2, hmac, strlen(hmac));
goto out;
}
/* Set the HMAC key out of current channel key. The client must do
this locally. */
- silc_hash_make(silc_hmac_get_hash(channel->hmac), channel->key,
+ silc_hash_make(silc_hmac_get_hash(channel->hmac), channel->key,
channel->key_len / 8, hash);
- silc_hmac_set_key(channel->hmac, hash,
+ silc_hmac_set_key(channel->hmac, hash,
silc_hash_len(silc_hmac_get_hash(channel->hmac)));
memset(hash, 0, sizeof(hash));
}
} else {
if (channel->mode & SILC_CHANNEL_MODE_HMAC) {
- /* Hmac mode is unset. Remove the hmac and revert back to
+ /* Hmac mode is unset. Remove the hmac and revert back to
default hmac */
SilcHmac newhmac;
unsigned char hash[32];
hmac = channel->hmac_name;
/* Delete old hmac and allocate default one */
- silc_hmac_free(channel->hmac);
if (!silc_hmac_alloc(hmac ? hmac : SILC_DEFAULT_HMAC, NULL, &newhmac)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_CMODE,
- SILC_STATUS_ERR_UNKNOWN_ALGORITHM, 0);
+ silc_server_command_send_status_data(
+ cmd, SILC_COMMAND_CMODE,
+ SILC_STATUS_ERR_UNKNOWN_ALGORITHM, 0,
+ 2, hmac, strlen(hmac));
goto out;
}
/* Set the HMAC key out of current channel key. The client must do
this locally. */
- silc_hash_make(silc_hmac_get_hash(channel->hmac), channel->key,
- channel->key_len / 8,
+ silc_hash_make(silc_hmac_get_hash(channel->hmac), channel->key,
+ channel->key_len / 8,
hash);
- silc_hmac_set_key(channel->hmac, hash,
+ silc_hmac_set_key(channel->hmac, hash,
silc_hash_len(silc_hmac_get_hash(channel->hmac)));
memset(hash, 0, sizeof(hash));
}
if (mode_mask & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
if (chl->mode & SILC_CHANNEL_UMODE_CHANFO) {
- if (!(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
- /* Set the founder authentication */
- tmp = silc_argument_get_arg_type(cmd->args, 7, &tmp_len);
- if (!tmp) {
- silc_server_command_send_status_reply(
- cmd, SILC_COMMAND_CMODE,
- SILC_STATUS_ERR_NOT_ENOUGH_PARAMS, 0);
- goto out;
- }
-
- /* Verify the payload before setting the mode */
- if (!silc_auth_verify_data(tmp, tmp_len, SILC_AUTH_PUBLIC_KEY,
- idata->public_key, 0, server->sha1hash,
- client->id, SILC_ID_CLIENT)) {
+ /* Check if the founder public key was received */
+ founder_key = idata->public_key;
+ tmp = silc_argument_get_arg_type(cmd->args, 8, &tmp_len);
+ if (tmp) {
+ if (!silc_pkcs_public_key_payload_decode(tmp, tmp_len, &founder_key)) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_CMODE,
SILC_STATUS_ERR_AUTH_FAILED,
0);
goto out;
}
+ } else {
+ /* If key was not sent and the channel mode has already founder
+ then the key was not to be changed. */
+ if (channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)
+ goto has_founder;
+ }
- /* Save the public key */
- channel->founder_key = silc_pkcs_public_key_copy(idata->public_key);
- if (!channel->founder_key) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_CMODE,
- SILC_STATUS_ERR_AUTH_FAILED,
- 0);
- goto out;
- }
+ /* Set the founder authentication */
+ tmp = silc_argument_get_arg_type(cmd->args, 7, &tmp_len);
+ if (!tmp) {
+ silc_server_command_send_status_reply(
+ cmd, SILC_COMMAND_CMODE,
+ SILC_STATUS_ERR_NOT_ENOUGH_PARAMS, 0);
+ goto out;
+ }
- founder_key = channel->founder_key;
- fkey = silc_pkcs_public_key_payload_encode(founder_key);
- if (!fkey) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_CMODE,
- SILC_STATUS_ERR_AUTH_FAILED,
- 0);
- silc_pkcs_public_key_free(channel->founder_key);
- channel->founder_key = NULL;
- goto out;
- }
+ /* Verify the payload before setting the mode */
+ if (!silc_auth_verify_data(tmp, tmp_len, SILC_AUTH_PUBLIC_KEY,
+ founder_key, 0, server->sha1hash,
+ client->id, SILC_ID_CLIENT)) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_CMODE,
+ SILC_STATUS_ERR_AUTH_FAILED,
+ 0);
+ goto out;
}
+
+ /* Save the public key */
+ if (channel->founder_key)
+ silc_pkcs_public_key_free(channel->founder_key);
+ if (silc_argument_get_arg_type(cmd->args, 8, NULL))
+ channel->founder_key = founder_key;
+ else
+ channel->founder_key = silc_pkcs_public_key_copy(founder_key);
+ if (!channel->founder_key) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_CMODE,
+ SILC_STATUS_ERR_AUTH_FAILED,
+ 0);
+ goto out;
+ }
+
+ fkey = silc_pkcs_public_key_payload_encode(channel->founder_key);
+ if (!fkey) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_CMODE,
+ SILC_STATUS_ERR_AUTH_FAILED,
+ 0);
+ silc_pkcs_public_key_free(channel->founder_key);
+ channel->founder_key = NULL;
+ goto out;
+ }
+ has_founder:
}
} else {
if (chl->mode & SILC_CHANNEL_UMODE_CHANFO) {
}
}
+ if (mode_mask & SILC_CHANNEL_MODE_CHANNEL_AUTH) {
+ if (chl->mode & SILC_CHANNEL_UMODE_CHANFO) {
+ SilcStatus st;
+
+ chpkdata = silc_argument_get_arg_type(cmd->args, 9, &chpklen);
+
+ if (!chpkdata && channel->mode & SILC_CHANNEL_MODE_CHANNEL_AUTH)
+ goto has_pk_list;
+
+ set_chpk = TRUE;
+
+ /* Process the channel public key(s) */
+ st = silc_server_set_channel_pk_list(server, NULL, channel,
+ chpkdata, chpklen);
+ if (st != SILC_STATUS_OK) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_CMODE, st, 0);
+ goto out;
+ }
+ has_pk_list:
+ }
+ } else {
+ if (chl->mode & SILC_CHANNEL_UMODE_CHANFO) {
+ if (channel->mode & SILC_CHANNEL_MODE_CHANNEL_AUTH) {
+ if (channel->channel_pubkeys)
+ silc_hash_table_free(channel->channel_pubkeys);
+ channel->channel_pubkeys = NULL;
+ set_chpk = TRUE;
+ }
+ }
+ }
+
/* Finally, set the mode */
old_mask = channel->mode = mode_mask;
/* Send CMODE_CHANGE notify. */
cidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
- silc_server_send_notify_to_channel(server, NULL, channel, FALSE,
- SILC_NOTIFY_TYPE_CMODE_CHANGE, 6,
- cidp->data, cidp->len,
+ silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
+ SILC_NOTIFY_TYPE_CMODE_CHANGE, 7,
+ cidp->data, cidp->len,
tmp_mask, 4,
cipher, cipher ? strlen(cipher) : 0,
hmac, hmac ? strlen(hmac) : 0,
- passphrase, passphrase ?
+ passphrase, passphrase ?
strlen(passphrase) : 0,
fkey ? fkey->data : NULL,
- fkey ? fkey->len : 0);
+ fkey ? fkey->len : 0,
+ chpkdata ? chpkdata : NULL,
+ chpkdata ? chpklen : 0);
/* Set CMODE notify type to network */
+ if (chpkdata && chpklen)
+ silc_buffer_set(&chpk, chpkdata, chpklen);
silc_server_send_notify_cmode(server, SILC_PRIMARY_ROUTE(server),
SILC_BROADCAST(server), channel,
mode_mask, client->id, SILC_ID_CLIENT,
- cipher, hmac, passphrase, founder_key);
+ cipher, hmac, passphrase, founder_key,
+ chpkdata ? &chpk : NULL);
+
+ if (set_chpk)
+ chpklist = silc_server_get_channel_pk_list(server, channel, FALSE, FALSE);
/* Send command reply to sender */
packet = silc_command_reply_payload_encode_va(SILC_COMMAND_CMODE,
- SILC_STATUS_OK, 0, ident, 2,
+ SILC_STATUS_OK, 0, ident, 4,
2, tmp_id, tmp_len2,
- 3, tmp_mask, 4);
- silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
+ 3, tmp_mask, 4,
+ 4, fkey ? fkey->data : NULL,
+ fkey ? fkey->len : 0,
+ 5, chpklist ? chpklist->data :
+ NULL, chpklist ? chpklist->len
+ : 0);
+ silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
packet->data, packet->len, FALSE);
silc_buffer_free(packet);
out:
channel->mode = old_mask;
+ silc_buffer_free(chpklist);
silc_buffer_free(fkey);
silc_free(channel_id);
silc_server_command_free(cmd);
SilcServerCommandContext cmd = (SilcServerCommandContext)context;
SilcServer server = cmd->server;
SilcClientEntry client = (SilcClientEntry)cmd->sock->user_data;
- SilcIDListData idata = (SilcIDListData)client;
SilcChannelID *channel_id = NULL;
SilcClientID *client_id = NULL;
SilcChannelEntry channel;
}
/* Get channel entry */
- channel = silc_idlist_find_channel_by_id(server->local_list,
+ channel = silc_idlist_find_channel_by_id(server->local_list,
channel_id, NULL);
if (!channel) {
- channel = silc_idlist_find_channel_by_id(server->global_list,
+ channel = silc_idlist_find_channel_by_id(server->global_list,
channel_id, NULL);
if (!channel) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_CUMODE,
- SILC_STATUS_ERR_NO_SUCH_CHANNEL,
- 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_CUMODE,
+ SILC_STATUS_ERR_NO_SUCH_CHANNEL_ID,
+ 0, 2, tmp_ch_id, tmp_ch_len);
goto out;
}
}
/* Check whether sender is on the channel */
if (!silc_server_client_on_channel(client, channel, &chl)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_CUMODE,
- SILC_STATUS_ERR_NOT_ON_CHANNEL, 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_CUMODE,
+ SILC_STATUS_ERR_NOT_ON_CHANNEL, 0,
+ 2, tmp_ch_id, tmp_ch_len);
goto out;
}
sender_mask = chl->mode;
-
+
/* Get the target client's channel mode mask */
tmp_mask = silc_argument_get_arg_type(cmd->args, 2, NULL);
if (!tmp_mask) {
}
/* Get target client's entry */
- target_client = silc_idlist_find_client_by_id(server->local_list,
+ target_client = silc_idlist_find_client_by_id(server->local_list,
client_id, TRUE, NULL);
if (!target_client) {
- target_client = silc_idlist_find_client_by_id(server->global_list,
+ target_client = silc_idlist_find_client_by_id(server->global_list,
client_id, TRUE, NULL);
}
if (target_client != client &&
!(sender_mask & SILC_CHANNEL_UMODE_CHANFO) &&
!(sender_mask & SILC_CHANNEL_UMODE_CHANOP)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_CUMODE,
- SILC_STATUS_ERR_NO_CHANNEL_PRIV, 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_CUMODE,
+ SILC_STATUS_ERR_NO_CHANNEL_PRIV, 0,
+ 2, tmp_ch_id, tmp_ch_len);
goto out;
}
/* Check whether target client is on the channel */
if (target_client != client) {
if (!silc_server_client_on_channel(target_client, channel, &chl)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_CUMODE,
- SILC_STATUS_ERR_USER_NOT_ON_CHANNEL, 0);
+ silc_server_command_send_status_data2(
+ cmd, SILC_COMMAND_CUMODE,
+ SILC_STATUS_ERR_USER_NOT_ON_CHANNEL, 0,
+ 2, tmp_id, tmp_len,
+ 3, tmp_ch_id, tmp_ch_len);
goto out;
}
}
- /*
- * Change the mode
+ /*
+ * Change the mode
*/
/* If the target client is founder, no one else can change their mode
but themselves. */
if (chl->mode & SILC_CHANNEL_UMODE_CHANFO && client != target_client) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_CUMODE,
- SILC_STATUS_ERR_NO_CHANNEL_FOPRIV,
- 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_CUMODE,
+ SILC_STATUS_ERR_NO_CHANNEL_FOPRIV,
+ 0, 2, tmp_ch_id, tmp_ch_len);
goto out;
}
SilcHashTableList htl;
if (!(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) ||
- !channel->founder_key || !idata->public_key ||
- !silc_pkcs_public_key_compare(channel->founder_key,
- idata->public_key)) {
+ !channel->founder_key) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_CUMODE,
SILC_STATUS_ERR_AUTH_FAILED, 0);
goto out;
if (target_mask & SILC_CHANNEL_UMODE_CHANOP) {
/* Promote to operator */
if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP)) {
- if (!(sender_mask & SILC_CHANNEL_UMODE_CHANOP) &&
+ if (!(sender_mask & SILC_CHANNEL_UMODE_CHANOP) &&
!(sender_mask & SILC_CHANNEL_UMODE_CHANFO)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_CUMODE,
- SILC_STATUS_ERR_NO_CHANNEL_PRIV,
- 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_CUMODE,
+ SILC_STATUS_ERR_NO_CHANNEL_PRIV,
+ 0, 2, tmp_ch_id, tmp_ch_len);
goto out;
}
if (chl->mode & SILC_CHANNEL_UMODE_CHANOP) {
if (!(sender_mask & SILC_CHANNEL_UMODE_CHANOP) &&
!(sender_mask & SILC_CHANNEL_UMODE_CHANFO)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_CUMODE,
- SILC_STATUS_ERR_NO_CHANNEL_PRIV,
- 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_CUMODE,
+ SILC_STATUS_ERR_NO_CHANNEL_PRIV,
+ 0, 2, tmp_ch_id, tmp_ch_len);
goto out;
}
-
+
/* Demote to normal user */
chl->mode &= ~SILC_CHANNEL_UMODE_CHANOP;
notify = TRUE;
/* Send notify to channel, notify only if mode was actually changed. */
if (notify) {
- silc_server_send_notify_to_channel(server, NULL, channel, FALSE,
+ silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
SILC_NOTIFY_TYPE_CUMODE_CHANGE, 4,
idp->data, idp->len,
- tmp_mask, 4,
+ tmp_mask, 4,
tmp_id, tmp_len,
fkey ? fkey->data : NULL,
fkey ? fkey->len : 0);
2, tmp_mask, 4,
3, tmp_ch_id, tmp_ch_len,
4, tmp_id, tmp_len);
- silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
+ 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);
SilcClientID *client_id;
SilcChannelEntry channel;
SilcChannelClientEntry chl;
- SilcBuffer idp;
- SilcUInt32 tmp_len, target_idp_len;
+ SilcBuffer idp, packet;
+ SilcUInt32 tmp_len, target_idp_len, clen;
+ SilcUInt16 ident = silc_command_get_ident(cmd->payload);
unsigned char *tmp, *comment, *target_idp;
if (!client)
}
channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
if (!channel_id) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_KICK,
- SILC_STATUS_ERR_NO_CHANNEL_ID, 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_KICK,
+ SILC_STATUS_ERR_BAD_CHANNEL_ID, 0,
+ 2, tmp, tmp_len);
goto out;
}
/* Get channel entry */
- channel = silc_idlist_find_channel_by_id(server->local_list,
+ channel = silc_idlist_find_channel_by_id(server->local_list,
channel_id, NULL);
if (!channel) {
- channel = silc_idlist_find_channel_by_id(server->local_list,
+ channel = silc_idlist_find_channel_by_id(server->local_list,
channel_id, NULL);
if (!channel) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_KICK,
- SILC_STATUS_ERR_NO_SUCH_CHANNEL,
- 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_KICK,
+ SILC_STATUS_ERR_NO_SUCH_CHANNEL_ID,
+ 0, 2, tmp, tmp_len);
goto out;
}
}
/* Check whether sender is on the channel */
if (!silc_server_client_on_channel(client, channel, &chl)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_KICK,
- SILC_STATUS_ERR_NOT_ON_CHANNEL, 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_KICK,
+ SILC_STATUS_ERR_NOT_ON_CHANNEL,
+ 0, 2, tmp, tmp_len);
goto out;
}
/* Check that the kicker is channel operator or channel founder */
if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
!(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_KICK,
- SILC_STATUS_ERR_NO_CHANNEL_PRIV, 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_KICK,
+ SILC_STATUS_ERR_NO_CHANNEL_PRIV,
+ 0, 2, tmp, tmp_len);
goto out;
}
-
+
/* Get target Client ID */
target_idp = silc_argument_get_arg_type(cmd->args, 2, &target_idp_len);
if (!target_idp) {
}
client_id = silc_id_payload_parse_id(target_idp, target_idp_len, NULL);
if (!client_id) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_KICK,
- SILC_STATUS_ERR_NO_CLIENT_ID, 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_KICK,
+ SILC_STATUS_ERR_BAD_CLIENT_ID,
+ 0, 2, target_idp, target_idp_len);
goto out;
}
/* Get target client's entry */
- target_client = silc_idlist_find_client_by_id(server->local_list,
+ target_client = silc_idlist_find_client_by_id(server->local_list,
client_id, TRUE, NULL);
if (!target_client) {
- target_client = silc_idlist_find_client_by_id(server->global_list,
+ target_client = silc_idlist_find_client_by_id(server->global_list,
client_id, TRUE, NULL);
}
/* Check whether target client is on the channel */
if (!silc_server_client_on_channel(target_client, channel, &chl)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_KICK,
+ silc_server_command_send_status_data2(cmd, SILC_COMMAND_KICK,
SILC_STATUS_ERR_USER_NOT_ON_CHANNEL,
- 0);
+ 0, 2, target_idp, target_idp_len,
+ 3, tmp, tmp_len);
goto out;
}
/* Check that the target client is not channel founder. Channel founder
cannot be kicked from the channel. */
if (chl->mode & SILC_CHANNEL_UMODE_CHANFO) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_KICK,
- SILC_STATUS_ERR_NO_CHANNEL_FOPRIV,
- 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_KICK,
+ SILC_STATUS_ERR_NO_CHANNEL_FOPRIV,
+ 0, 2, tmp, tmp_len);
goto out;
}
-
+
/* Get comment */
- tmp_len = 0;
- comment = silc_argument_get_arg_type(cmd->args, 3, &tmp_len);
- if (tmp_len > 128)
+ comment = silc_argument_get_arg_type(cmd->args, 3, &clen);
+ if (clen > 128)
comment = NULL;
+
+ /* Send the reply back to the client */
+ packet =
+ silc_command_reply_payload_encode_va(SILC_COMMAND_KICK,
+ SILC_STATUS_OK, 0, ident, 2,
+ 2, tmp, tmp_len,
+ 3, target_idp, target_idp_len);
+ silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
+ packet->data, packet->len, FALSE);
+ silc_buffer_free(packet);
+
/* Send command reply to sender */
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_KICK,
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_KICK,
SILC_STATUS_OK, 0);
/* Send KICKED notify to local clients on the channel */
idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
- silc_server_send_notify_to_channel(server, NULL, channel, FALSE,
+ silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
SILC_NOTIFY_TYPE_KICKED, 3,
target_idp, target_idp_len,
comment, comment ? strlen(comment) : 0,
SILC_BROADCAST(server), channel,
target_client->id, client->id, comment);
+ /* Remove the client from channel's invite list */
+ if (channel->invite_list && silc_hash_table_count(channel->invite_list)) {
+ SilcBuffer ab =
+ silc_argument_payload_encode_one(NULL, target_idp, target_idp_len, 3);
+ SilcArgumentPayload args =
+ silc_argument_payload_parse(ab->data, ab->len, 1);
+ silc_server_inviteban_process(server, channel->invite_list, 1, args);
+ silc_buffer_free(ab);
+ silc_argument_payload_free(args);
+ }
+
/* Remove the client from the channel. If the channel does not exist
after removing the client then the client kicked itself off the channel
and we don't have to send anything after that. */
- if (!silc_server_remove_from_one_channel(server, NULL, channel,
+ if (!silc_server_remove_from_one_channel(server, NULL, channel,
target_client, FALSE))
goto out;
/* Re-generate channel key */
if (!silc_server_create_channel_key(server, channel, 0))
goto out;
-
+
/* Send the channel key to the channel. The key of course is not sent
to the client who was kicked off the channel. */
- silc_server_send_channel_key(server, target_client->connection, channel,
- server->server_type == SILC_ROUTER ?
+ silc_server_send_channel_key(server, target_client->connection, channel,
+ server->server_type == SILC_ROUTER ?
FALSE : !server->standalone);
}
if (!cached_key)
goto out;
result = silc_auth_verify_data(auth, tmp_len, SILC_AUTH_PUBLIC_KEY,
- cached_key, 0, idata->hash,
+ cached_key, 0, idata->hash,
client->id, SILC_ID_CLIENT);
}
if (!result) {
if (server->config->detach_disabled) {
silc_server_command_send_status_reply(cmd, SILC_COMMAND_DETACH,
- SILC_STATUS_ERR_UNKNOWN_COMMAND, 0);
+ SILC_STATUS_ERR_OPERATION_ALLOWED,
+ 0);
goto out;
}
if (server->config->detach_timeout) {
q = silc_calloc(1, sizeof(*q));
q->sock = silc_id_dup(client->id, SILC_ID_CLIENT);
- silc_schedule_task_add(server->schedule, 0,
+ silc_schedule_task_add(server->schedule, 0,
silc_server_command_detach_timeout,
q, server->config->detach_timeout * 60,
0, SILC_TASK_TIMEOUT, SILC_TASK_PRI_LOW);
}
client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
if (!client_id) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_WATCH,
- SILC_STATUS_ERR_NO_SUCH_CLIENT_ID,
- 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_WATCH,
+ SILC_STATUS_ERR_NO_SUCH_CLIENT_ID,
+ 0, 2, tmp, tmp_len);
goto out;
}
/* Get the client entry which must be in local list */
- client = silc_idlist_find_client_by_id(server->local_list,
+ client = silc_idlist_find_client_by_id(server->local_list,
client_id, TRUE, NULL);
if (!client) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_WATCH,
- SILC_STATUS_ERR_NO_SUCH_CLIENT_ID,
- 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_WATCH,
+ SILC_STATUS_ERR_NO_SUCH_CLIENT_ID, 0,
+ 2, tmp, tmp_len);
goto out;
}
silc_hash_make(server->md5hash, nick, strlen(nick), hash);
/* Check whether this client is already watching this nickname */
- if (silc_hash_table_find_by_context(server->watcher_list, hash,
+ if (silc_hash_table_find_by_context(server->watcher_list, hash,
client, NULL)) {
/* Nickname is alredy being watched for this client */
silc_server_command_send_status_reply(cmd, SILC_COMMAND_WATCH,
silc_hash_make(server->md5hash, nick, strlen(nick), hash);
/* Check that this client is watching for this nickname */
- if (!silc_hash_table_find_by_context(server->watcher_list, hash,
+ if (!silc_hash_table_find_by_context(server->watcher_list, hash,
client, (void **)&tmp)) {
/* Nickname is alredy being watched for this client */
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_WATCH,
- SILC_STATUS_ERR_NO_SUCH_NICK, 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_WATCH,
+ SILC_STATUS_ERR_NO_SUCH_NICK, 0,
+ 2, nick, strlen(nick));
goto out;
}
if (!cached_key)
goto out;
result = silc_auth_verify_data(auth, tmp_len, SILC_AUTH_PUBLIC_KEY,
- cached_key, 0, idata->hash,
+ cached_key, 0, idata->hash,
client->id, SILC_ID_CLIENT);
}
if (!result) {
SilcServerCommandContext cmd = (SilcServerCommandContext)context;
SilcServer server = cmd->server;
SilcClientEntry client = (SilcClientEntry)cmd->sock->user_data;
- SilcBuffer packet;
+ SilcBuffer packet, list, tmp2;
SilcChannelEntry channel;
SilcChannelClientEntry chl;
SilcChannelID *channel_id = NULL;
- unsigned char *id, *add, *del;
- SilcUInt32 id_len, tmp_len;
- SilcUInt16 ident = silc_command_get_ident(cmd->payload);
+ unsigned char *id, *tmp, *atype = NULL;
+ SilcUInt32 id_len, len, len2;
+ SilcArgumentPayload args;
+ SilcHashTableList htl;
+ SilcUInt32 type;
+ SilcUInt16 argc = 0, ident = silc_command_get_ident(cmd->payload);
+ SilcBufferStruct blist;
if (cmd->sock->type != SILC_SOCKET_TYPE_CLIENT || !client)
goto out;
/* Get channel entry. The server must know about the channel since the
client is expected to be on the channel. */
- channel = silc_idlist_find_channel_by_id(server->local_list,
+ channel = silc_idlist_find_channel_by_id(server->local_list,
channel_id, NULL);
if (!channel) {
- channel = silc_idlist_find_channel_by_id(server->global_list,
+ channel = silc_idlist_find_channel_by_id(server->global_list,
channel_id, NULL);
if (!channel) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_BAN,
- SILC_STATUS_ERR_NO_SUCH_CHANNEL,
- 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_BAN,
+ SILC_STATUS_ERR_NO_SUCH_CHANNEL_ID,
+ 0, 2, id, id_len);
goto out;
}
}
/* Check whether this client is on the channel */
if (!silc_server_client_on_channel(client, channel, &chl)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_BAN,
- SILC_STATUS_ERR_NOT_ON_CHANNEL, 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_BAN,
+ SILC_STATUS_ERR_NOT_ON_CHANNEL, 0,
+ 2, id, id_len);
goto out;
}
/* The client must be at least channel operator. */
if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_BAN,
- SILC_STATUS_ERR_NO_CHANNEL_PRIV, 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_BAN,
+ SILC_STATUS_ERR_NO_CHANNEL_PRIV, 0,
+ 2, id, id_len);
goto out;
}
- /* Get the new ban and add it to the ban list */
- add = silc_argument_get_arg_type(cmd->args, 2, &tmp_len);
- if (add) {
- if (!channel->ban_list)
- channel->ban_list = silc_calloc(tmp_len + 2, sizeof(*channel->ban_list));
- else
- channel->ban_list = silc_realloc(channel->ban_list,
- sizeof(*channel->ban_list) *
- (tmp_len +
- strlen(channel->ban_list) + 2));
- if (add[tmp_len - 1] == ',')
- add[tmp_len - 1] = '\0';
-
- strncat(channel->ban_list, add, tmp_len);
- strncat(channel->ban_list, ",", 1);
- }
-
- /* Get the ban to be removed and remove it from the list */
- del = silc_argument_get_arg_type(cmd->args, 3, &tmp_len);
- if (del && channel->ban_list) {
- char *start, *end, *n;
+ /* Get the ban information */
+ tmp = silc_argument_get_arg_type(cmd->args, 3, &len2);
+ if (tmp && len2 > 2) {
+ /* Parse the arguments to see they are constructed correctly */
+ SILC_GET16_MSB(argc, tmp);
+ args = silc_argument_payload_parse(tmp + 2, len2 - 2, argc);
+ if (!args) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_BAN,
+ SILC_STATUS_ERR_NOT_ENOUGH_PARAMS,
+ 0);
+ goto out;
+ }
- if (!strncmp(channel->ban_list, del, strlen(channel->ban_list) - 1)) {
- silc_free(channel->ban_list);
- channel->ban_list = NULL;
- } else {
- start = strstr(channel->ban_list, del);
- if (start && strlen(start) >= tmp_len) {
- end = start + tmp_len;
- n = silc_calloc(strlen(channel->ban_list) - tmp_len, sizeof(*n));
- strncat(n, channel->ban_list, start - channel->ban_list);
- strncat(n, end + 1, ((channel->ban_list + strlen(channel->ban_list)) -
- end) - 1);
- silc_free(channel->ban_list);
- channel->ban_list = n;
+ /* Get the type of action */
+ atype = silc_argument_get_arg_type(cmd->args, 2, &len);
+ if (atype && len == 1) {
+ if (atype[0] == 0x00) {
+ /* Allocate hash table for ban list if it doesn't exist yet */
+ if (!channel->ban_list)
+ channel->ban_list =
+ silc_hash_table_alloc(0, silc_hash_ptr,
+ NULL, NULL, NULL,
+ silc_server_inviteban_destruct, channel,
+ TRUE);
+
+ /* Check for resource limit */
+ if (silc_hash_table_count(channel->ban_list) > 64) {
+ silc_server_command_send_status_reply(cmd, SILC_COMMAND_BAN,
+ SILC_STATUS_ERR_RESOURCE_LIMIT,
+ 0);
+ goto out;
+ }
}
- }
- }
- /* Send the BAN notify type to our primary router. */
- if (add || del)
+ /* Now add or delete the information. */
+ silc_server_inviteban_process(server, channel->ban_list,
+ (SilcUInt8)atype[0], args);
+ }
+ silc_argument_payload_free(args);
+ }
+
+ /* Encode ban list */
+ list = NULL;
+ if (channel->ban_list && silc_hash_table_count(channel->ban_list)) {
+ list = silc_buffer_alloc_size(2);
+ silc_buffer_format(list,
+ SILC_STR_UI_SHORT(silc_hash_table_count(
+ channel->ban_list)),
+ SILC_STR_END);
+ silc_hash_table_list(channel->ban_list, &htl);
+ while (silc_hash_table_get(&htl, (void **)&type, (void **)&tmp2))
+ list = silc_argument_payload_encode_one(list, tmp2->data, tmp2->len,
+ type);
+ silc_hash_table_list_reset(&htl);
+ }
+
+ /* Send BAN notify type to local servers (but not clients) and to
+ network. */
+ if (atype && tmp && len2) {
+ silc_buffer_set(&blist, tmp, len2);
+
+ /* Send to local servers if we are router */
+ if (server->server_type == SILC_ROUTER)
+ silc_server_send_notify_to_channel(server, NULL, channel, FALSE, FALSE,
+ SILC_NOTIFY_TYPE_BAN, 3,
+ id, id_len,
+ atype, 1,
+ tmp ? blist.data : NULL,
+ tmp ? blist.len : 0);
+
+ /* Send to network. */
silc_server_send_notify_ban(server, SILC_PRIMARY_ROUTE(server),
- SILC_BROADCAST(server), channel, add, del);
+ SILC_BROADCAST(server), channel, atype,
+ &blist);
+ }
/* Send the reply back to the client */
- packet =
+ packet =
silc_command_reply_payload_encode_va(SILC_COMMAND_BAN,
SILC_STATUS_OK, 0, ident, 2,
2, id, id_len,
- 3, channel->ban_list,
- channel->ban_list ?
- strlen(channel->ban_list) -1 : 0);
- silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
+ 3, list ? list->data : NULL,
+ list ? list->len : 0);
+ silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
packet->data, packet->len, FALSE);
-
+
silc_buffer_free(packet);
+ silc_buffer_free(list);
out:
silc_free(channel_id);
if (!channel) {
channel = silc_idlist_find_channel_by_id(server->global_list, id, NULL);
if (!channel) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_LEAVE,
- SILC_STATUS_ERR_NO_SUCH_CHANNEL,
- 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_LEAVE,
+ SILC_STATUS_ERR_NO_SUCH_CHANNEL_ID,
+ 0, 2, tmp, len);
goto out;
}
}
/* Check whether this client is on the channel */
if (!silc_server_client_on_channel(id_entry, channel, NULL)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_LEAVE,
- SILC_STATUS_ERR_NOT_ON_CHANNEL, 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_LEAVE,
+ SILC_STATUS_ERR_NOT_ON_CHANNEL, 0,
+ 2, tmp, len);
goto out;
}
goto out;
/* Send the channel key */
- silc_server_send_channel_key(server, NULL, channel,
- server->server_type == SILC_ROUTER ?
+ silc_server_send_channel_key(server, NULL, channel,
+ server->server_type == SILC_ROUTER ?
FALSE : !server->standalone);
}
if (channel_id) {
id = silc_id_payload_parse_id(channel_id, channel_id_len, NULL);
if (!id) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_USERS,
- SILC_STATUS_ERR_NO_CHANNEL_ID, 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_USERS,
+ SILC_STATUS_ERR_BAD_CHANNEL_ID, 0,
+ 2, channel_id, channel_id_len);
goto out;
}
}
if (id)
channel = silc_idlist_find_channel_by_id(server->local_list, id, NULL);
else
- channel = silc_idlist_find_channel_by_name(server->local_list,
+ channel = silc_idlist_find_channel_by_name(server->local_list,
channel_name, NULL);
- if (!channel || (!server->standalone && (channel->disabled ||
+ if (!channel || (!server->standalone && (channel->disabled ||
!channel->users_resolved))) {
if (server->server_type != SILC_ROUTER && !server->standalone &&
!cmd->pending) {
SilcBuffer tmpbuf;
-
+
silc_command_set_ident(cmd->payload, ++server->cmd_ident);
tmpbuf = silc_command_payload_encode_payload(cmd->payload);
-
+
/* Send USERS command */
silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
SILC_PACKET_COMMAND, cmd->packet->flags,
tmpbuf->data, tmpbuf->len, TRUE);
-
+
/* Reprocess this packet after received reply */
- silc_server_command_pending(server, SILC_COMMAND_USERS,
+ silc_server_command_pending(server, SILC_COMMAND_USERS,
silc_command_get_ident(cmd->payload),
silc_server_command_users,
silc_server_command_dup(cmd));
if (id)
channel = silc_idlist_find_channel_by_id(server->global_list, id, NULL);
else
- channel = silc_idlist_find_channel_by_name(server->global_list,
+ channel = silc_idlist_find_channel_by_name(server->global_list,
channel_name, NULL);
if (!channel) {
/* Channel really does not exist */
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_USERS,
- SILC_STATUS_ERR_NO_SUCH_CHANNEL,
- 0);
+ if (id)
+ silc_server_command_send_status_data(
+ cmd, SILC_COMMAND_USERS,
+ SILC_STATUS_ERR_NO_SUCH_CHANNEL_ID, 0,
+ 2, channel_id, channel_id_len);
+ else
+ silc_server_command_send_status_data(
+ cmd, SILC_COMMAND_USERS,
+ SILC_STATUS_ERR_NO_SUCH_CHANNEL, 0,
+ 2, channel_name, strlen(channel_name));
goto out;
}
}
user requesting this command is on the channel or is server */
if (cmd->sock->type == SILC_SOCKET_TYPE_CLIENT) {
if (channel->mode & (SILC_CHANNEL_MODE_PRIVATE | SILC_CHANNEL_MODE_SECRET)
- && !silc_server_client_on_channel(cmd->sock->user_data, channel,
+ && !silc_server_client_on_channel(cmd->sock->user_data, channel,
NULL)) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_USERS,
- SILC_STATUS_ERR_NO_SUCH_CHANNEL,
- 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_USERS,
+ SILC_STATUS_ERR_NO_SUCH_CHANNEL, 0,
+ 2, channel->channel_name,
+ strlen(channel->channel_name));
goto out;
}
}
SILC_STATUS_OK, 0, ident, 4,
2, idp->data, idp->len,
3, lc, 4,
- 4, client_id_list ?
+ 4, client_id_list ?
client_id_list->data : NULL,
client_id_list ?
client_id_list->len : 0,
client_mode_list->data : NULL,
client_mode_list ?
client_mode_list->len : 0);
- silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
+ silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
packet->data, packet->len, FALSE);
-
+
silc_buffer_free(idp);
silc_buffer_free(packet);
if (client_id_list)
/* If the client is not found from local list there is no chance it
would be locally connected client so send the command further. */
- client = silc_idlist_find_client_by_id(server->local_list,
+ client = silc_idlist_find_client_by_id(server->local_list,
client_id, TRUE, NULL);
if (!client)
- client = silc_idlist_find_client_by_id(server->global_list,
+ client = silc_idlist_find_client_by_id(server->global_list,
client_id, TRUE, NULL);
-
+
if ((!client && !cmd->pending && !server->standalone) ||
(client && !client->connection && !cmd->pending &&
!(client->mode & SILC_UMODE_DETACHED)) ||
SilcBuffer tmpbuf;
SilcUInt16 old_ident;
SilcSocketConnection dest_sock;
-
- dest_sock = silc_server_get_client_route(server, NULL, 0,
+
+ dest_sock = silc_server_get_client_route(server, NULL, 0,
client_id, NULL, NULL);
if (!dest_sock)
goto out;
-
+
old_ident = silc_command_get_ident(cmd->payload);
silc_command_set_ident(cmd->payload, ++server->cmd_ident);
tmpbuf = silc_command_payload_encode_payload(cmd->payload);
-
+
silc_server_packet_send(server, dest_sock,
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_GETKEY,
+ silc_server_command_pending(server, SILC_COMMAND_GETKEY,
silc_command_get_ident(cmd->payload),
silc_server_command_getkey,
silc_server_command_dup(cmd));
}
if (!client) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_GETKEY,
- SILC_STATUS_ERR_NO_SUCH_CLIENT_ID,
- 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_GETKEY,
+ SILC_STATUS_ERR_NO_SUCH_CLIENT_ID,
+ 0, 2, tmp, tmp_len);
goto out;
}
/* The client is locally connected, just get the public key and
- send it back. If they key does not exist then do not send it,
+ send it back. If they key does not exist then do not send it,
send just OK reply */
public_key = client->data.public_key;
if (public_key)
/* If the server is not found from local list there is no chance it
would be locally connected server so send the command further. */
- server_entry = silc_idlist_find_server_by_id(server->local_list,
+ server_entry = silc_idlist_find_server_by_id(server->local_list,
server_id, TRUE, NULL);
if (!server_entry)
- server_entry = silc_idlist_find_server_by_id(server->global_list,
+ server_entry = silc_idlist_find_server_by_id(server->global_list,
server_id, TRUE, NULL);
-
+
if (server_entry != server->id_entry &&
((!server_entry && !cmd->pending && !server->standalone) ||
(server_entry && !server_entry->connection && !cmd->pending &&
!server->standalone))) {
SilcBuffer tmpbuf;
SilcUInt16 old_ident;
-
+
old_ident = silc_command_get_ident(cmd->payload);
silc_command_set_ident(cmd->payload, ++server->cmd_ident);
tmpbuf = silc_command_payload_encode_payload(cmd->payload);
-
+
silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
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_GETKEY,
+ silc_server_command_pending(server, SILC_COMMAND_GETKEY,
silc_command_get_ident(cmd->payload),
silc_server_command_getkey,
silc_server_command_dup(cmd));
}
if (!server_entry) {
- silc_server_command_send_status_reply(cmd, SILC_COMMAND_GETKEY,
- SILC_STATUS_ERR_NO_SUCH_SERVER_ID,
- 0);
+ silc_server_command_send_status_data(cmd, SILC_COMMAND_GETKEY,
+ SILC_STATUS_ERR_NO_SUCH_SERVER_ID,
+ 0, 2, tmp, tmp_len);
goto out;
}
/* If they key does not exist then do not send it, send just OK reply */
- public_key = (!server_entry->data.public_key ?
+ public_key = (!server_entry->data.public_key ?
(server_entry == server->id_entry ? server->public_key :
NULL) : server_entry->data.public_key);
if (public_key)
2, tmp, tmp_len,
3, pk ? pk->data : NULL,
pk ? pk->len : 0);
- silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
+ silc_server_packet_send(server, cmd->sock, SILC_PACKET_COMMAND_REPLY, 0,
packet->data, packet->len, FALSE);
silc_buffer_free(packet);
}
/* Server side command of CLOSE. Closes connection to a specified server. */
-
+
SILC_SERVER_CMD_FUNC(close)
{
SilcServerCommandContext cmd = (SilcServerCommandContext)context;
/* Close the connection to the server */
sock = (SilcSocketConnection)server_entry->connection;
- /* If we shutdown primary router connection manually then don't trigger
- any reconnect or backup router connections, by setting the router
- to NULL here. */
+ server->backup_noswitch = TRUE;
if (server->router == server_entry) {
server->id_entry->router = NULL;
server->router = NULL;
server->standalone = TRUE;
}
- silc_server_free_sock_user_data(server, sock, NULL);
- silc_server_close_connection(server, sock);
-
+ silc_server_disconnect_remote(server, sock,
+ SILC_STATUS_ERR_BANNED_FROM_SERVER,
+ "Closed by administrator");
+ if (sock->user_data)
+ silc_server_free_sock_user_data(server, sock, NULL);
+ server->backup_noswitch = FALSE;
+
out:
silc_server_command_free(cmd);
}
/* Server side command of SHUTDOWN. Shutdowns the server and closes all
active connections. */
-
+
SILC_SERVER_CMD_FUNC(shutdown)
{
SilcServerCommandContext cmd = (SilcServerCommandContext)context;
projects / silc.git / blobdiff