Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1997 - 2002 Pekka Riikonen
+ Copyright (C) 1997 - 2007 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; either version 2 of the License, or
(at your option) any later version.
-
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
*/
-/*
- * Server packet routines to handle received packets.
- */
-/* $Id$ */
#include "serverincludes.h"
#include "server_internal.h"
-/* Received notify packet. Server can receive notify packets from router.
+/* Received notify packet. Server can receive notify packets from router.
Server then relays the notify messages to clients if needed. */
-void silc_server_notify(SilcServer server,
- SilcSocketConnection sock,
- SilcPacketContext *packet)
+static void silc_server_notify_process(SilcServer server,
+ SilcPacketStream sock,
+ SilcPacket packet,
+ SilcBuffer buffer)
{
+ SilcIDListData idata = silc_packet_get_context(sock);
SilcNotifyPayload payload;
SilcNotifyType type;
SilcArgumentPayload args;
- SilcChannelID *channel_id = NULL, *channel_id2;
- SilcClientID *client_id, *client_id2;
- SilcServerID *server_id;
- SilcIdType id_type;
+ SilcChannelID channel_id;
+ SilcID id, id2;
SilcChannelEntry channel = NULL;
SilcClientEntry client = NULL, client2 = NULL;
SilcServerEntry server_entry = NULL;
SilcChannelClientEntry chl;
- SilcIDCacheEntry cache;
+ SilcIDCacheEntry cache = NULL;
SilcHashTableList htl;
SilcUInt32 mode;
- unsigned char *tmp;
- SilcUInt32 tmp_len;
- bool local;
+ unsigned char *tmp, *tmp2;
+ SilcUInt32 tmp_len, tmp2_len;
+ SilcBool local, ret;
- SILC_LOG_DEBUG(("Start"));
+ if (idata->conn_type == SILC_CONN_CLIENT) {
+ SILC_LOG_DEBUG(("Notify received from client, drop it"));
+ return;
+ }
- if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
- packet->src_id_type != SILC_ID_SERVER)
+ if (packet->src_id_type != SILC_ID_SERVER){
+ SILC_LOG_DEBUG(("Bad notify packet received"));
return;
+ }
- if (!packet->dst_id)
+ if (!packet->dst_id) {
+ SILC_LOG_DEBUG(("Bad notify packet received"));
return;
+ }
/* If the packet is destined directly to a client then relay the packet
before processing it. */
if (packet->dst_id_type == SILC_ID_CLIENT) {
SilcIDListData idata;
- SilcSocketConnection dst_sock;
+ SilcPacketStream dst_sock;
/* Get the route to the client */
dst_sock = silc_server_get_client_route(server, packet->dst_id,
- packet->dst_id_len, NULL,
+ packet->dst_id_len, NULL,
&idata, NULL);
if (dst_sock)
/* Relay the packet */
- silc_server_relay_packet(server, dst_sock, idata->send_key,
- idata->hmac_send, idata->psn_send++,
- packet, TRUE);
+ silc_server_packet_route(server, dst_sock, packet);
}
/* Parse the Notify Payload */
- payload = silc_notify_payload_parse(packet->buffer->data,
- packet->buffer->len);
- if (!payload)
+ payload = silc_notify_payload_parse(buffer->data, silc_buffer_len(buffer));
+ if (!payload) {
+ SILC_LOG_DEBUG(("Marlformed notify payload"));
return;
+ }
/* If we are router and this packet is not already broadcast packet
we will broadcast it. The sending socket really cannot be router or
the router is buggy. If this packet is coming from router then it must
have the broadcast flag set already and we won't do anything. */
- if (!server->standalone && server->server_type == SILC_ROUTER &&
- sock->type == SILC_SOCKET_TYPE_SERVER &&
+ if (server->server_type == SILC_ROUTER &&
+ idata->conn_type == SILC_CONN_SERVER &&
!(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
SILC_LOG_DEBUG(("Broadcasting received Notify packet"));
if (packet->dst_id_type == SILC_ID_CHANNEL) {
/* Packet is destined to channel */
- channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
- packet->dst_id_type);
- if (!channel_id)
+ if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
+ packet->dst_id_type, &channel_id,
+ sizeof(channel_id))) {
+ SILC_LOG_DEBUG(("Malformed destination ID in notify packet"));
goto out;
+ }
- silc_server_packet_send_dest(server, server->router->connection,
- packet->type,
- packet->flags | SILC_PACKET_FLAG_BROADCAST,
- channel_id, SILC_ID_CHANNEL,
- packet->buffer->data, packet->buffer->len,
- FALSE);
- silc_server_backup_send_dest(server, (SilcServerEntry)sock->user_data,
+ silc_server_packet_send_dest(server, SILC_PRIMARY_ROUTE(server),
+ packet->type, packet->flags |
+ SILC_PACKET_FLAG_BROADCAST,
+ &channel_id, SILC_ID_CHANNEL,
+ buffer->data, silc_buffer_len(buffer));
+ silc_server_backup_send_dest(server, (SilcServerEntry)idata,
packet->type, packet->flags,
- channel_id, SILC_ID_CHANNEL,
- packet->buffer->data, packet->buffer->len,
+ &channel_id, SILC_ID_CHANNEL,
+ buffer->data, silc_buffer_len(buffer),
FALSE, TRUE);
} else {
/* Packet is destined to client or server */
- silc_server_packet_send(server, server->router->connection,
+ silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
packet->type,
- packet->flags | SILC_PACKET_FLAG_BROADCAST,
- packet->buffer->data, packet->buffer->len,
- FALSE);
- silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
+ packet->flags | SILC_PACKET_FLAG_BROADCAST,
+ buffer->data, silc_buffer_len(buffer));
+ silc_server_backup_send(server, (SilcServerEntry)idata,
packet->type, packet->flags,
- packet->buffer->data, packet->buffer->len,
+ buffer->data, silc_buffer_len(buffer),
FALSE, TRUE);
}
}
type = silc_notify_get_type(payload);
args = silc_notify_get_args(payload);
- if (!args)
+ if (!args) {
+ SILC_LOG_DEBUG(("Notify doesn't have any arguments, drop it"));
goto out;
+ }
switch(type) {
case SILC_NOTIFY_TYPE_JOIN:
- /*
+ /*
* Distribute the notify to local clients on the channel
*/
SILC_LOG_DEBUG(("JOIN notify"));
/* Get Channel ID */
- tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
- if (!tmp)
- goto out;
- channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
- if (!channel_id)
+ if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL))
goto out;
/* Get channel entry */
- channel = silc_idlist_find_channel_by_id(server->global_list,
- channel_id, NULL);
+ channel = silc_idlist_find_channel_by_id(server->global_list,
+ SILC_ID_GET_ID(id), NULL);
if (!channel) {
- channel = silc_idlist_find_channel_by_id(server->local_list,
- channel_id, NULL);
+ channel = silc_idlist_find_channel_by_id(server->local_list,
+ SILC_ID_GET_ID(id), NULL);
if (!channel) {
- silc_free(channel_id);
+ SILC_LOG_DEBUG(("Notify for unknown channel %s",
+ silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
goto out;
}
}
- silc_free(channel_id);
/* Get client ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
- goto out;
- client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
- if (!client_id)
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
goto out;
/* If the the client is not in local list we check global list (ie. the
channel will be global channel) and if it does not exist then create
entry for the client. */
- client = silc_idlist_find_client_by_id(server->global_list,
- client_id, server->server_type,
- NULL);
+ client = silc_idlist_find_client_by_id(server->global_list,
+ SILC_ID_GET_ID(id),
+ server->server_type,
+ &cache);
if (!client) {
- client = silc_idlist_find_client_by_id(server->local_list,
- client_id, server->server_type,
- NULL);
+ client = silc_idlist_find_client_by_id(server->local_list,
+ SILC_ID_GET_ID(id),
+ server->server_type,
+ &cache);
if (!client) {
/* If router did not find the client the it is bogus */
if (server->server_type != SILC_SERVER)
goto out;
- client =
+ client =
silc_idlist_add_client(server->global_list, NULL, NULL, NULL,
- silc_id_dup(client_id, SILC_ID_CLIENT),
- sock->user_data, NULL, 0);
+ silc_id_dup(SILC_ID_GET_ID(id),
+ SILC_ID_CLIENT),
+ (SilcServerEntry)idata, NULL);
if (!client) {
SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
- silc_free(client_id);
goto out;
}
/* Do not add client to channel if it is there already */
if (silc_server_client_on_channel(client, channel, NULL)) {
- SILC_LOG_DEBUG(("Client already on channel"));
+ SILC_LOG_DEBUG(("Client already on channel %s",
+ channel->channel_name));
break;
}
/* Send to channel */
- silc_server_packet_send_to_channel(server, sock, channel, packet->type,
- FALSE, packet->buffer->data,
- packet->buffer->len, FALSE);
+ silc_server_packet_send_to_channel(server, sock, channel, packet->type,
+ FALSE, TRUE, buffer->data,
+ silc_buffer_len(buffer));
- if (server->server_type != SILC_ROUTER &&
- sock->type == SILC_SOCKET_TYPE_ROUTER)
+ if (server->server_type != SILC_ROUTER &&
+ idata->conn_type == SILC_CONN_ROUTER)
/* The channel is global now */
channel->global_users = TRUE;
SILC_LOG_DEBUG(("Joining to channel %s", channel->channel_name));
- /* JOIN the global client to the channel (local clients (if router
+ /* JOIN the global client to the channel (local clients (if router
created the channel) is joined in the pending JOIN command). */
chl = silc_calloc(1, sizeof(*chl));
+ if (!chl)
+ goto out;
chl->client = client;
chl->channel = channel;
- /* If this is the first one on the channel then it is the founder of
- the channel. */
- if (!silc_hash_table_count(channel->user_list))
- chl->mode = (SILC_CHANNEL_UMODE_CHANOP | SILC_CHANNEL_UMODE_CHANFO);
+ if (server->server_type != SILC_ROUTER ||
+ idata->conn_type == SILC_CONN_ROUTER) {
+ /* If founder auth is set, first client is not automatically founder. */
+ if (!(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
+ /* If this is the first one on the channel then it is the founder of
+ the channel. This is done on normal server and on router if this
+ notify is coming from router */
+ if (!silc_hash_table_count(channel->user_list)) {
+ SILC_LOG_DEBUG(("Client %s is founder on channel",
+ silc_id_render(chl->client->id, SILC_ID_CLIENT)));
+ chl->mode = (SILC_CHANNEL_UMODE_CHANOP | SILC_CHANNEL_UMODE_CHANFO);
+ }
+ }
+ }
silc_hash_table_add(channel->user_list, client, chl);
silc_hash_table_add(client->channels, channel, chl);
- silc_free(client_id);
channel->user_count++;
+ channel->disabled = FALSE;
+
+ /* Update statistics */
+ if (server->server_type == SILC_ROUTER) {
+ if (idata->conn_type != SILC_CONN_ROUTER)
+ server->stat.cell_chanclients++;
+ server->stat.chanclients++;
+ }
break;
case SILC_NOTIFY_TYPE_LEAVE:
- /*
+ /*
* Distribute the notify to local clients on the channel
*/
SILC_LOG_DEBUG(("LEAVE notify"));
- if (!channel_id) {
- channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
- packet->dst_id_type);
- if (!channel_id)
- goto out;
- }
+ if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
+ packet->dst_id_type, &channel_id,
+ sizeof(channel_id)))
+ goto out;
/* Get channel entry */
- channel = silc_idlist_find_channel_by_id(server->global_list,
- channel_id, NULL);
- if (!channel) {
- channel = silc_idlist_find_channel_by_id(server->local_list,
- channel_id, NULL);
+ channel = silc_idlist_find_channel_by_id(server->global_list,
+ &channel_id, NULL);
+ if (!channel) {
+ channel = silc_idlist_find_channel_by_id(server->local_list,
+ &channel_id, NULL);
if (!channel) {
- silc_free(channel_id);
+ SILC_LOG_DEBUG(("Notify for unknown channel %s",
+ silc_id_render(&channel_id, SILC_ID_CHANNEL)));
goto out;
}
}
/* Get client ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp) {
- silc_free(channel_id);
- goto out;
- }
- client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
- if (!client_id) {
- silc_free(channel_id);
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
goto out;
- }
/* Get client entry */
- client = silc_idlist_find_client_by_id(server->global_list,
- client_id, TRUE, NULL);
+ client = silc_idlist_find_client_by_id(server->global_list,
+ SILC_ID_GET_ID(id), TRUE, NULL);
if (!client) {
- client = silc_idlist_find_client_by_id(server->local_list,
- client_id, TRUE, NULL);
- if (!client) {
- silc_free(client_id);
- silc_free(channel_id);
+ client = silc_idlist_find_client_by_id(server->local_list,
+ SILC_ID_GET_ID(id), TRUE, NULL);
+ if (!client)
goto out;
- }
}
- silc_free(client_id);
/* Check if on channel */
if (!silc_server_client_on_channel(client, channel, NULL))
break;
/* Send the leave notify to channel */
- silc_server_packet_send_to_channel(server, sock, channel, packet->type,
- FALSE, packet->buffer->data,
- packet->buffer->len, FALSE);
+ silc_server_packet_send_to_channel(server, sock, channel, packet->type,
+ FALSE, TRUE, buffer->data,
+ silc_buffer_len(buffer));
/* Remove the user from channel */
silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
break;
case SILC_NOTIFY_TYPE_SIGNOFF:
- /*
+ /*
* Distribute the notify to local clients on the channel
*/
SILC_LOG_DEBUG(("SIGNOFF notify"));
/* Get client ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
- goto out;
- client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
- if (!client_id)
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
goto out;
/* Get client entry */
- client = silc_idlist_find_client_by_id(server->global_list,
- client_id, TRUE, &cache);
+ client = silc_idlist_find_client_by_id(server->global_list,
+ SILC_ID_GET_ID(id), TRUE, &cache);
if (!client) {
- client = silc_idlist_find_client_by_id(server->local_list,
- client_id, TRUE, &cache);
- if (!client) {
- silc_free(client_id);
+ client = silc_idlist_find_client_by_id(server->local_list,
+ SILC_ID_GET_ID(id), TRUE, &cache);
+ if (!client)
goto out;
- }
}
- silc_free(client_id);
/* Get signoff message */
tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
if (tmp_len > 128)
- tmp = NULL;
+ tmp_len = 128;
/* Update statistics */
server->stat.clients--;
server->stat.cell_clients--;
SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
+ silc_schedule_task_del_by_context(server->schedule, client);
+
+ /* Remove client's public key from repository, this will free it too. */
+ if (client->data.public_key) {
+ silc_skr_del_public_key(server->repository, client->data.public_key,
+ client);
+ client->data.public_key = NULL;
+ }
/* Remove the client from all channels. */
- silc_server_remove_from_channels(server, NULL, client, TRUE, tmp, FALSE);
+ silc_server_remove_from_channels(server, NULL, client, TRUE,
+ tmp, FALSE, FALSE);
/* Check if anyone is watching this nickname */
if (server->server_type == SILC_ROUTER)
silc_server_check_watcher_list(server, client, NULL,
SILC_NOTIFY_TYPE_SIGNOFF);
+ /* Remove this client from watcher list if it is */
+ silc_server_del_from_watcher_list(server, client);
+
client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
- cache->expire = SILC_ID_CACHE_EXPIRE_DEF;
+ client->mode = 0;
+ client->router = NULL;
+ client->connection = NULL;
+ client->data.created = silc_time();
+ silc_dlist_del(server->expired_clients, client);
+ silc_dlist_add(server->expired_clients, client);
break;
case SILC_NOTIFY_TYPE_TOPIC_SET:
- /*
+ /*
* Distribute the notify to local clients on the channel
*/
SILC_LOG_DEBUG(("TOPIC SET notify"));
/* Get client ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
- goto out;
- client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
- if (!client_id)
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
goto out;
/* Get client entry */
- client = silc_idlist_find_client_by_id(server->global_list,
- client_id, TRUE, &cache);
- if (!client) {
- client = silc_idlist_find_client_by_id(server->local_list,
- client_id, TRUE, &cache);
+ if (id.type == SILC_ID_CLIENT) {
+ client = silc_idlist_find_client_by_id(server->global_list,
+ SILC_ID_GET_ID(id), TRUE, &cache);
if (!client) {
- silc_free(client_id);
- goto out;
+ client = silc_idlist_find_client_by_id(server->local_list,
+ SILC_ID_GET_ID(id),
+ TRUE, &cache);
+ if (!client)
+ goto out;
}
}
- silc_free(client_id);
/* Get the topic */
tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
- if (!tmp) {
- silc_free(channel_id);
+ if (!tmp)
goto out;
- }
- if (!channel_id) {
- channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
- packet->dst_id_type);
- if (!channel_id)
- goto out;
- }
+ if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
+ packet->dst_id_type, &channel_id,
+ sizeof(channel_id)))
+ goto out;
/* Get channel entry */
- channel = silc_idlist_find_channel_by_id(server->global_list,
- channel_id, NULL);
+ channel = silc_idlist_find_channel_by_id(server->global_list,
+ &channel_id, NULL);
if (!channel) {
- channel = silc_idlist_find_channel_by_id(server->local_list,
- channel_id, NULL);
+ channel = silc_idlist_find_channel_by_id(server->local_list,
+ &channel_id, NULL);
if (!channel) {
- silc_free(channel_id);
+ SILC_LOG_DEBUG(("Notify for unknown channel %s",
+ silc_id_render(&channel_id, SILC_ID_CHANNEL)));
goto out;
}
}
- if (channel->topic && !strcmp(channel->topic, tmp))
+ if (channel->topic && !strcmp(channel->topic, tmp)) {
+ SILC_LOG_DEBUG(("Topic is already set and same"));
goto out;
+ }
- /* Get user's channel entry and check that topic set is allowed. */
- if (!silc_server_client_on_channel(client, channel, &chl))
- goto out;
- if (channel->mode & SILC_CHANNEL_MODE_TOPIC &&
- !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
- !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
- SILC_LOG_DEBUG(("Topic change is not allowed"));
- goto out;
+ if (client) {
+ /* Get user's channel entry and check that topic set is allowed. */
+ if (!silc_server_client_on_channel(client, channel, &chl))
+ goto out;
+ if (channel->mode & SILC_CHANNEL_MODE_TOPIC &&
+ !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
+ !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
+ SILC_LOG_DEBUG(("Topic change is not allowed"));
+ goto out;
+ }
}
/* Change the topic */
channel->topic = strdup(tmp);
/* Send the same notify to the channel */
- silc_server_packet_send_to_channel(server, sock, channel, packet->type,
- FALSE, packet->buffer->data,
- packet->buffer->len, FALSE);
- silc_free(channel_id);
+ silc_server_packet_send_to_channel(server, NULL, channel, packet->type,
+ FALSE, TRUE, buffer->data,
+ silc_buffer_len(buffer));
break;
case SILC_NOTIFY_TYPE_NICK_CHANGE:
{
- /*
+ /*
* Distribute the notify to local clients on the channel
*/
- unsigned char *id, *id2;
char *nickname;
SilcUInt32 nickname_len;
SILC_LOG_DEBUG(("NICK CHANGE notify"));
-
+
/* Get old client ID */
- id = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!id)
- goto out;
- client_id = silc_id_payload_parse_id(id, tmp_len, NULL);
- if (!client_id)
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
goto out;
-
+
/* Get new client ID */
- id2 = silc_argument_get_arg_type(args, 2, &tmp_len);
- if (!id2)
- goto out;
- client_id2 = silc_id_payload_parse_id(id2, tmp_len, NULL);
- if (!client_id2)
+ if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id2, NULL))
goto out;
-
- SILC_LOG_DEBUG(("Old Client ID id(%s)",
- silc_id_render(client_id, SILC_ID_CLIENT)));
- SILC_LOG_DEBUG(("New Client ID id(%s)",
- silc_id_render(client_id2, SILC_ID_CLIENT)));
+
+ SILC_LOG_DEBUG(("Old Client ID id(%s)",
+ silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CLIENT)));
+ SILC_LOG_DEBUG(("New Client ID id(%s)",
+ silc_id_render(SILC_ID_GET_ID(id2), SILC_ID_CLIENT)));
/* From protocol version 1.1 we also get the new nickname */
nickname = silc_argument_get_arg_type(args, 3, &nickname_len);;
/* Replace the Client ID */
client = silc_idlist_replace_client_id(server,
- server->global_list, client_id,
- client_id2, nickname);
+ server->global_list,
+ SILC_ID_GET_ID(id),
+ SILC_ID_GET_ID(id2), nickname);
if (!client)
client = silc_idlist_replace_client_id(server,
- server->local_list, client_id,
- client_id2, nickname);
+ server->local_list,
+ SILC_ID_GET_ID(id),
+ SILC_ID_GET_ID(id2), nickname);
if (client) {
/* Send the NICK_CHANGE notify type to local clients on the channels
this client is joined to. */
+ tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
+ tmp2 = silc_argument_get_arg_type(args, 2, &tmp2_len);
silc_server_send_notify_on_channels(server, client, client,
SILC_NOTIFY_TYPE_NICK_CHANGE, 3,
- id, tmp_len, id2, tmp_len,
+ tmp, tmp_len, tmp2, tmp2_len,
nickname, nickname ?
nickname_len : 0);
}
- silc_free(client_id);
- if (!client)
- silc_free(client_id2);
break;
}
case SILC_NOTIFY_TYPE_CMODE_CHANGE:
- /*
+ /*
* Distribute the notify to local clients on the channel
*/
-
+
SILC_LOG_DEBUG(("CMODE CHANGE notify"));
-
+
/* Get client ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
- goto out;
- client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
- if (!client_id)
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
goto out;
/* Get client entry */
- if (id_type == SILC_ID_CLIENT) {
- client = silc_idlist_find_client_by_id(server->global_list,
- client_id, TRUE, &cache);
+ if (id.type == SILC_ID_CLIENT) {
+ client = silc_idlist_find_client_by_id(server->global_list,
+ SILC_ID_GET_ID(id), TRUE, &cache);
if (!client) {
- client = silc_idlist_find_client_by_id(server->local_list,
- client_id, TRUE, &cache);
- if (!client) {
- silc_free(client_id);
+ client = silc_idlist_find_client_by_id(server->local_list,
+ SILC_ID_GET_ID(id),
+ TRUE, &cache);
+ if (!client)
goto out;
- }
}
- silc_free(client_id);
}
- if (!channel_id) {
- channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
- packet->dst_id_type);
- if (!channel_id)
- goto out;
- }
+ if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
+ packet->dst_id_type, &channel_id,
+ sizeof(channel_id)))
+ goto out;
/* Get channel entry */
- channel = silc_idlist_find_channel_by_id(server->global_list,
- channel_id, NULL);
+ channel = silc_idlist_find_channel_by_id(server->global_list,
+ &channel_id, NULL);
if (!channel) {
- channel = silc_idlist_find_channel_by_id(server->local_list,
- channel_id, NULL);
+ channel = silc_idlist_find_channel_by_id(server->local_list,
+ &channel_id, NULL);
if (!channel) {
- silc_free(channel_id);
+ SILC_LOG_DEBUG(("Notify for unknown channel %s",
+ silc_id_render(&channel_id, SILC_ID_CHANNEL)));
goto out;
}
}
- silc_free(channel_id);
/* Get the mode */
tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
SILC_GET32_MSB(mode, tmp);
/* Check if mode changed */
- if (channel->mode == mode)
+ if (channel->mode == mode) {
+ SILC_LOG_DEBUG(("Mode is changed already"));
+
+ /* If this mode change has founder mode then we'll enforce the
+ change so that the server gets the real founder public key */
+ if (server->server_type != SILC_SERVER &&
+ sock != SILC_PRIMARY_ROUTE(server) &&
+ mode & SILC_CHANNEL_MODE_FOUNDER_AUTH && channel->founder_key) {
+ SILC_LOG_DEBUG(("Sending founder public key to server"));
+ silc_server_send_notify_cmode(server, sock, FALSE, channel,
+ channel->mode, server->id,
+ SILC_ID_SERVER, channel->cipher,
+ channel->hmac_name,
+ channel->passphrase,
+ channel->founder_key, NULL);
+ }
+
+ /* If we received same mode from our primary check whether founder
+ mode and key in the notify is set. We update the founder key
+ here since we may have wrong one */
+ if (server->server_type != SILC_ROUTER &&
+ sock == SILC_PRIMARY_ROUTE(server) &&
+ mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
+ SILC_LOG_DEBUG(("Founder public key received from router"));
+ tmp = silc_argument_get_arg_type(args, 6, &tmp_len);
+ if (!tmp)
+ break;
+
+ if (channel->founder_key)
+ silc_pkcs_public_key_free(channel->founder_key);
+ channel->founder_key = NULL;
+ silc_public_key_payload_decode(tmp, tmp_len,
+ &channel->founder_key);
+ }
+
+ /* Check also for channel public key list */
+ if (server->server_type == SILC_SERVER &&
+ sock == SILC_PRIMARY_ROUTE(server) &&
+ mode & SILC_CHANNEL_MODE_CHANNEL_AUTH) {
+ SilcBuffer chpklist;
+ SilcBuffer sidp;
+ unsigned char mask[4], ulimit[4];
+
+ SILC_LOG_DEBUG(("Channel public key list received from router"));
+ tmp = silc_argument_get_arg_type(args, 7, &tmp_len);
+ if (!tmp)
+ break;
+
+ /* Set the router's list, and send the notify to channel too so that
+ channel gets the list */
+ silc_server_set_channel_pk_list(server, sock, channel, tmp, tmp_len);
+ chpklist = silc_server_get_channel_pk_list(server, channel,
+ FALSE, FALSE);
+ if (!chpklist)
+ break;
+ sidp = silc_id_payload_encode(server->router->id, SILC_ID_SERVER);
+ SILC_PUT32_MSB(channel->mode, mask);
+ if (channel->mode & SILC_CHANNEL_MODE_ULIMIT)
+ SILC_PUT32_MSB(channel->user_limit, ulimit);
+ silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
+ SILC_NOTIFY_TYPE_CMODE_CHANGE, 8,
+ sidp->data, silc_buffer_len(sidp),
+ mask, 4,
+ channel->cipher,
+ channel->cipher ?
+ strlen(channel->cipher) : 0,
+ channel->hmac_name,
+ channel->hmac_name ?
+ strlen(channel->hmac_name) : 0,
+ channel->passphrase,
+ channel->passphrase ?
+ strlen(channel->passphrase) : 0,
+ NULL, 0,
+ chpklist->data,
+ silc_buffer_len(chpklist),
+ (channel->mode &
+ SILC_CHANNEL_MODE_ULIMIT ?
+ ulimit : NULL),
+ (channel->mode &
+ SILC_CHANNEL_MODE_ULIMIT ?
+ sizeof(ulimit) : 0));
+ silc_buffer_free(sidp);
+ silc_buffer_free(chpklist);
+ goto out;
+ }
+
break;
+ }
/* Get user's channel entry and check that mode change is allowed */
if (client) {
goto out;
if (!silc_server_check_cmode_rights(server, channel, chl, mode)) {
SILC_LOG_DEBUG(("CMODE change is not allowed"));
+ silc_server_send_notify_cmode(server, sock, FALSE, channel,
+ channel->mode, server->id,
+ SILC_ID_SERVER, channel->cipher,
+ channel->hmac_name,
+ channel->passphrase,
+ channel->founder_key, NULL);
+ goto out;
+ }
+ } else {
+ /* Assure that server is not removing founder mode from us */
+ if (server->server_type == SILC_ROUTER &&
+ sock != SILC_PRIMARY_ROUTE(server) &&
+ channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH &&
+ !(mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
+ SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
+ silc_server_send_notify_cmode(server, sock, FALSE, channel,
+ channel->mode, server->id,
+ SILC_ID_SERVER, channel->cipher,
+ channel->hmac_name,
+ channel->passphrase,
+ channel->founder_key, NULL);
goto out;
}
- }
- /* Send the same notify to the channel */
- silc_server_packet_send_to_channel(server, sock, channel, packet->type,
- FALSE, packet->buffer->data,
- packet->buffer->len, FALSE);
+ /* If server is adding founder mode, check whether there is founder
+ on channel already and is not from this server */
+ if (server->server_type == SILC_ROUTER &&
+ sock != SILC_PRIMARY_ROUTE(server) &&
+ mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
+ silc_hash_table_list(channel->user_list, &htl);
+ while (silc_hash_table_get(&htl, NULL, (void *)&chl))
+ if (chl->mode & SILC_CHANNEL_UMODE_CHANFO &&
+ chl->client->router != (SilcServerEntry)idata) {
+ SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
+ silc_server_send_notify_cmode(server, sock, FALSE, channel,
+ channel->mode, server->id,
+ SILC_ID_SERVER, channel->cipher,
+ channel->hmac_name,
+ channel->passphrase,
+ channel->founder_key, NULL);
+ silc_hash_table_list_reset(&htl);
+ goto out;
+ }
+ silc_hash_table_list_reset(&htl);
+ }
+ }
/* If the channel had private keys set and the mode was removed then
we must re-generate and re-distribute a new channel key */
/* 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);
}
- /* Change mode */
- channel->mode = mode;
-
/* Get the hmac */
tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
if (tmp) {
- unsigned char hash[32];
+ unsigned char hash[SILC_HASH_MAXLEN];
if (channel->hmac)
silc_hmac_free(channel->hmac);
/* 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));
}
channel->passphrase = silc_memdup(tmp, tmp_len);
}
+ /* Get founder public key */
+ tmp = silc_argument_get_arg_type(args, 6, &tmp_len);
+ if (tmp && mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
+ if (channel->founder_key)
+ silc_pkcs_public_key_free(channel->founder_key);
+ channel->founder_key = NULL;
+ SILC_LOG_DEBUG(("Founder public key received"));
+ if (!silc_public_key_payload_decode(tmp, tmp_len,
+ &channel->founder_key)) {
+ SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
+ mode &= ~SILC_CHANNEL_MODE_FOUNDER_AUTH;
+ silc_server_send_notify_cmode(server, sock, FALSE, channel,
+ mode, server->id, SILC_ID_SERVER,
+ channel->cipher,
+ channel->hmac_name,
+ channel->passphrase, NULL, NULL);
+ if (channel->founder_key)
+ silc_pkcs_public_key_free(channel->founder_key);
+ channel->founder_key = NULL;
+ }
+ }
+
+ if (mode & SILC_CHANNEL_MODE_FOUNDER_AUTH && !channel->founder_key &&
+ server->server_type == SILC_ROUTER) {
+ SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
+ mode &= ~SILC_CHANNEL_MODE_FOUNDER_AUTH;
+ silc_server_send_notify_cmode(server, sock, FALSE, channel,
+ mode, server->id, SILC_ID_SERVER,
+ channel->cipher,
+ channel->hmac_name,
+ channel->passphrase, NULL, NULL);
+ }
+
+ /* Process channel public key(s). */
+ tmp = silc_argument_get_arg_type(args, 7, &tmp_len);
+ if (tmp && mode & SILC_CHANNEL_MODE_CHANNEL_AUTH) {
+ SilcStatus ret;
+ SILC_LOG_DEBUG(("Channel public key list received from router"));
+
+ ret =
+ silc_server_set_channel_pk_list(server, sock, channel, tmp, tmp_len);
+
+ /* If list was set already we will enforce the same list to server. */
+ if (ret == SILC_STATUS_ERR_OPERATION_ALLOWED) {
+ SilcBuffer chpklist = silc_server_get_channel_pk_list(server, channel,
+ TRUE, FALSE);
+ silc_server_send_notify_cmode(server, sock, FALSE, channel,
+ mode, server->id, SILC_ID_SERVER,
+ channel->cipher,
+ channel->hmac_name,
+ channel->passphrase, NULL,
+ chpklist);
+ silc_buffer_free(chpklist);
+ }
+ }
+
+ /* Get the user limit */
+ tmp = silc_argument_get_arg_type(args, 8, &tmp_len);
+ if (tmp && tmp_len == 4 && mode & SILC_CHANNEL_MODE_ULIMIT)
+ SILC_GET32_MSB(channel->user_limit, tmp);
+
+ /* Send the same notify to the channel */
+ silc_server_packet_send_to_channel(server, NULL, channel, packet->type,
+ FALSE, TRUE, buffer->data,
+ silc_buffer_len(buffer));
+
+ /* Change mode */
+ channel->mode = mode;
+
+ /* Cleanup if some modes are removed */
+
+ if (!(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) &&
+ channel->founder_key) {
+ silc_pkcs_public_key_free(channel->founder_key);
+ channel->founder_key = NULL;
+ }
+
+ if (!(channel->mode & SILC_CHANNEL_MODE_CHANNEL_AUTH) &&
+ channel->channel_pubkeys) {
+ silc_hash_table_free(channel->channel_pubkeys);
+ channel->channel_pubkeys = NULL;
+ }
+
break;
case SILC_NOTIFY_TYPE_CUMODE_CHANGE:
{
- /*
+ /*
* Distribute the notify to local clients on the channel
*/
SilcChannelClientEntry chl2 = NULL;
- bool notify_sent = FALSE;
-
+ SilcBool notify_sent = FALSE;
+
SILC_LOG_DEBUG(("CUMODE CHANGE notify"));
-
+
/* Get client ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
- goto out;
- client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
- if (!client_id)
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
goto out;
/* Get client entry */
- if (id_type == SILC_ID_CLIENT) {
- client = silc_idlist_find_client_by_id(server->global_list,
- client_id, TRUE, &cache);
+ if (id.type == SILC_ID_CLIENT) {
+ client = silc_idlist_find_client_by_id(server->global_list,
+ SILC_ID_GET_ID(id),
+ TRUE, &cache);
if (!client) {
- client = silc_idlist_find_client_by_id(server->local_list,
- client_id, TRUE, &cache);
- if (!client) {
- silc_free(client_id);
+ client = silc_idlist_find_client_by_id(server->local_list,
+ SILC_ID_GET_ID(id),
+ TRUE, &cache);
+ if (!client)
goto out;
- }
}
- silc_free(client_id);
}
- if (!channel_id) {
- channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
- packet->dst_id_type);
- if (!channel_id)
- goto out;
- }
+ if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
+ packet->dst_id_type, &channel_id,
+ sizeof(channel_id)))
+ goto out;
/* Get channel entry */
- channel = silc_idlist_find_channel_by_id(server->global_list,
- channel_id, NULL);
+ channel = silc_idlist_find_channel_by_id(server->global_list,
+ &channel_id, NULL);
if (!channel) {
- channel = silc_idlist_find_channel_by_id(server->local_list,
- channel_id, NULL);
+ channel = silc_idlist_find_channel_by_id(server->local_list,
+ &channel_id, NULL);
if (!channel) {
- silc_free(channel_id);
+ SILC_LOG_DEBUG(("Notify for unknown channel %s",
+ silc_id_render(&channel_id, SILC_ID_CHANNEL)));
goto out;
}
}
/* Get the mode */
tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
- if (!tmp) {
- silc_free(channel_id);
+ if (!tmp)
goto out;
- }
-
+
SILC_GET32_MSB(mode, tmp);
-
+
/* Get target client */
- tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
- if (!tmp)
- goto out;
- client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
- if (!client_id)
+ if (!silc_argument_get_decoded(args, 3, SILC_ARGUMENT_ID, &id, NULL))
goto out;
-
+
/* Get client entry */
- client2 = silc_idlist_find_client_by_id(server->global_list,
- client_id, TRUE, NULL);
+ client2 = silc_idlist_find_client_by_id(server->global_list,
+ SILC_ID_GET_ID(id), TRUE, NULL);
if (!client2) {
- client2 = silc_idlist_find_client_by_id(server->local_list,
- client_id, TRUE, NULL);
- if (!client2) {
- silc_free(client_id);
+ client2 = silc_idlist_find_client_by_id(server->local_list,
+ SILC_ID_GET_ID(id),
+ TRUE, NULL);
+ if (!client2)
goto out;
- }
}
- silc_free(client_id);
if (client) {
/* Check that sender is on channel */
if (!silc_server_client_on_channel(client, channel, &chl))
goto out;
-
- if (client != client2) {
+
+ if (client != client2 && server->server_type == SILC_ROUTER) {
/* Sender must be operator */
if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
!(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
goto out;
}
- /* Check that target is on channel */
if (!silc_server_client_on_channel(client2, channel, &chl))
goto out;
}
}
- /* Get entry to the channel user list */
- silc_hash_table_list(channel->user_list, &htl);
- while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
- /* If the mode is channel founder and we already find a client
- to have that mode on the channel we will enforce the sender
- to change the channel founder mode away. There can be only one
- channel founder on the channel. */
- if (server->server_type == SILC_ROUTER &&
- mode & SILC_CHANNEL_UMODE_CHANFO &&
- chl->mode & SILC_CHANNEL_UMODE_CHANFO) {
- SilcBuffer idp;
- unsigned char cumode[4];
-
- if (chl->client == client && chl->mode == mode) {
- notify_sent = TRUE;
- break;
- }
+ /* Get target channel user entry */
+ if (!silc_server_client_on_channel(client2, channel, &chl))
+ goto out;
+
+ if (server->server_type == SILC_SERVER && chl->mode == mode) {
+ SILC_LOG_DEBUG(("Mode is changed already"));
+ break;
+ }
- mode &= ~SILC_CHANNEL_UMODE_CHANFO;
- silc_server_send_notify_cumode(server, sock, FALSE, channel, mode,
- client2->id, SILC_ID_CLIENT,
- client2->id);
-
- idp = silc_id_payload_encode(client2->id, SILC_ID_CLIENT);
- SILC_PUT32_MSB(mode, cumode);
- silc_server_send_notify_to_channel(server, sock, channel, FALSE,
- SILC_NOTIFY_TYPE_CUMODE_CHANGE,
- 3, idp->data, idp->len,
- cumode, 4,
- idp->data, idp->len);
- silc_buffer_free(idp);
+ /* Check whether to give founder rights to this user or not. The
+ problem here is that we get only the public key of the client,
+ but no authentication data. We must assume that server has
+ already authenticated the user (and thus we must trust the
+ server). */
+ if (mode & SILC_CHANNEL_UMODE_CHANFO &&
+ !(chl->mode & SILC_CHANNEL_UMODE_CHANFO) &&
+ server->server_type == SILC_ROUTER &&
+ sock != SILC_PRIMARY_ROUTE(server)) {
+ SilcPublicKey founder_key = NULL;
+
+ /* If channel doesn't have founder auth mode then it's impossible
+ that someone would be getting founder rights with CUMODE command.
+ In that case there already either is founder or there isn't
+ founder at all on the channel (valid only when 'client' is
+ valid). */
+ if (client && !(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
+ /* Force the mode to not have founder mode */
+ chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
+ silc_server_force_cumode_change(server, sock, channel, chl, mode);
notify_sent = TRUE;
+ break;
+ }
- /* Force the mode change if we alredy set the mode */
- if (chl2) {
- chl2->mode = mode;
- silc_free(channel_id);
- silc_hash_table_list_reset(&htl);
- goto out;
+ /* Get the founder of the channel and if found then this client
+ cannot be the founder since there already is one. */
+ silc_hash_table_list(channel->user_list, &htl);
+ while (silc_hash_table_get(&htl, NULL, (void *)&chl2))
+ if (chl2->mode & SILC_CHANNEL_UMODE_CHANFO) {
+ SILC_LOG_DEBUG(("Founder already on channel"));
+ chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
+ silc_server_force_cumode_change(server, sock, channel,
+ chl, mode);
+ notify_sent = TRUE;
+ break;
}
- }
-
- if (chl->client == client2) {
- if (chl->mode == mode) {
+ silc_hash_table_list_reset(&htl);
+ if (!(mode & SILC_CHANNEL_UMODE_CHANFO))
+ break;
+
+ /* Founder not found on the channel. Since the founder auth mode
+ is set on the channel now check whether this is the client that
+ originally set the mode. */
+
+ if (channel->founder_key) {
+ /* Get public key that must be present in notify */
+ tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
+ if (!tmp || !silc_public_key_payload_decode(tmp, tmp_len,
+ &founder_key)) {
+ chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
+ SILC_LOG_DEBUG(("Founder public key not present"));
+ silc_server_force_cumode_change(server, sock, channel, chl, mode);
notify_sent = TRUE;
break;
}
- SILC_LOG_DEBUG(("Changing the channel user mode"));
-
- /* Change the mode */
- chl->mode = mode;
- if (!(mode & SILC_CHANNEL_UMODE_CHANFO))
+ /* Now match the public key we have cached and public key sent.
+ They must match. */
+ if (!silc_pkcs_public_key_compare(channel->founder_key,
+ founder_key)) {
+ chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
+ SILC_LOG_DEBUG(("Founder public key mismatch"));
+ silc_server_force_cumode_change(server, sock, channel, chl, mode);
+ notify_sent = TRUE;
break;
-
- chl2 = chl;
+ }
}
+
+ /* There cannot be anyone else as founder on the channel now. This
+ client is definitely the founder due to this 'authentication'.
+ We trust the server did the actual signature verification
+ earlier (bad, yes). */
+ silc_hash_table_list(channel->user_list, &htl);
+ while (silc_hash_table_get(&htl, NULL, (void *)&chl2))
+ if (chl2->mode & SILC_CHANNEL_UMODE_CHANFO) {
+ chl2->mode &= ~SILC_CHANNEL_UMODE_CHANFO;
+ SILC_LOG_DEBUG(("Removing old founder rights, new authenticated"));
+ silc_server_force_cumode_change(server, NULL, channel, chl2,
+ chl2->mode);
+ break;
+ }
+ silc_hash_table_list_reset(&htl);
+
+ if (founder_key)
+ silc_pkcs_public_key_free(founder_key);
}
- silc_hash_table_list_reset(&htl);
-
+
+ if (server->server_type != SILC_SERVER && chl->mode == mode) {
+ SILC_LOG_DEBUG(("Mode is changed already"));
+ break;
+ }
+
+ SILC_LOG_DEBUG(("Changing %s channel user mode",
+ chl->client->nickname ? chl->client->nickname :
+ (unsigned char *)""));
+
+ /* Change the mode */
+ chl->mode = mode;
+
/* Send the same notify to the channel */
if (!notify_sent)
- silc_server_packet_send_to_channel(server, sock, channel,
- packet->type,
- FALSE, packet->buffer->data,
- packet->buffer->len, FALSE);
-
- silc_free(channel_id);
+ silc_server_packet_send_to_channel(server, sock, channel,
+ packet->type,
+ FALSE, TRUE, buffer->data,
+ silc_buffer_len(buffer));
+
break;
}
SILC_LOG_DEBUG(("INVITE notify"));
/* Get Channel ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
- goto out;
- channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
- if (!channel_id)
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
goto out;
/* Get channel entry */
- channel = silc_idlist_find_channel_by_id(server->global_list,
- channel_id, NULL);
+ channel = silc_idlist_find_channel_by_id(server->global_list,
+ SILC_ID_GET_ID(id), NULL);
if (!channel) {
- channel = silc_idlist_find_channel_by_id(server->local_list,
- channel_id, NULL);
+ channel = silc_idlist_find_channel_by_id(server->local_list,
+ SILC_ID_GET_ID(id), NULL);
if (!channel) {
- silc_free(channel_id);
+ SILC_LOG_DEBUG(("Notify for unknown channel %s",
+ silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
goto out;
}
}
- silc_free(channel_id);
-
- /* Get client ID */
- tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
- if (!tmp)
- goto out;
- client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
- if (!client_id)
- goto out;
- /* Get client entry */
- client = silc_idlist_find_client_by_id(server->global_list,
- client_id, TRUE, &cache);
- if (!client) {
- client = silc_idlist_find_client_by_id(server->local_list,
- client_id, TRUE, &cache);
- if (!client) {
- silc_free(client_id);
+ /* Get the invite action */
+ tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
+ if (tmp && tmp_len == 1) {
+ SilcUInt8 action = (SilcUInt8)tmp[0];
+ SilcUInt16 iargc = 0;
+ SilcArgumentPayload iargs;
+
+ /* Get invite list */
+ tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
+ if (!tmp || tmp_len < 2)
goto out;
- }
- }
- silc_free(client_id);
- /* Get user's channel entry and check that inviting is allowed. */
- if (!silc_server_client_on_channel(client, channel, &chl))
- goto out;
- if (channel->mode & SILC_CHANNEL_MODE_INVITE &&
- !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
- !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
- SILC_LOG_DEBUG(("Inviting is not allowed"));
- goto out;
- }
+ /* Parse the arguments to see they are constructed correctly */
+ SILC_GET16_MSB(iargc, tmp);
+ iargs = silc_argument_payload_parse(tmp + 2, tmp_len - 2, iargc);
+ if (!iargs)
+ goto out;
- /* Get the added invite */
- tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
- if (tmp) {
if (!channel->invite_list)
- channel->invite_list = silc_calloc(tmp_len + 2,
- sizeof(*channel->invite_list));
- else
- channel->invite_list = silc_realloc(channel->invite_list,
- sizeof(*channel->invite_list) *
- (tmp_len +
- strlen(channel->invite_list) +
- 2));
- if (tmp[tmp_len - 1] == ',')
- tmp[tmp_len - 1] = '\0';
-
- strncat(channel->invite_list, tmp, tmp_len);
- strncat(channel->invite_list, ",", 1);
- }
-
- /* Get the deleted invite */
- tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
- if (tmp && channel->invite_list) {
- char *start, *end, *n;
-
- if (!strncmp(channel->invite_list, tmp,
- strlen(channel->invite_list) - 1)) {
- silc_free(channel->invite_list);
- channel->invite_list = NULL;
- } else {
- start = strstr(channel->invite_list, tmp);
- if (start && strlen(start) >= tmp_len) {
- end = start + tmp_len;
- n = silc_calloc(strlen(channel->invite_list) - tmp_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;
- }
- }
+ channel->invite_list =
+ silc_hash_table_alloc(0, silc_hash_ptr,
+ NULL, NULL, NULL,
+ silc_server_inviteban_destruct, channel, TRUE);
+
+ /* Proces the invite action */
+ if (!silc_server_inviteban_process(server, channel->invite_list, action,
+ iargs))
+ goto out;
+ silc_argument_payload_free(iargs);
+
+ /* If we are router we must send this notify to our local servers on
+ the channel. Normal server does nothing. The notify is not
+ sent to clients. */
+ if (server->server_type == SILC_ROUTER)
+ silc_server_packet_send_to_channel(server, sock, channel,
+ packet->type, FALSE, FALSE,
+ buffer->data,
+ silc_buffer_len(buffer));
}
break;
SILC_LOG_DEBUG(("CHANNEL CHANGE"));
- if (sock->type != SILC_SOCKET_TYPE_ROUTER)
+ if (idata->conn_type != SILC_CONN_ROUTER)
break;
/* Get the old Channel ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
- goto out;
- channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
- if (!channel_id)
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
goto out;
/* Get the channel entry */
- channel = silc_idlist_find_channel_by_id(server->local_list,
- channel_id, NULL);
+ channel = silc_idlist_find_channel_by_id(server->local_list,
+ SILC_ID_GET_ID(id), NULL);
if (!channel) {
- channel = silc_idlist_find_channel_by_id(server->global_list,
- channel_id, NULL);
+ channel = silc_idlist_find_channel_by_id(server->global_list,
+ SILC_ID_GET_ID(id), NULL);
if (!channel) {
- silc_free(channel_id);
+ SILC_LOG_DEBUG(("Notify for unknown channel %s",
+ silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
goto out;
}
}
/* Send the notify to the channel */
- silc_server_packet_send_to_channel(server, sock, channel, packet->type,
- FALSE, packet->buffer->data,
- packet->buffer->len, FALSE);
+ silc_server_packet_send_to_channel(server, sock, channel, packet->type,
+ FALSE, TRUE, buffer->data,
+ silc_buffer_len(buffer));
/* Get the new Channel ID */
- tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
- if (!tmp)
- goto out;
- channel_id2 = silc_id_payload_parse_id(tmp, tmp_len, NULL);
- if (!channel_id2)
+ if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id2, NULL))
goto out;
- SILC_LOG_DEBUG(("Old Channel ID id(%s)",
- silc_id_render(channel_id, SILC_ID_CHANNEL)));
- SILC_LOG_DEBUG(("New Channel ID id(%s)",
- silc_id_render(channel_id2, SILC_ID_CHANNEL)));
+ SILC_LOG_DEBUG(("Old Channel ID id(%s)",
+ silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
+ SILC_LOG_DEBUG(("New Channel ID id(%s)",
+ silc_id_render(SILC_ID_GET_ID(id2), SILC_ID_CHANNEL)));
/* Replace the Channel ID */
- if (!silc_idlist_replace_channel_id(server->local_list, channel_id,
- channel_id2))
- if (!silc_idlist_replace_channel_id(server->global_list, channel_id,
- channel_id2)) {
- silc_free(channel_id2);
- channel_id2 = NULL;
- }
-
- if (channel_id2) {
- SilcBuffer users = NULL, users_modes = NULL;
+ ret = TRUE;
+ if (!silc_idlist_replace_channel_id(server->local_list,
+ SILC_ID_GET_ID(id),
+ SILC_ID_GET_ID(id2)))
+ if (!silc_idlist_replace_channel_id(server->global_list,
+ SILC_ID_GET_ID(id),
+ SILC_ID_GET_ID(id2)))
+ ret = FALSE;
+
+ if (ret) {
+ SilcBuffer modes = NULL, users = NULL, users_modes = NULL;
/* Re-announce this channel which ID was changed. */
silc_server_send_new_channel(server, sock, FALSE, channel->channel_name,
- channel->id,
- silc_id_get_len(channel->id,
+ channel->id,
+ silc_id_get_len(channel->id,
SILC_ID_CHANNEL),
channel->mode);
/* Re-announce our clients on the channel as the ID has changed now */
- silc_server_announce_get_channel_users(server, channel, &users,
+ silc_server_announce_get_channel_users(server, channel, &modes, &users,
&users_modes);
if (users) {
silc_buffer_push(users, users->data - users->head);
silc_server_packet_send(server, sock,
SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
- users->data, users->len, FALSE);
+ users->data, silc_buffer_len(users));
silc_buffer_free(users);
}
+ if (modes) {
+ silc_buffer_push(modes, modes->data - modes->head);
+ silc_server_packet_send_dest(server, sock,
+ SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
+ channel->id, SILC_ID_CHANNEL,
+ modes->data, silc_buffer_len(modes));
+ silc_buffer_free(modes);
+ }
if (users_modes) {
silc_buffer_push(users_modes, users_modes->data - users_modes->head);
silc_server_packet_send_dest(server, sock,
SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
channel->id, SILC_ID_CHANNEL,
- users_modes->data,
- users_modes->len, FALSE);
+ users_modes->data,
+ silc_buffer_len(users_modes));
silc_buffer_free(users_modes);
}
if (channel->topic) {
silc_server_send_notify_topic_set(server, sock,
server->server_type == SILC_ROUTER ?
- TRUE : FALSE, channel,
- channel->id, SILC_ID_CHANNEL,
+ TRUE : FALSE, channel,
+ server->id, SILC_ID_SERVER,
channel->topic);
}
}
- silc_free(channel_id);
-
break;
case SILC_NOTIFY_TYPE_SERVER_SIGNOFF:
- /*
+ /*
* Remove the server entry and all clients that this server owns.
*/
SILC_LOG_DEBUG(("SERVER SIGNOFF notify"));
+ /* Backup router shouldn't accept SERVER_SIGNOFF's from normal routers
+ when the backup isn't acting as primary router. */
+ if (idata->conn_type == SILC_CONN_SERVER &&
+ server->backup_router && server->server_type == SILC_BACKUP_ROUTER)
+ return;
+
/* Get Server ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
- goto out;
- server_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
- if (!server_id)
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
goto out;
+ /* If the ID is mine, this notify is not allowed. */
+ if (SILC_ID_SERVER_COMPARE(SILC_ID_GET_ID(id), server->id)) {
+ SILC_LOG_DEBUG(("Ignoring my own ID for SERVER_SIGNOFF"));
+ break;
+ }
+
/* Get server entry */
- server_entry = silc_idlist_find_server_by_id(server->global_list,
- server_id, TRUE, NULL);
- local = TRUE;
+ server_entry = silc_idlist_find_server_by_id(server->global_list,
+ SILC_ID_GET_ID(id),
+ TRUE, NULL);
+ local = FALSE;
if (!server_entry) {
- server_entry = silc_idlist_find_server_by_id(server->local_list,
- server_id, TRUE, NULL);
+ server_entry = silc_idlist_find_server_by_id(server->local_list,
+ SILC_ID_GET_ID(id),
+ TRUE, NULL);
local = TRUE;
if (!server_entry) {
/* If we are normal server then we might not have the server. Check
for (i = 1; i < silc_argument_get_arg_num(args); i++) {
/* Get Client ID */
- tmp = silc_argument_get_arg_type(args, i + 1, &tmp_len);
- if (!tmp)
- continue;
- client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
- if (!client_id)
+ if (!silc_argument_get_decoded(args, i + 1, SILC_ARGUMENT_ID,
+ &id2, NULL))
continue;
/* Get client entry */
- client = silc_idlist_find_client_by_id(server->global_list,
- client_id, TRUE, &cache);
- local = TRUE;
+ client = silc_idlist_find_client_by_id(server->global_list,
+ SILC_ID_GET_ID(id2),
+ TRUE, &cache);
+ local = FALSE;
if (!client) {
- client = silc_idlist_find_client_by_id(server->local_list,
- client_id, TRUE, &cache);
- local = FALSE;
- if (!client) {
- silc_free(client_id);
+ client = silc_idlist_find_client_by_id(server->local_list,
+ SILC_ID_GET_ID(id2),
+ TRUE, &cache);
+ local = TRUE;
+ if (!client)
continue;
- }
}
- silc_free(client_id);
/* Update statistics */
server->stat.clients--;
SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
/* Remove the client from all channels. */
- silc_server_remove_from_channels(server, NULL, client,
- TRUE, NULL, FALSE);
+ silc_server_remove_from_channels(server, NULL, client,
+ TRUE, NULL, FALSE, FALSE);
/* Check if anyone is watching this nickname */
if (server->server_type == SILC_ROUTER)
silc_server_del_from_watcher_list(server, client);
/* Remove the client */
+ silc_dlist_del(server->expired_clients, client);
+ silc_idlist_del_data(client);
silc_idlist_del_client(local ? server->local_list :
server->global_list, client);
}
}
- silc_free(server_id);
goto out;
}
}
- silc_free(server_id);
- /* Free all client entries that this server owns as they will
- become invalid now as well. */
- silc_server_remove_clients_by_server(server, server_entry, TRUE);
+ /* For local entrys SERVER_SIGNOFF is processed only on backup router.
+ It is possible that router sends server signoff for a server. If
+ backup router has it as local connection it will be closed. */
+ if (SILC_IS_LOCAL(server_entry)) {
+ if (server->server_type == SILC_BACKUP_ROUTER) {
+ sock = server_entry->connection;
+ SILC_LOG_DEBUG(("Closing connection after SERVER_SIGNOFF"));
+ silc_server_free_sock_user_data(server, sock, NULL);
+ silc_server_close_connection(server, sock);
+ }
+
+ break;
+ }
+
+ /* Remove all servers that are originated from this server, and
+ remove the clients of those servers too. */
+ silc_server_remove_servers_by_server(server, server_entry, TRUE);
+
+ /* Remove the clients that this server owns as they will become
+ invalid now too. */
+ silc_server_remove_clients_by_server(server, server_entry->router,
+ server_entry, TRUE);
+ silc_server_backup_del(server, server_entry);
/* Remove the server entry */
silc_idlist_del_server(local ? server->local_list :
server->global_list, server_entry);
- /* XXX update statistics */
+ /* Update statistics */
+ if (server->server_type == SILC_ROUTER)
+ server->stat.servers--;
break;
case SILC_NOTIFY_TYPE_KICKED:
- /*
+ /*
* Distribute the notify to local clients on the channel
*/
-
+
SILC_LOG_DEBUG(("KICKED notify"));
-
- if (!channel_id) {
- channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
- packet->dst_id_type);
- if (!channel_id)
- goto out;
- }
+
+ if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
+ packet->dst_id_type, &channel_id,
+ sizeof(channel_id)))
+ goto out;
/* Get channel entry */
- channel = silc_idlist_find_channel_by_id(server->global_list,
- channel_id, NULL);
+ channel = silc_idlist_find_channel_by_id(server->global_list,
+ &channel_id, NULL);
if (!channel) {
- channel = silc_idlist_find_channel_by_id(server->local_list,
- channel_id, NULL);
+ channel = silc_idlist_find_channel_by_id(server->local_list,
+ &channel_id, NULL);
if (!channel) {
- silc_free(channel_id);
+ SILC_LOG_DEBUG(("Notify for unknown channel %s",
+ silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
goto out;
}
}
- silc_free(channel_id);
/* Get client ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
- goto out;
- client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
- if (!client_id)
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
goto out;
/* If the the client is not in local list we check global list */
- client = silc_idlist_find_client_by_id(server->global_list,
- client_id, TRUE, NULL);
+ client = silc_idlist_find_client_by_id(server->global_list,
+ SILC_ID_GET_ID(id), TRUE, NULL);
if (!client) {
- client = silc_idlist_find_client_by_id(server->local_list,
- client_id, TRUE, NULL);
- if (!client) {
- silc_free(client_id);
+ client = silc_idlist_find_client_by_id(server->local_list,
+ SILC_ID_GET_ID(id), TRUE, NULL);
+ if (!client)
goto out;
- }
}
- silc_free(client_id);
/* If target is founder they cannot be kicked */
if (!silc_server_client_on_channel(client, channel, &chl))
goto out;
if (chl->mode & SILC_CHANNEL_UMODE_CHANFO)
goto out;
-
- /* From protocol version 1.1 we get the kicker's ID as well. */
- tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
- if (tmp) {
- client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
- if (!client_id)
- goto out;
- /* If the the client is not in local list we check global list */
- client2 = silc_idlist_find_client_by_id(server->global_list,
- client_id, TRUE, NULL);
- if (!client2) {
- client2 = silc_idlist_find_client_by_id(server->local_list,
- client_id, TRUE, NULL);
- if (!client2) {
- silc_free(client_id);
- goto out;
- }
- }
- silc_free(client_id);
+ /* Get the kicker's Client ID */
+ if (!silc_argument_get_decoded(args, 3, SILC_ARGUMENT_ID, &id, NULL))
+ goto out;
- /* Kicker must be operator on channel */
- if (!silc_server_client_on_channel(client2, channel, &chl))
- goto out;
- if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
- !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
- SILC_LOG_DEBUG(("Kicking is not allowed"));
+ /* If the the client is not in local list we check global list */
+ client2 = silc_idlist_find_client_by_id(server->global_list,
+ SILC_ID_GET_ID(id), TRUE, NULL);
+ if (!client2) {
+ client2 = silc_idlist_find_client_by_id(server->local_list,
+ SILC_ID_GET_ID(id), TRUE, NULL);
+ if (!client2)
goto out;
- }
+ }
+
+ /* Kicker must be operator on channel */
+ if (!silc_server_client_on_channel(client2, channel, &chl))
+ goto out;
+ if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
+ !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
+ SILC_LOG_DEBUG(("Kicking is not allowed"));
+ goto out;
}
/* Send to channel */
- silc_server_packet_send_to_channel(server, sock, channel, packet->type,
- FALSE, packet->buffer->data,
- packet->buffer->len, FALSE);
+ silc_server_packet_send_to_channel(server, sock, channel, packet->type,
+ FALSE, TRUE, buffer->data,
+ silc_buffer_len(buffer));
+
+ /* Remove the client from channel's invite list */
+ if (channel->invite_list && silc_hash_table_count(channel->invite_list)) {
+ SilcBuffer ab;
+ SilcArgumentPayload iargs;
+ tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
+ ab = silc_argument_payload_encode_one(NULL, tmp, tmp_len, 3);
+ iargs = silc_argument_payload_parse(ab->data, silc_buffer_len(ab), 1);
+ silc_server_inviteban_process(server, channel->invite_list, 1, iargs);
+ silc_buffer_free(ab);
+ silc_argument_payload_free(iargs);
+ }
/* Remove the client from channel */
silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
case SILC_NOTIFY_TYPE_KILLED:
{
- /*
+ /*
* Distribute the notify to local clients on channels
*/
- unsigned char *id, *comment;
- SilcUInt32 id_len, comment_len;
-
+ unsigned char *comment;
+ SilcUInt32 comment_len;
+
SILC_LOG_DEBUG(("KILLED notify"));
-
+
/* Get client ID */
- id = silc_argument_get_arg_type(args, 1, &id_len);
- if (!id)
- goto out;
- client_id = silc_id_payload_parse_id(id, id_len, NULL);
- if (!client_id)
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
goto out;
/* If the the client is not in local list we check global list */
- client = silc_idlist_find_client_by_id(server->global_list,
- client_id, TRUE, NULL);
+ client = silc_idlist_find_client_by_id(server->global_list,
+ SILC_ID_GET_ID(id), TRUE, &cache);
if (!client) {
- client = silc_idlist_find_client_by_id(server->local_list,
- client_id, TRUE, NULL);
- if (!client) {
- silc_free(client_id);
+ client = silc_idlist_find_client_by_id(server->local_list,
+ SILC_ID_GET_ID(id),
+ TRUE, &cache);
+ if (!client)
goto out;
- }
}
- silc_free(client_id);
/* If the client is one of ours, then close the connection to the
client now. This removes the client from all channels as well. */
if (comment_len > 128)
comment_len = 127;
- /* From protocol version 1.1 we get the killer's ID as well. */
- tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
- if (tmp) {
- client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
- if (!client_id)
- goto out;
-
- if (id_type == SILC_ID_CLIENT) {
- /* If the the client is not in local list we check global list */
- client2 = silc_idlist_find_client_by_id(server->global_list,
- client_id, TRUE, NULL);
- if (!client2) {
- client2 = silc_idlist_find_client_by_id(server->local_list,
- client_id, TRUE, NULL);
- if (!client2) {
- silc_free(client_id);
- goto out;
- }
- }
- silc_free(client_id);
+ /* Get the killer's Client ID */
+ if (!silc_argument_get_decoded(args, 3, SILC_ARGUMENT_ID, &id, NULL))
+ goto out;
- /* Killer must be router operator */
- if (!(client2->mode & SILC_UMODE_ROUTER_OPERATOR)) {
- SILC_LOG_DEBUG(("Killing is not allowed"));
+ if (id.type == SILC_ID_CLIENT) {
+ /* If the the client is not in local list we check global list */
+ client2 = silc_idlist_find_client_by_id(server->global_list,
+ SILC_ID_GET_ID(id),
+ TRUE, NULL);
+ if (!client2) {
+ client2 = silc_idlist_find_client_by_id(server->local_list,
+ SILC_ID_GET_ID(id),
+ TRUE, NULL);
+ if (!client2)
goto out;
- }
+ }
+
+ /* Killer must be router operator */
+ if (server->server_type != SILC_SERVER &&
+ !(client2->mode & SILC_UMODE_ROUTER_OPERATOR)) {
+ SILC_LOG_DEBUG(("Killing is not allowed"));
+ goto out;
}
}
/* Send the notify to local clients on the channels except to the
client who is killed. */
+ tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
+ tmp2 = silc_argument_get_arg_type(args, 3, &tmp2_len);
silc_server_send_notify_on_channels(server, client, client,
SILC_NOTIFY_TYPE_KILLED, 3,
- id, id_len, comment, comment_len,
- tmp, tmp_len);
+ tmp, tmp_len, comment, comment_len,
+ tmp2, tmp2_len);
/* Remove the client from all channels */
- silc_server_remove_from_channels(server, NULL, client, FALSE, NULL,
- FALSE);
+ silc_server_remove_from_channels(server, NULL, client, FALSE, NULL,
+ FALSE, TRUE);
/* Check if anyone is watching this nickname */
if (server->server_type == SILC_ROUTER)
silc_server_check_watcher_list(server, client, NULL,
SILC_NOTIFY_TYPE_KILLED);
+ /* Remove client's public key from repository, this will free it too. */
+ if (client->data.public_key) {
+ silc_skr_del_public_key(server->repository, client->data.public_key,
+ client);
+ client->data.public_key = NULL;
+ }
+
+ /* Update statistics */
+ server->stat.clients--;
+ if (server->stat.cell_clients)
+ server->stat.cell_clients--;
+ SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
+ SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
+
+ if (SILC_IS_LOCAL(client)) {
+ server->stat.my_clients--;
+ silc_schedule_task_del_by_context(server->schedule, client);
+ silc_idlist_del_data(client);
+ client->mode = 0;
+ }
+
+ client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
+ client->mode = 0;
+ client->router = NULL;
+ client->connection = NULL;
+ client->data.created = silc_time();
+ silc_dlist_del(server->expired_clients, client);
+ silc_dlist_add(server->expired_clients, client);
break;
}
SILC_LOG_DEBUG(("UMODE_CHANGE notify"));
/* Get client ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
- goto out;
- client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
- if (!client_id)
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
goto out;
/* Get client entry */
- client = silc_idlist_find_client_by_id(server->global_list,
- client_id, TRUE, NULL);
+ client = silc_idlist_find_client_by_id(server->global_list,
+ SILC_ID_GET_ID(id), TRUE, NULL);
if (!client) {
- client = silc_idlist_find_client_by_id(server->local_list,
- client_id, TRUE, NULL);
- if (!client) {
- silc_free(client_id);
+ client = silc_idlist_find_client_by_id(server->local_list,
+ SILC_ID_GET_ID(id), TRUE, NULL);
+ if (!client)
goto out;
- }
}
- silc_free(client_id);
/* Get the mode */
tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
goto out;
SILC_GET32_MSB(mode, tmp);
- /* Check that mode changing is allowed. */
- if (!silc_server_check_umode_rights(server, client, mode)) {
- SILC_LOG_DEBUG(("UMODE change is not allowed"));
- goto out;
- }
-
/* Remove internal resumed flag if client is marked detached now */
if (mode & SILC_UMODE_DETACHED)
client->data.status &= ~SILC_IDLIST_STATUS_RESUMED;
+ /* Update statistics */
+ if (server->server_type == SILC_ROUTER) {
+ if (mode & SILC_UMODE_GONE) {
+ if (!(client->mode & SILC_UMODE_GONE))
+ server->stat.aways++;
+ } else {
+ if (client->mode & SILC_UMODE_GONE)
+ server->stat.aways--;
+ }
+ if (mode & SILC_UMODE_DETACHED) {
+ if (!(client->mode & SILC_UMODE_DETACHED))
+ server->stat.detached++;
+ } else {
+ if (client->mode & SILC_UMODE_DETACHED)
+ server->stat.detached--;
+ }
+ }
+ SILC_UMODE_STATS_UPDATE(server, SILC_UMODE_SERVER_OPERATOR);
+ SILC_UMODE_STATS_UPDATE(router, SILC_UMODE_ROUTER_OPERATOR);
+
/* Change the mode */
client->mode = mode;
*/
SILC_LOG_DEBUG(("BAN notify"));
-
+
/* Get Channel ID */
- tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
- if (!tmp)
+ if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
goto out;
- channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
- if (!channel_id)
- goto out;
-
+
/* Get channel entry */
- channel = silc_idlist_find_channel_by_id(server->global_list,
- channel_id, NULL);
+ channel = silc_idlist_find_channel_by_id(server->global_list,
+ SILC_ID_GET_ID(id), NULL);
if (!channel) {
- channel = silc_idlist_find_channel_by_id(server->local_list,
- channel_id, NULL);
+ channel = silc_idlist_find_channel_by_id(server->local_list,
+ SILC_ID_GET_ID(id), NULL);
if (!channel) {
- silc_free(channel_id);
+ SILC_LOG_DEBUG(("Notify for unknown channel %s",
+ silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
goto out;
}
}
- silc_free(channel_id);
- /* Get the new ban and add it to the ban list */
+ /* Get the ban action */
tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
- if (tmp) {
+ if (tmp && tmp_len == 1) {
+ SilcUInt8 action = (SilcUInt8)tmp[0];
+ SilcUInt16 iargc = 0;
+ SilcArgumentPayload iargs;
+
+ /* Get ban list */
+ tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
+ if (!tmp || tmp_len < 2)
+ goto out;
+
+ /* Parse the arguments to see they are constructed correctly */
+ SILC_GET16_MSB(iargc, tmp);
+ iargs = silc_argument_payload_parse(tmp + 2, tmp_len - 2, iargc);
+ if (!iargs)
+ goto out;
+
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));
- strncat(channel->ban_list, tmp, tmp_len);
- strncat(channel->ban_list, ",", 1);
- }
-
- /* Get the ban to be removed and remove it from the list */
- tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
- if (tmp && channel->ban_list) {
- char *start, *end, *n;
-
- if (!strncmp(channel->ban_list, tmp, strlen(channel->ban_list) - 1)) {
- silc_free(channel->ban_list);
- channel->ban_list = NULL;
- } else {
- start = strstr(channel->ban_list, tmp);
- 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;
- }
- }
+ channel->ban_list =
+ silc_hash_table_alloc(0, silc_hash_ptr,
+ NULL, NULL, NULL,
+ silc_server_inviteban_destruct, channel, TRUE);
+
+ /* Proces the ban action */
+ if (!silc_server_inviteban_process(server, channel->ban_list, action,
+ iargs))
+ goto out;
+ silc_argument_payload_free(iargs);
+
+ /* If we are router we must send this notify to our local servers on
+ the channel. Normal server does nothing. The notify is not
+ sent to clients. */
+ if (server->server_type == SILC_ROUTER)
+ silc_server_packet_send_to_channel(server, sock, channel,
+ packet->type, FALSE, FALSE,
+ buffer->data,
+ silc_buffer_len(buffer));
}
break;
SILC_LOG_DEBUG(("ERROR notify (%d)", error));
if (error == SILC_STATUS_ERR_NO_SUCH_CLIENT_ID &&
- sock->type == SILC_SOCKET_TYPE_ROUTER) {
- tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
- if (tmp) {
- SILC_LOG_DEBUG(("Received invalid client ID notification, deleting "
- "the entry from cache"));
- client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
- if (!client_id)
- goto out;
- client = silc_idlist_find_client_by_id(server->global_list,
- client_id, FALSE, NULL);
- if (client) {
- silc_server_remove_from_channels(server, NULL, client, TRUE,
- NULL, TRUE);
- silc_idlist_del_client(server->global_list, client);
- }
- silc_free(client_id);
- }
+ idata->conn_type == SILC_CONN_ROUTER) {
+ if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL))
+ goto out;
+
+ SILC_LOG_DEBUG(("Received invalid client ID notification, deleting "
+ "the entry from cache"));
+
+ client = silc_idlist_find_client_by_id(server->global_list,
+ SILC_ID_GET_ID(id),
+ FALSE, NULL);
+ if (!client)
+ goto out;
+
+ silc_server_remove_from_channels(server, NULL, client, TRUE,
+ NULL, TRUE, FALSE);
+ silc_dlist_del(server->expired_clients, client);
+ silc_idlist_del_data(client);
+ silc_idlist_del_client(server->global_list, client);
}
}
break;
case SILC_NOTIFY_TYPE_NONE:
case SILC_NOTIFY_TYPE_MOTD:
break;
+
default:
+ SILC_LOG_DEBUG(("Unsupported notify %d", type));
break;
}
silc_notify_payload_free(payload);
}
+void silc_server_notify(SilcServer server,
+ SilcPacketStream sock,
+ SilcPacket packet)
+{
+ silc_server_notify_process(server, sock, packet, &packet->buffer);
+ silc_packet_free(packet);
+}
+
void silc_server_notify_list(SilcServer server,
- SilcSocketConnection sock,
- SilcPacketContext *packet)
+ SilcPacketStream sock,
+ SilcPacket packet)
{
- SilcPacketContext *new;
- SilcBuffer buffer;
+ SilcIDListData idata = silc_packet_get_context(sock);
SilcUInt16 len;
+ SilcBuffer buffer;
SILC_LOG_DEBUG(("Processing Notify List"));
- if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
+ if (idata->conn_type == SILC_CONN_CLIENT ||
packet->src_id_type != SILC_ID_SERVER)
return;
- /* Make copy of the original packet context, except for the actual
- data buffer, which we will here now fetch from the original buffer. */
- new = silc_packet_context_alloc();
- new->type = SILC_PACKET_NOTIFY;
- new->flags = packet->flags;
- new->src_id = packet->src_id;
- new->src_id_len = packet->src_id_len;
- new->src_id_type = packet->src_id_type;
- new->dst_id = packet->dst_id;
- new->dst_id_len = packet->dst_id_len;
- new->dst_id_type = packet->dst_id_type;
-
buffer = silc_buffer_alloc(1024);
- new->buffer = buffer;
+ if (!buffer)
+ return;
- while (packet->buffer->len) {
- SILC_GET16_MSB(len, packet->buffer->data + 2);
- if (len > packet->buffer->len)
+ while (silc_buffer_len(&packet->buffer)) {
+ SILC_GET16_MSB(len, packet->buffer.data + 2);
+ if (len > silc_buffer_len(&packet->buffer))
break;
- if (len > buffer->truelen) {
+ if (len > silc_buffer_truelen(buffer)) {
silc_buffer_free(buffer);
buffer = silc_buffer_alloc(1024 + len);
}
silc_buffer_pull_tail(buffer, len);
- silc_buffer_put(buffer, packet->buffer->data, len);
+ silc_buffer_put(buffer, packet->buffer.data, len);
/* Process the Notify */
- silc_server_notify(server, sock, new);
+ silc_server_notify_process(server, sock, packet, buffer);
silc_buffer_push_tail(buffer, len);
- silc_buffer_pull(packet->buffer, len);
+ silc_buffer_pull(&packet->buffer, len);
}
+ silc_packet_free(packet);
silc_buffer_free(buffer);
- silc_free(new);
}
-/* Received private message. This resolves the destination of the message
+/* Received private message. This resolves the destination of the message
and sends the packet. This is used by both server and router. If the
destination is our locally connected client this sends the packet to
the client. This may also send the message for further routing if
the destination is not in our server (or router). */
void silc_server_private_message(SilcServer server,
- SilcSocketConnection sock,
- SilcPacketContext *packet)
+ SilcPacketStream sock,
+ SilcPacket packet)
{
- SilcSocketConnection dst_sock;
+ SilcPacketStream dst_sock;
SilcIDListData idata;
SilcClientEntry client;
+ SilcClientID client_id;
SILC_LOG_DEBUG(("Start"));
if (packet->src_id_type != SILC_ID_CLIENT ||
packet->dst_id_type != SILC_ID_CLIENT || !packet->dst_id)
- return;
+ goto out;
/* Get the route to the client */
dst_sock = silc_server_get_client_route(server, packet->dst_id,
- packet->dst_id_len, NULL,
+ packet->dst_id_len, NULL,
&idata, &client);
if (!dst_sock) {
SilcBuffer idp;
if (client && client->mode & SILC_UMODE_DETACHED) {
SILC_LOG_DEBUG(("Client is detached, discarding packet"));
- return;
+ goto out;
}
/* Send SILC_NOTIFY_TYPE_ERROR to indicate that such destination ID
packet->dst_id_len,
packet->dst_id_type);
if (!idp)
- return;
+ goto out;
error = SILC_STATUS_ERR_NO_SUCH_CLIENT_ID;
if (packet->src_id_type == SILC_ID_CLIENT) {
- SilcClientID *client_id = silc_id_str2id(packet->src_id,
- packet->src_id_len,
- packet->src_id_type);
+ silc_id_str2id(packet->src_id, packet->src_id_len,
+ packet->src_id_type, &client_id, sizeof(client_id));
silc_server_send_notify_dest(server, sock, FALSE,
- client_id, SILC_ID_CLIENT,
+ &client_id, SILC_ID_CLIENT,
SILC_NOTIFY_TYPE_ERROR, 2,
&error, 1,
- idp->data, idp->len);
- silc_free(client_id);
+ idp->data, silc_buffer_len(idp));
} else {
silc_server_send_notify(server, sock, FALSE,
SILC_NOTIFY_TYPE_ERROR, 2,
&error, 1,
- idp->data, idp->len);
+ idp->data, silc_buffer_len(idp));
}
silc_buffer_free(idp);
- return;
+ goto out;
}
/* Check whether destination client wishes to receive private messages */
if (client && !(packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY) &&
client->mode & SILC_UMODE_BLOCK_PRIVMSG) {
SILC_LOG_DEBUG(("Client blocks private messages, discarding packet"));
- return;
+ goto out;
}
/* Send the private message */
- silc_server_send_private_message(server, dst_sock, idata->send_key,
- idata->hmac_send, idata->psn_send++,
- packet);
+ silc_server_packet_route(server, dst_sock, packet);
+
+ out:
+ silc_packet_free(packet);
}
/* Received private message key packet.. This packet is never for us. It is to
one client to another. */
void silc_server_private_message_key(SilcServer server,
- SilcSocketConnection sock,
- SilcPacketContext *packet)
+ SilcPacketStream sock,
+ SilcPacket packet)
{
- SilcSocketConnection dst_sock;
+ SilcPacketStream dst_sock;
SilcIDListData idata;
SILC_LOG_DEBUG(("Start"));
if (packet->src_id_type != SILC_ID_CLIENT ||
- packet->dst_id_type != SILC_ID_CLIENT)
- return;
-
- if (!packet->dst_id)
+ packet->dst_id_type != SILC_ID_CLIENT || !packet->dst_id) {
+ silc_packet_free(packet);
return;
+ }
/* Get the route to the client */
dst_sock = silc_server_get_client_route(server, packet->dst_id,
- packet->dst_id_len, NULL,
+ packet->dst_id_len, NULL,
&idata, NULL);
- if (!dst_sock)
+ if (!dst_sock) {
+ silc_packet_free(packet);
return;
+ }
/* Relay the packet */
- silc_server_relay_packet(server, dst_sock, idata->send_key,
- idata->hmac_send, idata->psn_send++, packet, FALSE);
+ silc_server_packet_route(server, dst_sock, packet);
+
+ silc_packet_free(packet);
}
/* Processes incoming command reply packet. The command reply packet may
- be destined to one of our clients or it may directly for us. We will
+ be destined to one of our clients or it may directly for us. We will
call the command reply routine after processing the packet. */
void silc_server_command_reply(SilcServer server,
- SilcSocketConnection sock,
- SilcPacketContext *packet)
+ SilcPacketStream sock,
+ SilcPacket packet)
{
- SilcBuffer buffer = packet->buffer;
+ SilcBuffer buffer = &packet->buffer;
SilcClientEntry client = NULL;
- SilcSocketConnection dst_sock;
- SilcIDListData idata;
- SilcClientID *id = NULL;
+ SilcClientID id;
SILC_LOG_DEBUG(("Start"));
- /* Source must be server or router */
- if (packet->src_id_type != SILC_ID_SERVER &&
- sock->type != SILC_SOCKET_TYPE_ROUTER)
- return;
-
- if (packet->dst_id_type == SILC_ID_CHANNEL)
+ if (packet->dst_id_type == SILC_ID_CHANNEL) {
+ silc_packet_free(packet);
return;
+ }
if (packet->dst_id_type == SILC_ID_CLIENT) {
/* Destination must be one of ours */
- id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CLIENT);
- if (!id)
+ if (!silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CLIENT,
+ &id, sizeof(id))) {
+ silc_packet_free(packet);
return;
- client = silc_idlist_find_client_by_id(server->local_list, id, TRUE, NULL);
+ }
+ client = silc_idlist_find_client_by_id(server->local_list, &id,
+ TRUE, NULL);
if (!client) {
SILC_LOG_ERROR(("Cannot process command reply to unknown client"));
- silc_free(id);
+ silc_packet_free(packet);
return;
}
}
/* For now this must be for us */
if (memcmp(packet->dst_id, server->id_string, server->id_string_len)) {
SILC_LOG_ERROR(("Cannot process command reply to unknown server"));
+ silc_packet_free(packet);
return;
}
}
/* Execute command reply locally for the command */
silc_server_command_reply_process(server, sock, buffer);
- if (packet->dst_id_type == SILC_ID_CLIENT && client && id) {
- /* Relay the packet to the client */
- const SilcBufferStruct p;
-
- dst_sock = (SilcSocketConnection)client->connection;
- idata = (SilcIDListData)client;
-
- silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
- + packet->dst_id_len + packet->padlen);
- if (!silc_packet_send_prepare(dst_sock, 0, 0, buffer->len,
- idata->hmac_send, (const SilcBuffer)&p)) {
- SILC_LOG_ERROR(("Cannot send packet"));
- return;
- }
- silc_buffer_put((SilcBuffer)&p, buffer->data, buffer->len);
-
- /* Encrypt packet */
- silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
- (SilcBuffer)&p, buffer->len);
-
- /* Send the packet */
- silc_server_packet_send_real(server, dst_sock, TRUE);
+ /* Relay the packet to the client */
+ if (packet->dst_id_type == SILC_ID_CLIENT && client)
+ silc_server_packet_route(server, client->connection, packet);
- silc_free(id);
- }
+ silc_packet_free(packet);
}
/* Process received channel message. The message can be originated from
client or server. */
void silc_server_channel_message(SilcServer server,
- SilcSocketConnection sock,
- SilcPacketContext *packet)
+ SilcPacketStream sock,
+ SilcPacket packet)
{
SilcChannelEntry channel = NULL;
- SilcChannelID *id = NULL;
- void *sender_id = NULL;
+ SilcChannelID id;
+ SilcClientID cid;
+ SilcID sid;
SilcClientEntry sender_entry = NULL;
+ SilcIDListData idata;
SilcChannelClientEntry chl;
- bool local = TRUE;
+ SilcBool local = TRUE;
SILC_LOG_DEBUG(("Processing channel message"));
}
/* Find channel entry */
- id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CHANNEL);
- if (!id)
+ if (!silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CHANNEL,
+ &id, sizeof(id)))
goto out;
- channel = silc_idlist_find_channel_by_id(server->local_list, id, NULL);
+ channel = silc_idlist_find_channel_by_id(server->local_list, &id, NULL);
if (!channel) {
- channel = silc_idlist_find_channel_by_id(server->global_list, id, NULL);
+ channel = silc_idlist_find_channel_by_id(server->global_list, &id, NULL);
if (!channel) {
SilcBuffer idp;
unsigned char error;
error = SILC_STATUS_ERR_NO_SUCH_CHANNEL_ID;
if (packet->src_id_type == SILC_ID_CLIENT) {
- SilcClientID *client_id = silc_id_str2id(packet->src_id,
- packet->src_id_len,
- packet->src_id_type);
+ silc_id_str2id(packet->src_id, packet->src_id_len,
+ packet->src_id_type, &cid, sizeof(cid));
silc_server_send_notify_dest(server, sock, FALSE,
- client_id, SILC_ID_CLIENT,
+ &cid, SILC_ID_CLIENT,
SILC_NOTIFY_TYPE_ERROR, 2,
- &error, 1, idp->data, idp->len);
- silc_free(client_id);
+ &error, 1, idp->data,
+ silc_buffer_len(idp));
} else {
silc_server_send_notify(server, sock, FALSE,
SILC_NOTIFY_TYPE_ERROR, 2,
- &error, 1, idp->data, idp->len);
+ &error, 1, idp->data, silc_buffer_len(idp));
}
-
+
silc_buffer_free(idp);
goto out;
}
/* See that this client is on the channel. If the original sender is
not client (as it can be server as well) we don't do the check. */
- sender_id = silc_id_str2id(packet->src_id, packet->src_id_len,
- packet->src_id_type);
- if (!sender_id)
+ if (!silc_id_str2id2(packet->src_id, packet->src_id_len,
+ packet->src_id_type, &sid))
goto out;
- if (packet->src_id_type == SILC_ID_CLIENT) {
- sender_entry = silc_idlist_find_client_by_id(server->local_list,
- sender_id, TRUE, NULL);
+ if (sid.type == SILC_ID_CLIENT) {
+ sender_entry = silc_idlist_find_client_by_id(server->local_list,
+ SILC_ID_GET_ID(sid),
+ TRUE, NULL);
if (!sender_entry) {
local = FALSE;
- sender_entry = silc_idlist_find_client_by_id(server->global_list,
- sender_id, TRUE, NULL);
+ sender_entry = silc_idlist_find_client_by_id(server->global_list,
+ SILC_ID_GET_ID(sid),
+ TRUE, NULL);
}
- if (!sender_entry || !silc_server_client_on_channel(sender_entry,
+ if (!sender_entry || !silc_server_client_on_channel(sender_entry,
channel, &chl)) {
SILC_LOG_DEBUG(("Client not on channel"));
goto out;
/* If channel is moderated check that client is allowed to send
messages. */
- if (channel->mode & SILC_CHANNEL_MODE_SILENCE_USERS &&
+ if (channel->mode & SILC_CHANNEL_MODE_SILENCE_USERS &&
!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
!(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
SILC_LOG_DEBUG(("Channel is silenced from normal users"));
goto out;
}
- if (channel->mode & SILC_CHANNEL_MODE_SILENCE_OPERS &&
+ if (channel->mode & SILC_CHANNEL_MODE_SILENCE_OPERS &&
chl->mode & SILC_CHANNEL_UMODE_CHANOP &&
!(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
SILC_LOG_DEBUG(("Channel is silenced from operators"));
goto out;
}
+ if (chl->mode & SILC_CHANNEL_UMODE_QUIET) {
+ SILC_LOG_DEBUG(("Sender is quieted on the channel"));
+ goto out;
+ }
- /* If the packet is coming from router, but the client entry is local
- entry to us then some router is rerouting this to us and it is not
+ /* If the packet is coming from router, but the client entry is local
+ entry to us then some router is rerouting this to us and it is not
allowed. When the client is local to us it means that we've routed
this packet to network, and now someone is routing it back to us. */
+ idata = silc_packet_get_context(sock);
if (server->server_type == SILC_ROUTER &&
- sock->type == SILC_SOCKET_TYPE_ROUTER && local) {
+ idata->conn_type == SILC_CONN_ROUTER && local) {
SILC_LOG_DEBUG(("Channel message rerouted to the sender, drop it"));
goto out;
}
/* Distribute the packet to our local clients. This will send the
packet for further routing as well, if needed. */
- silc_server_packet_relay_to_channel(server, sock, channel, sender_id,
- packet->src_id_type, sender_entry,
- packet->buffer->data,
- packet->buffer->len, FALSE);
+ silc_server_packet_relay_to_channel(server, sock, channel,
+ SILC_ID_GET_ID(sid), sid.type,
+ sender_entry, packet->buffer.data,
+ silc_buffer_len(&packet->buffer));
out:
- silc_free(sender_id);
- silc_free(id);
+ silc_packet_free(packet);
}
/* Received channel key packet. We distribute the key to all of our locally
connected clients on the channel. */
void silc_server_channel_key(SilcServer server,
- SilcSocketConnection sock,
- SilcPacketContext *packet)
+ SilcPacketStream sock,
+ SilcPacket packet)
{
- SilcBuffer buffer = packet->buffer;
+ SilcBuffer buffer = &packet->buffer;
+ SilcIDListData idata = silc_packet_get_context(sock);
SilcChannelEntry channel;
if (packet->src_id_type != SILC_ID_SERVER ||
- (server->server_type == SILC_ROUTER &&
- sock->type == SILC_SOCKET_TYPE_ROUTER))
+ (server->server_type == SILC_ROUTER && !server->backup_router &&
+ idata->conn_type == SILC_CONN_ROUTER)) {
+ silc_packet_free(packet);
return;
+ }
/* Save the channel key */
channel = silc_server_save_channel_key(server, buffer, NULL);
- if (!channel)
+ if (!channel) {
+ SILC_LOG_ERROR(("Bad channel key from %s", idata->sconn->remote_host));
+ silc_packet_free(packet);
return;
+ }
/* Distribute the key to everybody who is on the channel. If we are router
we will also send it to locally connected servers. */
silc_server_send_channel_key(server, sock, channel, FALSE);
-
- if (server->server_type != SILC_BACKUP_ROUTER) {
+
+ if (server->server_type != SILC_BACKUP_ROUTER)
/* Distribute to local cell backup routers. */
- silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
+ silc_server_backup_send(server, (SilcServerEntry)idata,
SILC_PACKET_CHANNEL_KEY, 0,
- buffer->data, buffer->len, FALSE, TRUE);
- }
+ buffer->data, silc_buffer_len(buffer),
+ FALSE, TRUE);
+
+ silc_packet_free(packet);
}
/* Received New Client packet and processes it. Creates Client ID for the
client. Client becomes registered after calling this functions. */
SilcClientEntry silc_server_new_client(SilcServer server,
- SilcSocketConnection sock,
- SilcPacketContext *packet)
+ SilcPacketStream sock,
+ SilcPacket packet)
{
- SilcBuffer buffer = packet->buffer;
+ SilcBuffer buffer = &packet->buffer;
+ SilcIDListData idata = silc_packet_get_context(sock);
SilcClientEntry client;
SilcClientID *client_id;
- SilcIDListData idata;
char *username = NULL, *realname = NULL;
- SilcUInt16 username_len;
- SilcUInt32 id_len;
+ SilcUInt16 username_len, nickname_len;
+ SilcUInt32 id_len, tmp_len;
int ret;
- char *hostname, *nickname;
- int nickfail = 0;
+ char *host, *nickname = NULL, *nicknamec;
+ const char *hostname, *ip;
SILC_LOG_DEBUG(("Creating new client"));
- if (sock->type != SILC_SOCKET_TYPE_CLIENT)
+ if (idata->conn_type != SILC_CONN_CLIENT) {
+ silc_packet_free(packet);
return NULL;
+ }
/* Take client entry */
- client = (SilcClientEntry)sock->user_data;
- idata = (SilcIDListData)client;
-
- /* Remove the old cache entry. */
- if (!silc_idcache_del_by_context(server->local_list->clients, client)) {
- SILC_LOG_INFO(("Unauthenticated client attempted to register to network"));
- silc_server_disconnect_remote(server, sock,
- SILC_STATUS_ERR_NOT_AUTHENTICATED, NULL);
+ client = (SilcClientEntry)idata;
+ silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
+ NULL, &hostname, &ip, NULL);
+
+ SILC_LOG_DEBUG(("%s %s", ip, hostname));
+
+ /* Make sure this client hasn't registered already */
+ if (idata->status & SILC_IDLIST_STATUS_REGISTERED) {
+ silc_packet_free(packet);
return NULL;
}
/* Parse incoming packet */
ret = silc_buffer_unformat(buffer,
- SILC_STR_UI16_NSTRING_ALLOC(&username,
+ SILC_STR_ADVANCE,
+ SILC_STR_UI16_NSTRING_ALLOC(&username,
&username_len),
SILC_STR_UI16_STRING_ALLOC(&realname),
SILC_STR_END);
silc_free(username);
silc_free(realname);
SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
- "connection", sock->hostname, sock->ip));
- silc_server_disconnect_remote(server, sock,
- SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
+ "connection", hostname, ip));
+ silc_server_disconnect_remote(server, sock,
+ SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
NULL);
+ silc_server_free_sock_user_data(server, sock, NULL);
+ silc_packet_free(packet);
return NULL;
}
silc_free(username);
silc_free(realname);
SILC_LOG_ERROR(("Client %s (%s) did not send its username, closing "
- "connection", sock->hostname, sock->ip));
- silc_server_disconnect_remote(server, sock,
+ "connection", hostname, ip));
+ silc_server_disconnect_remote(server, sock,
SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
NULL);
+ silc_server_free_sock_user_data(server, sock, NULL);
+ silc_packet_free(packet);
return NULL;
}
- if (username_len > 128)
- username[128] = '\0';
+ if (username_len > 128) {
+ username_len = 128;
+ username[username_len - 1] = '\0';
+ }
- /* Check for bad characters for nickname, and modify the nickname if
- it includes those. */
- if (silc_server_name_bad_chars(username, username_len)) {
- nickname = silc_server_name_modify_bad(username, username_len);
- } else {
+ /* Take nickname from NEW_CLIENT packet, if present */
+ if (silc_buffer_unformat(buffer,
+ SILC_STR_UI16_NSTRING_ALLOC(&nickname,
+ &nickname_len),
+ SILC_STR_END) >= 0) {
+ if (nickname_len > 128) {
+ nickname_len = 128;
+ nickname[nickname_len - 1] = '\0';
+ }
+ }
+
+ /* Nickname is initially same as username, if not present in NEW_CLIENT */
+ if (!nickname) {
nickname = strdup(username);
+ nickname_len = strlen(nickname);
+ }
+
+ /* Check for valid username string */
+ nicknamec = silc_identifier_check(nickname, nickname_len,
+ SILC_STRING_UTF8, 128, &tmp_len);
+ if (!nicknamec) {
+ silc_free(username);
+ silc_free(realname);
+ silc_free(nickname);
+ SILC_LOG_ERROR(("Client %s (%s) sent bad username string '%s', closing "
+ "connection", hostname, ip, username));
+ silc_server_disconnect_remote(server, sock,
+ SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
+ NULL);
+ silc_server_free_sock_user_data(server, sock, NULL);
+ silc_packet_free(packet);
+ return NULL;
}
/* Make sanity checks for the hostname of the client. If the hostname
the client's public key. If the hostname is not present then put
it from the resolved name or from the public key. */
if (strchr(username, '@')) {
- SilcPublicKeyIdentifier pident;
+ SilcSILCPublicKey silc_pubkey;
int tlen = strcspn(username, "@");
char *phostname = NULL;
- hostname = silc_memdup(username + tlen + 1, strlen(username) - tlen - 1);
+ host = silc_memdup(username + tlen + 1, strlen(username) - tlen - 1);
- if (strcmp(sock->hostname, sock->ip) &&
- strcmp(sock->hostname, hostname)) {
+ if (strcmp(hostname, ip) && strcmp(hostname, host)) {
+ silc_free(nickname);
silc_free(username);
- silc_free(hostname);
+ silc_free(host);
silc_free(realname);
SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
- "connection", sock->hostname, sock->ip));
- silc_server_disconnect_remote(server, sock,
+ "connection", hostname, ip));
+ silc_server_disconnect_remote(server, sock,
SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
NULL);
+ silc_server_free_sock_user_data(server, sock, NULL);
+ silc_packet_free(packet);
return NULL;
}
-
- pident = silc_pkcs_decode_identifier(client->data.public_key->identifier);
- if (pident) {
- phostname = strdup(pident->host);
- silc_pkcs_free_identifier(pident);
- }
- if (!strcmp(sock->hostname, sock->ip) &&
- phostname && strcmp(phostname, hostname)) {
+ silc_pubkey = silc_pkcs_get_context(SILC_PKCS_SILC,
+ client->data.public_key);
+ phostname = strdup(silc_pubkey->identifier.host);
+ if (!strcmp(hostname, ip) && phostname && strcmp(phostname, host)) {
+ silc_free(nickname);
silc_free(username);
- silc_free(hostname);
+ silc_free(host);
silc_free(phostname);
silc_free(realname);
SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
- "connection", sock->hostname, sock->ip));
- silc_server_disconnect_remote(server, sock,
+ "connection", hostname, ip));
+ silc_server_disconnect_remote(server, sock,
SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
NULL);
+ silc_server_free_sock_user_data(server, sock, NULL);
+ silc_packet_free(packet);
return NULL;
}
-
+
silc_free(phostname);
} else {
/* The hostname is not present, add it. */
char *newusername;
- /* XXX For now we cannot take the host name from the public key since
- they are not trusted or we cannot verify them as trusted. Just take
- what the resolved name or address is. */
-#if 0
- if (strcmp(sock->hostname, sock->ip)) {
-#endif
- newusername = silc_calloc(strlen(username) +
- strlen(sock->hostname) + 2,
- sizeof(*newusername));
- strncat(newusername, username, strlen(username));
- strncat(newusername, "@", 1);
- strncat(newusername, sock->hostname, strlen(sock->hostname));
- silc_free(username);
- username = newusername;
-#if 0
- } else {
- SilcPublicKeyIdentifier pident =
- silc_pkcs_decode_identifier(client->data.public_key->identifier);
-
- if (pident) {
- newusername = silc_calloc(strlen(username) +
- strlen(pident->host) + 2,
- sizeof(*newusername));
- strncat(newusername, username, strlen(username));
- strncat(newusername, "@", 1);
- strncat(newusername, pident->host, strlen(pident->host));
- silc_free(username);
- username = newusername;
- silc_pkcs_free_identifier(pident);
- }
- }
-#endif
+ newusername = silc_calloc(strlen(username) + strlen(hostname) + 2,
+ sizeof(*newusername));
+ strncat(newusername, username, strlen(username));
+ strncat(newusername, "@", 1);
+ strncat(newusername, hostname, strlen(hostname));
+ silc_free(username);
+ username = newusername;
}
+ SILC_LOG_DEBUG(("%s %s", ip, hostname));
+
/* Create Client ID */
- while (!silc_id_create_client_id(server, server->id, server->rng,
- server->md5hash, nickname, &client_id)) {
- nickfail++;
- if (nickfail > 9) {
- silc_server_disconnect_remote(server, sock,
- SILC_STATUS_ERR_BAD_NICKNAME, NULL);
- return NULL;
+ if (!silc_id_create_client_id(server, server->id, server->rng,
+ server->md5hash, nicknamec,
+ strlen(nicknamec), &client_id)) {
+ silc_server_disconnect_remote(server, sock,
+ SILC_STATUS_ERR_BAD_NICKNAME, NULL);
+ silc_server_free_sock_user_data(server, sock, NULL);
+ silc_packet_free(packet);
+ return NULL;
+ }
+
+ /* If client marked as anonymous, scramble the username and hostname */
+ if (client->mode & SILC_UMODE_ANONYMOUS) {
+ char *scramble;
+
+ if (strlen(username) >= 2) {
+ username[0] = silc_rng_get_byte_fast(server->rng);
+ username[1] = silc_rng_get_byte_fast(server->rng);
}
- snprintf(&nickname[strlen(nickname) - 1], 1, "%d", nickfail);
+
+ scramble = silc_hash_babbleprint(server->sha1hash, username,
+ strlen(username));
+ scramble[5] = '@';
+ scramble[11] = '.';
+ memcpy(&scramble[16], ".silc", 5);
+ scramble[21] = '\0';
+ silc_free(username);
+ username = scramble;
}
/* Update client entry */
idata->status |= SILC_IDLIST_STATUS_REGISTERED;
client->nickname = nickname;
client->username = username;
- client->userinfo = realname ? realname : strdup(" ");
+ client->userinfo = realname ? realname : strdup(username);
client->id = client_id;
id_len = silc_id_get_len(client_id, SILC_ID_CLIENT);
-
- /* Add the client again to the ID cache */
- silc_idcache_add(server->local_list->clients, client->nickname,
- client_id, client, 0, NULL);
+ silc_idcache_update_by_context(server->local_list->clients, client,
+ client_id, nicknamec, TRUE);
/* Notify our router about new client on the SILC network */
- if (!server->standalone)
- silc_server_send_new_id(server, (SilcSocketConnection)
- server->router->connection,
- server->server_type == SILC_ROUTER ? TRUE : FALSE,
- client->id, SILC_ID_CLIENT, id_len);
-
+ silc_server_send_new_id(server, SILC_PRIMARY_ROUTE(server),
+ SILC_BROADCAST(server), client->id,
+ SILC_ID_CLIENT, id_len);
+
+ /* Distribute to backup routers */
+ if (server->server_type == SILC_ROUTER) {
+ SilcBuffer idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
+ silc_server_backup_send(server, NULL, SILC_PACKET_NEW_ID, 0,
+ idp->data, silc_buffer_len(idp), FALSE, TRUE);
+ silc_buffer_free(idp);
+ }
+
/* Send the new client ID to the client. */
silc_server_send_new_id(server, sock, FALSE, client->id, SILC_ID_CLIENT,
silc_id_get_len(client->id, SILC_ID_CLIENT));
if (server->server_type == SILC_ROUTER)
silc_server_check_watcher_list(server, client, NULL, 0);
+ silc_packet_free(packet);
return client;
}
/* Create new server. This processes received New Server packet and
saves the received Server ID. The server is our locally connected
- server thus we save all the information and save it to local list.
+ server thus we save all the information and save it to local list.
This funtion can be used by both normal server and router server.
If normal server uses this it means that its router has connected
to the server. If router uses this it means that one of the cell's
servers is connected to the router. */
SilcServerEntry silc_server_new_server(SilcServer server,
- SilcSocketConnection sock,
- SilcPacketContext *packet)
+ SilcPacketStream sock,
+ SilcPacket packet)
{
- SilcBuffer buffer = packet->buffer;
+ SilcBuffer buffer = &packet->buffer;
+ SilcIDListData idata = silc_packet_get_context(sock);
SilcServerEntry new_server, server_entry;
- SilcServerID *server_id;
- SilcIDListData idata;
- unsigned char *server_name, *id_string;
+ SilcServerID server_id;
+ unsigned char *server_name, *server_namec, *id_string;
SilcUInt16 id_len, name_len;
int ret;
- bool local = TRUE;
+ SilcBool local = TRUE;
+ const char *hostname, *ip;
SILC_LOG_DEBUG(("Creating new server"));
- if (sock->type != SILC_SOCKET_TYPE_SERVER &&
- sock->type != SILC_SOCKET_TYPE_ROUTER)
+ if (idata->conn_type != SILC_CONN_SERVER &&
+ idata->conn_type != SILC_CONN_ROUTER) {
+ silc_packet_free(packet);
return NULL;
+ }
/* Take server entry */
- new_server = (SilcServerEntry)sock->user_data;
- idata = (SilcIDListData)new_server;
+ new_server = (SilcServerEntry)idata;
+ silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
+ NULL, &hostname, &ip, NULL);
+
+ /* Statistics */
+ if (server->server_type == SILC_ROUTER)
+ server->stat.cell_servers++;
/* Remove the old cache entry */
- if (!silc_idcache_del_by_context(server->local_list->servers, new_server)) {
- if (!silc_idcache_del_by_context(server->global_list->servers,
- new_server)) {
+ if (!silc_idcache_del_by_context(server->local_list->servers, new_server,
+ NULL)) {
+ if (!silc_idcache_del_by_context(server->global_list->servers,
+ new_server, NULL)) {
SILC_LOG_INFO(("Unauthenticated %s attempted to register to "
- "network", (sock->type == SILC_SOCKET_TYPE_SERVER ?
+ "network", (idata->conn_type == SILC_CONN_SERVER ?
"server" : "router")));
- silc_server_disconnect_remote(server, sock,
+ silc_server_disconnect_remote(server, sock,
SILC_STATUS_ERR_NOT_AUTHENTICATED, NULL);
+ silc_server_free_sock_user_data(server, sock, NULL);
return NULL;
}
local = FALSE;
}
+ /* Make sure this server hasn't registered already */
+ if (idata->status & SILC_IDLIST_STATUS_REGISTERED) {
+ silc_server_disconnect_remote(server, sock,
+ SILC_STATUS_ERR_OPERATION_ALLOWED,
+ "Too many registrations");
+ silc_server_free_sock_user_data(server, sock, NULL);
+ return NULL;
+ }
+
/* Parse the incoming packet */
ret = silc_buffer_unformat(buffer,
SILC_STR_UI16_NSTRING_ALLOC(&id_string, &id_len),
- SILC_STR_UI16_NSTRING_ALLOC(&server_name,
+ SILC_STR_UI16_NSTRING_ALLOC(&server_name,
&name_len),
SILC_STR_END);
if (ret == -1) {
- if (id_string)
- silc_free(id_string);
- if (server_name)
- silc_free(server_name);
+ silc_free(id_string);
+ silc_free(server_name);
+ silc_server_disconnect_remote(server, sock,
+ SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
+ NULL);
+ silc_server_free_sock_user_data(server, sock, NULL);
return NULL;
}
- if (id_len > buffer->len) {
+ if (id_len > silc_buffer_len(buffer)) {
silc_free(id_string);
silc_free(server_name);
+ silc_server_disconnect_remote(server, sock,
+ SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
+ NULL);
+ silc_server_free_sock_user_data(server, sock, NULL);
return NULL;
}
- if (name_len > 256)
- server_name[255] = '\0';
+ if (name_len > 256) {
+ server_name[256] = '\0';
+ name_len = 256;
+ }
/* Get Server ID */
- server_id = silc_id_str2id(id_string, id_len, SILC_ID_SERVER);
- if (!server_id) {
+ if (!silc_id_str2id(id_string, id_len, SILC_ID_SERVER, &server_id,
+ sizeof(server_id))) {
silc_free(id_string);
silc_free(server_name);
+ silc_server_disconnect_remote(server, sock,
+ SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
+ NULL);
+ silc_server_free_sock_user_data(server, sock, NULL);
return NULL;
}
silc_free(id_string);
/* Check for valid server ID */
- if (!silc_id_is_valid_server_id(server, server_id, sock)) {
+ if (!silc_id_is_valid_server_id(server, &server_id, sock)) {
SILC_LOG_INFO(("Invalid server ID sent by %s (%s)",
- sock->ip, sock->hostname));
- silc_server_disconnect_remote(server, sock,
+ ip, hostname));
+ silc_server_disconnect_remote(server, sock,
SILC_STATUS_ERR_BAD_SERVER_ID, NULL);
+ silc_server_free_sock_user_data(server, sock, NULL);
silc_free(server_name);
return NULL;
}
/* Check that we do not have this ID already */
- server_entry = silc_idlist_find_server_by_id(server->local_list,
- server_id, TRUE, NULL);
+ server_entry = silc_idlist_find_server_by_id(server->local_list,
+ &server_id, TRUE, NULL);
if (server_entry) {
- silc_idcache_del_by_context(server->local_list->servers, server_entry);
+ if (SILC_IS_LOCAL(server_entry)) {
+ SILC_LOG_ERROR(("Too many registrations from %s (%s)",
+ ip, hostname));
+ silc_server_disconnect_remote(server, sock,
+ SILC_STATUS_ERR_OPERATION_ALLOWED,
+ "Too many registrations");
+ silc_server_free_sock_user_data(server, sock, NULL);
+ return NULL;
+ } else {
+ silc_idcache_del_by_context(server->local_list->servers, server_entry,
+ NULL);
+ }
} else {
- server_entry = silc_idlist_find_server_by_id(server->global_list,
- server_id, TRUE, NULL);
- if (server_entry)
- silc_idcache_del_by_context(server->global_list->servers, server_entry);
+ server_entry = silc_idlist_find_server_by_id(server->global_list,
+ &server_id, TRUE, NULL);
+ if (server_entry) {
+ if (SILC_IS_LOCAL(server_entry)) {
+ SILC_LOG_ERROR(("Too many registrations from %s (%s)",
+ ip, hostname));
+ silc_server_disconnect_remote(server, sock,
+ SILC_STATUS_ERR_OPERATION_ALLOWED,
+ "Too many registrations");
+ silc_server_free_sock_user_data(server, sock, NULL);
+ return NULL;
+ } else {
+ silc_idcache_del_by_context(server->global_list->servers,
+ server_entry, NULL);
+ }
+ }
+ }
+
+ /* Check server name */
+ server_namec = silc_identifier_check(server_name, strlen(server_name),
+ SILC_STRING_UTF8, 256, NULL);
+ if (!server_namec) {
+ SILC_LOG_ERROR(("Malformed server name from %s (%s)",
+ ip, hostname));
+ silc_server_disconnect_remote(server, sock,
+ SILC_STATUS_ERR_OPERATION_ALLOWED,
+ "Malfromed server name");
+ silc_server_free_sock_user_data(server, sock, NULL);
+ return NULL;
}
/* Update server entry */
idata->status |= SILC_IDLIST_STATUS_REGISTERED;
new_server->server_name = server_name;
- new_server->id = server_id;
-
+ new_server->id = silc_id_dup(&server_id, SILC_ID_SERVER);
+
SILC_LOG_DEBUG(("New server id(%s)",
- silc_id_render(server_id, SILC_ID_SERVER)));
+ silc_id_render(&server_id, SILC_ID_SERVER)));
/* Add again the entry to the ID cache. */
- silc_idcache_add(local ? server->local_list->servers :
- server->global_list->servers, server_name, server_id,
- new_server, 0, NULL);
+ silc_idcache_add(local ? server->local_list->servers :
+ server->global_list->servers, server_namec,
+ new_server->id, new_server);
/* Distribute the information about new server in the SILC network
to our router. If we are normal server we won't send anything
since this connection must be our router connection. */
if (server->server_type == SILC_ROUTER && !server->standalone &&
- server->router->connection != sock)
- silc_server_send_new_id(server, server->router->connection,
- TRUE, new_server->id, SILC_ID_SERVER,
- silc_id_get_len(server_id, SILC_ID_SERVER));
-
- if (server->server_type == SILC_ROUTER)
- server->stat.cell_servers++;
+ SILC_PRIMARY_ROUTE(server) != sock)
+ silc_server_send_new_id(server, SILC_PRIMARY_ROUTE(server),
+ TRUE, new_server->id, SILC_ID_SERVER,
+ silc_id_get_len(&server_id, SILC_ID_SERVER));
+
+ if (server->server_type == SILC_ROUTER) {
+ /* Distribute to backup routers */
+ SilcBuffer idp = silc_id_payload_encode(new_server->id, SILC_ID_SERVER);
+ silc_server_backup_send(server, NULL, SILC_PACKET_NEW_ID, 0, idp->data,
+ silc_buffer_len(idp), FALSE, TRUE);
+ silc_buffer_free(idp);
+ }
/* Check whether this router connection has been replaced by an
backup router. If it has been then we'll disable the server and will
ignore everything it will send until the backup router resuming
protocol has been completed. */
- if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
- silc_server_backup_replaced_get(server, server_id, NULL)) {
- /* Send packet to the server indicating that it cannot use this
+ if (idata->conn_type == SILC_CONN_ROUTER &&
+ silc_server_backup_replaced_get(server, &server_id, NULL)) {
+ /* Send packet to the router indicating that it cannot use this
connection as it has been replaced by backup router. */
- SilcBuffer packet = silc_buffer_alloc(2);
- silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
- silc_buffer_format(packet,
- SILC_STR_UI_CHAR(SILC_SERVER_BACKUP_REPLACED),
- SILC_STR_UI_CHAR(0),
- SILC_STR_END);
- silc_server_packet_send(server, sock,
- SILC_PACKET_RESUME_ROUTER, 0,
- packet->data, packet->len, TRUE);
- silc_buffer_free(packet);
+ SILC_LOG_DEBUG(("Remote router has been replaced by backup router, "
+ "disabling its connection"));
+
+ silc_server_backup_send_replaced(server, sock);
/* Mark the router disabled. The data sent earlier will go but nothing
- after this does not go to this connection. */
+ after this goes to this connection. */
idata->status |= SILC_IDLIST_STATUS_DISABLED;
} else {
/* If it is router announce our stuff to it. */
- if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
+ if (idata->conn_type == SILC_CONN_ROUTER &&
server->server_type == SILC_ROUTER) {
silc_server_announce_servers(server, FALSE, 0, sock);
silc_server_announce_clients(server, 0, sock);
silc_server_announce_channels(server, 0, sock);
}
+
+ /* Announce our information to backup router */
+ if (new_server->server_type == SILC_BACKUP_ROUTER &&
+ idata->conn_type == SILC_CONN_SERVER &&
+ server->server_type == SILC_ROUTER) {
+ silc_server_announce_servers(server, TRUE, 0, sock);
+ silc_server_announce_clients(server, 0, sock);
+ silc_server_announce_channels(server, 0, sock);
+ }
+
+ /* If backup router, mark it as one of ours. This server is considered
+ to be backup router after this setting. */
+ if (new_server->server_type == SILC_BACKUP_ROUTER) {
+ SilcServerConfigRouter *backup;
+ backup = silc_server_config_find_backup_conn(server, (char *)ip);
+ if (!backup)
+ backup = silc_server_config_find_backup_conn(server, (char *)hostname);
+ if (backup) {
+ /* Add as our backup router */
+ silc_server_backup_add(server, new_server, backup->backup_replace_ip,
+ backup->backup_replace_port,
+ backup->backup_local);
+ }
+ }
+
+ /* By default the servers connected to backup router are disabled
+ until backup router has become the primary */
+ if (server->server_type == SILC_BACKUP_ROUTER &&
+ idata->conn_type == SILC_CONN_SERVER)
+ idata->status |= SILC_IDLIST_STATUS_DISABLED;
}
return new_server;
/* Processes incoming New ID packet. New ID Payload is used to distribute
information about newly registered clients and servers. */
-static void silc_server_new_id_real(SilcServer server,
- SilcSocketConnection sock,
- SilcPacketContext *packet,
- int broadcast)
+static void silc_server_new_id_real(SilcServer server,
+ SilcPacketStream sock,
+ SilcPacket packet,
+ SilcBuffer buffer,
+ SilcBool broadcast)
{
- SilcBuffer buffer = packet->buffer;
+ SilcIDListData idata = silc_packet_get_context(sock);
SilcIDList id_list;
SilcServerEntry router, server_entry;
- SilcSocketConnection router_sock;
+ SilcPacketStream router_sock;
SilcIDPayload idp;
SilcIdType id_type;
- void *id;
+ SilcServerID sender_id;
+ const char *hostname, *ip;
SILC_LOG_DEBUG(("Processing new ID"));
- if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
+ if (idata->conn_type == SILC_CONN_CLIENT ||
server->server_type == SILC_SERVER ||
packet->src_id_type != SILC_ID_SERVER)
return;
- idp = silc_id_payload_parse(buffer->data, buffer->len);
+ idp = silc_id_payload_parse(buffer->data, silc_buffer_len(buffer));
if (!idp)
return;
id_type = silc_id_payload_get_type(idp);
+ silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
+ NULL, &hostname, &ip, NULL);
+
/* Normal server cannot have other normal server connections */
- server_entry = (SilcServerEntry)sock->user_data;
- if (id_type == SILC_ID_SERVER && sock->type == SILC_SOCKET_TYPE_SERVER &&
+ server_entry = (SilcServerEntry)idata;
+ if (id_type == SILC_ID_SERVER && idata->conn_type == SILC_CONN_SERVER &&
server_entry->server_type == SILC_SERVER)
goto out;
- id = silc_id_payload_get_id(idp);
- if (!id)
- goto out;
-
/* If the packet is coming from server then use the sender as the
origin of the the packet. If it came from router then check the real
sender of the packet and use that as the origin. */
- if (sock->type == SILC_SOCKET_TYPE_SERVER) {
+ if (idata->conn_type == SILC_CONN_SERVER) {
id_list = server->local_list;
router_sock = sock;
- router = sock->user_data;
+ router = server_entry;
/* If the sender is backup router and ID is server (and we are not
backup router) then switch the entry to global list. */
- if (server_entry->server_type == SILC_BACKUP_ROUTER &&
- id_type == SILC_ID_SERVER &&
+ if (server_entry->server_type == SILC_BACKUP_ROUTER &&
+ id_type == SILC_ID_SERVER &&
server->id_entry->server_type != SILC_BACKUP_ROUTER) {
id_list = server->global_list;
- router_sock = server->router ? server->router->connection : sock;
+ router_sock = server->router ? SILC_PRIMARY_ROUTE(server) : sock;
}
} else {
- void *sender_id = silc_id_str2id(packet->src_id, packet->src_id_len,
- packet->src_id_type);
+ silc_id_str2id(packet->src_id, packet->src_id_len,
+ packet->src_id_type, &sender_id, sizeof(sender_id));
router = silc_idlist_find_server_by_id(server->global_list,
- sender_id, TRUE, NULL);
+ &sender_id, TRUE, NULL);
if (!router)
router = silc_idlist_find_server_by_id(server->local_list,
- sender_id, TRUE, NULL);
- silc_free(sender_id);
+ &sender_id, TRUE, NULL);
router_sock = sock;
id_list = server->global_list;
}
case SILC_ID_CLIENT:
{
SilcClientEntry entry;
+ SilcClientID id;
+
+ if (!silc_id_payload_get_id(idp, &id, sizeof(id)))
+ goto out;
/* Check that we do not have this client already */
- entry = silc_idlist_find_client_by_id(server->global_list,
- id, server->server_type,
+ entry = silc_idlist_find_client_by_id(server->global_list,
+ &id, server->server_type,
NULL);
if (!entry)
- entry = silc_idlist_find_client_by_id(server->local_list,
- id, server->server_type,
+ entry = silc_idlist_find_client_by_id(server->local_list,
+ &id, server->server_type,
NULL);
if (entry) {
SILC_LOG_DEBUG(("Ignoring client that we already have"));
}
SILC_LOG_DEBUG(("New client id(%s) from [%s] %s",
- silc_id_render(id, SILC_ID_CLIENT),
- sock->type == SILC_SOCKET_TYPE_SERVER ?
- "Server" : "Router", sock->hostname));
-
+ silc_id_render(&id, SILC_ID_CLIENT),
+ idata->conn_type == SILC_CONN_SERVER ?
+ "Server" : "Router", hostname));
+
/* As a router we keep information of all global information in our
global list. Cell wide information however is kept in the local
list. */
- entry = silc_idlist_add_client(id_list, NULL, NULL, NULL,
- id, router, NULL, 0);
+ entry = silc_idlist_add_client(id_list, NULL, NULL, NULL,
+ silc_id_dup(&id, SILC_ID_CLIENT),
+ router, NULL);
if (!entry) {
SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
/* Inform the sender that the ID is not usable */
- silc_server_send_notify_signoff(server, sock, FALSE, id, NULL);
+ silc_server_send_notify_signoff(server, sock, FALSE, &id, NULL);
goto out;
}
entry->nickname = NULL;
entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
- if (sock->type == SILC_SOCKET_TYPE_SERVER)
+ if (idata->conn_type == SILC_CONN_SERVER)
server->stat.cell_clients++;
server->stat.clients++;
/* Check if anyone is watching this nickname */
if (server->server_type == SILC_ROUTER && id_list == server->local_list)
silc_server_check_watcher_list(server, entry, NULL, 0);
+
+ if (server->server_type == SILC_ROUTER) {
+ /* Add the client's public key to repository or get the key with
+ GETKEY command. */
+ if (entry->data.public_key) {
+ if (!silc_server_get_public_key_by_client(server, entry, NULL))
+ silc_skr_add_public_key_simple(server->repository,
+ entry->data.public_key,
+ SILC_SKR_USAGE_IDENTIFICATION,
+ entry, NULL);
+ } else {
+ silc_server_send_command(server, router_sock,
+ SILC_COMMAND_GETKEY, ++server->cmd_ident,
+ 1, 1, buffer->data,
+ silc_buffer_len(buffer));
+ }
+ }
}
break;
case SILC_ID_SERVER:
{
SilcServerEntry entry;
+ SilcServerID id;
+
+ if (!silc_id_payload_get_id(idp, &id, sizeof(id)))
+ goto out;
/* If the ID is mine, ignore it. */
- if (SILC_ID_SERVER_COMPARE(id, server->id)) {
+ if (SILC_ID_SERVER_COMPARE(&id, server->id)) {
SILC_LOG_DEBUG(("Ignoring my own ID as new ID"));
break;
}
/* If the ID is the sender's ID, ignore it (we have it already) */
- if (SILC_ID_SERVER_COMPARE(id, router->id)) {
+ if (SILC_ID_SERVER_COMPARE(&id, router->id)) {
SILC_LOG_DEBUG(("Ignoring sender's own ID"));
break;
}
-
+
/* Check that we do not have this server already */
- entry = silc_idlist_find_server_by_id(server->global_list,
- id, server->server_type,
+ entry = silc_idlist_find_server_by_id(server->global_list,
+ &id, server->server_type,
NULL);
if (!entry)
- entry = silc_idlist_find_server_by_id(server->local_list,
- id, server->server_type,
+ entry = silc_idlist_find_server_by_id(server->local_list,
+ &id, server->server_type,
NULL);
if (entry) {
SILC_LOG_DEBUG(("Ignoring server that we already have"));
}
SILC_LOG_DEBUG(("New server id(%s) from [%s] %s",
- silc_id_render(id, SILC_ID_SERVER),
- sock->type == SILC_SOCKET_TYPE_SERVER ?
- "Server" : "Router", sock->hostname));
-
- /* As a router we keep information of all global information in our
+ silc_id_render(&id, SILC_ID_SERVER),
+ idata->conn_type == SILC_CONN_SERVER ?
+ "Server" : "Router", hostname));
+
+ /* As a router we keep information of all global information in our
global list. Cell wide information however is kept in the local
list. */
- entry = silc_idlist_add_server(id_list, NULL, 0, id, router,
+ entry = silc_idlist_add_server(id_list, NULL, 0,
+ silc_id_dup(&id, SILC_ID_SERVER), router,
router_sock);
if (!entry) {
SILC_LOG_ERROR(("Could not add new server to the ID Cache"));
goto out;
}
entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
-
- if (sock->type == SILC_SOCKET_TYPE_SERVER)
+
+ if (idata->conn_type == SILC_CONN_SERVER)
server->stat.cell_servers++;
server->stat.servers++;
}
/* If the sender of this packet is server and we are router we need to
broadcast this packet to other routers in the network. */
- if (broadcast && !server->standalone && server->server_type == SILC_ROUTER &&
- sock->type == SILC_SOCKET_TYPE_SERVER &&
+ if (broadcast && server->server_type == SILC_ROUTER &&
+ idata->conn_type == SILC_CONN_SERVER &&
!(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
SILC_LOG_DEBUG(("Broadcasting received New ID packet"));
- silc_server_packet_send(server, server->router->connection,
- packet->type,
+ silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
+ packet->type,
packet->flags | SILC_PACKET_FLAG_BROADCAST,
- buffer->data, buffer->len, FALSE);
- silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
+ buffer->data, silc_buffer_len(buffer));
+ silc_server_backup_send(server, (SilcServerEntry)idata,
packet->type, packet->flags,
- packet->buffer->data, packet->buffer->len,
+ packet->buffer.data,
+ silc_buffer_len(&packet->buffer),
FALSE, TRUE);
}
/* Processes incoming New ID packet. New ID Payload is used to distribute
information about newly registered clients and servers. */
-void silc_server_new_id(SilcServer server, SilcSocketConnection sock,
- SilcPacketContext *packet)
+void silc_server_new_id(SilcServer server, SilcPacketStream sock,
+ SilcPacket packet)
{
- silc_server_new_id_real(server, sock, packet, TRUE);
+ silc_server_new_id_real(server, sock, packet, &packet->buffer, TRUE);
+ silc_packet_free(packet);
}
/* Receoved New Id List packet, list of New ID payloads inside one
packet. Process the New ID payloads one by one. */
-void silc_server_new_id_list(SilcServer server, SilcSocketConnection sock,
- SilcPacketContext *packet)
+void silc_server_new_id_list(SilcServer server, SilcPacketStream sock,
+ SilcPacket packet)
{
- SilcPacketContext *new_id;
+ SilcIDListData idata = silc_packet_get_context(sock);
SilcBuffer idp;
SilcUInt16 id_len;
SILC_LOG_DEBUG(("Processing New ID List"));
- if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
- packet->src_id_type != SILC_ID_SERVER)
+ if (idata->conn_type == SILC_CONN_CLIENT ||
+ packet->src_id_type != SILC_ID_SERVER) {
+ silc_packet_free(packet);
return;
+ }
/* If the sender of this packet is server and we are router we need to
broadcast this packet to other routers in the network. Broadcast
this list packet instead of multiple New ID packets. */
- if (!server->standalone && server->server_type == SILC_ROUTER &&
- sock->type == SILC_SOCKET_TYPE_SERVER &&
+ if (server->server_type == SILC_ROUTER &&
+ idata->conn_type == SILC_CONN_SERVER &&
!(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
SILC_LOG_DEBUG(("Broadcasting received New ID List packet"));
- silc_server_packet_send(server, server->router->connection,
- packet->type,
+ silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
+ packet->type,
packet->flags | SILC_PACKET_FLAG_BROADCAST,
- packet->buffer->data, packet->buffer->len, FALSE);
- silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
+ packet->buffer.data,
+ silc_buffer_len(&packet->buffer));
+ silc_server_backup_send(server, (SilcServerEntry)idata,
packet->type, packet->flags,
- packet->buffer->data, packet->buffer->len,
+ packet->buffer.data,
+ silc_buffer_len(&packet->buffer),
FALSE, TRUE);
}
- /* Make copy of the original packet context, except for the actual
- data buffer, which we will here now fetch from the original buffer. */
- new_id = silc_packet_context_alloc();
- new_id->type = SILC_PACKET_NEW_ID;
- new_id->flags = packet->flags;
- new_id->src_id = packet->src_id;
- new_id->src_id_len = packet->src_id_len;
- new_id->src_id_type = packet->src_id_type;
- new_id->dst_id = packet->dst_id;
- new_id->dst_id_len = packet->dst_id_len;
- new_id->dst_id_type = packet->dst_id_type;
-
idp = silc_buffer_alloc(256);
- new_id->buffer = idp;
+ if (!idp) {
+ silc_packet_free(packet);
+ return;
+ }
- while (packet->buffer->len) {
- SILC_GET16_MSB(id_len, packet->buffer->data + 2);
- if ((id_len > packet->buffer->len) ||
- (id_len > idp->truelen))
+ while (silc_buffer_len(&packet->buffer)) {
+ SILC_GET16_MSB(id_len, packet->buffer.data + 2);
+ if ((id_len > silc_buffer_len(&packet->buffer)) ||
+ (id_len > silc_buffer_truelen(idp)))
break;
silc_buffer_pull_tail(idp, 4 + id_len);
- silc_buffer_put(idp, packet->buffer->data, 4 + id_len);
+ silc_buffer_put(idp, packet->buffer.data, 4 + id_len);
/* Process the New ID */
- silc_server_new_id_real(server, sock, new_id, FALSE);
+ silc_server_new_id_real(server, sock, packet, idp, FALSE);
silc_buffer_push_tail(idp, 4 + id_len);
- silc_buffer_pull(packet->buffer, 4 + id_len);
+ silc_buffer_pull(&packet->buffer, 4 + id_len);
}
silc_buffer_free(idp);
- silc_free(new_id);
+ silc_packet_free(packet);
}
-/* Received New Channel packet. Information about new channels in the
+/* Received New Channel packet. Information about new channels in the
network are distributed using this packet. Save the information about
the new channel. This usually comes from router but also normal server
can send this to notify channels it has when it connects to us. */
-void silc_server_new_channel(SilcServer server,
- SilcSocketConnection sock,
- SilcPacketContext *packet)
+static void silc_server_new_channel_process(SilcServer server,
+ SilcPacketStream sock,
+ SilcPacket packet,
+ SilcBuffer buffer)
{
+ SilcIDListData idata = silc_packet_get_context(sock);
SilcChannelPayload payload;
- SilcChannelID *channel_id;
- char *channel_name;
+ SilcChannelID channel_id;
+ char *channel_name, *channel_namec = NULL;
SilcUInt32 name_len;
- unsigned char *id;
- SilcUInt32 id_len;
- SilcUInt32 mode;
+ unsigned char *id, cid[32];
+ SilcUInt32 id_len, cipher_len;
SilcServerEntry server_entry;
SilcChannelEntry channel;
+ const char *cipher;
- SILC_LOG_DEBUG(("Processing New Channel"));
-
- if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
+ if (idata->conn_type == SILC_CONN_CLIENT ||
packet->src_id_type != SILC_ID_SERVER ||
server->server_type == SILC_SERVER)
return;
/* Parse the channel payload */
- payload = silc_channel_payload_parse(packet->buffer->data,
- packet->buffer->len);
+ payload = silc_channel_payload_parse(buffer->data, silc_buffer_len(buffer));
if (!payload)
return;
-
+
/* Get the channel ID */
- channel_id = silc_channel_get_id_parse(payload);
- if (!channel_id) {
+ if (!silc_channel_get_id_parse(payload, &channel_id)) {
silc_channel_payload_free(payload);
return;
}
channel_name = silc_channel_get_name(payload, &name_len);
- if (name_len > 256)
- channel_name[255] = '\0';
+ if (name_len > 256) {
+ channel_name[256] = '\0';
+ name_len = 256;
+ }
+
+ /* Check channel name */
+ channel_namec = silc_channel_name_check(channel_name, strlen(channel_name),
+ SILC_STRING_UTF8, 256, NULL);
+ if (!channel_namec)
+ return;
id = silc_channel_get_id(payload, &id_len);
- server_entry = (SilcServerEntry)sock->user_data;
+ server_entry = (SilcServerEntry)idata;
- if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
- /* Add the channel to global list as it is coming from router. It
+ if (idata->conn_type == SILC_CONN_ROUTER) {
+ /* Add the channel to global list as it is coming from router. It
cannot be our own channel as it is coming from router. */
/* Check that we don't already have this channel */
- channel = silc_idlist_find_channel_by_name(server->local_list,
- channel_name, NULL);
+ channel = silc_idlist_find_channel_by_name(server->local_list,
+ channel_namec, NULL);
if (!channel)
- channel = silc_idlist_find_channel_by_name(server->global_list,
- channel_name, NULL);
+ channel = silc_idlist_find_channel_by_name(server->global_list,
+ channel_namec, NULL);
if (!channel) {
SILC_LOG_DEBUG(("New channel id(%s) from [Router] %s",
- silc_id_render(channel_id, SILC_ID_CHANNEL),
- sock->hostname));
-
- channel =
- silc_idlist_add_channel(server->global_list, strdup(channel_name),
- 0, channel_id, sock->user_data, NULL, NULL, 0);
- if (!channel)
+ silc_id_render(&channel_id, SILC_ID_CHANNEL),
+ idata->sconn->remote_host));
+
+ channel =
+ silc_idlist_add_channel(server->global_list, strdup(channel_name),
+ 0, silc_id_dup(&channel_id, SILC_ID_CHANNEL),
+ (SilcServerEntry)idata, NULL, NULL, NULL);
+ if (!channel) {
+ silc_channel_payload_free(payload);
return;
+ }
+ channel->disabled = TRUE; /* Disabled until someone JOINs */
server->stat.channels++;
if (server->server_type == SILC_ROUTER)
SilcBuffer chk;
SILC_LOG_DEBUG(("Channel id(%s) from [Server] %s",
- silc_id_render(channel_id, SILC_ID_CHANNEL),
- sock->hostname));
+ silc_id_render(&channel_id, SILC_ID_CHANNEL),
+ idata->sconn->remote_host));
/* Check that we don't already have this channel */
- channel = silc_idlist_find_channel_by_name(server->local_list,
- channel_name, NULL);
+ channel = silc_idlist_find_channel_by_name(server->local_list,
+ channel_namec, NULL);
if (!channel)
- channel = silc_idlist_find_channel_by_name(server->global_list,
- channel_name, NULL);
+ channel = silc_idlist_find_channel_by_name(server->global_list,
+ channel_namec, NULL);
/* If the channel does not exist, then create it. This creates a new
key to the channel as well that we will send to the server. */
if (!channel) {
+ SILC_LOG_DEBUG(("Channel is new to us"));
+
/* The protocol says that the Channel ID's IP address must be based
on the router's IP address. Check whether the ID is based in our
IP and if it is not then create a new ID and enforce the server
to switch the ID. */
if (server_entry->server_type != SILC_BACKUP_ROUTER &&
- !SILC_ID_COMPARE(channel_id, server->id, server->id->ip.data_len)) {
+ !SILC_ID_COMPARE(&channel_id, server->id, server->id->ip.data_len)) {
SilcChannelID *tmp;
SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
-
if (silc_id_create_channel_id(server, server->id, server->rng, &tmp)) {
- silc_server_send_notify_channel_change(server, sock, FALSE,
- channel_id, tmp);
- silc_free(channel_id);
- channel_id = tmp;
+ silc_server_send_notify_channel_change(server, sock, FALSE,
+ &channel_id, tmp);
+ silc_channel_payload_free(payload);
+ silc_free(tmp);
}
+
+ /* Wait that server re-announces this channel */
+ return;
}
/* Create the channel with the provided Channel ID */
- channel = silc_server_create_new_channel_with_id(server, NULL, NULL,
- channel_name,
- channel_id, FALSE);
+ channel =
+ silc_server_create_new_channel_with_id(
+ server, NULL, NULL,
+ channel_name,
+ silc_id_dup(&channel_id, SILC_ID_CHANNEL),
+ FALSE);
if (!channel) {
silc_channel_payload_free(payload);
- silc_free(channel_id);
return;
}
+ channel->disabled = TRUE; /* Disabled until someone JOINs */
+
+#if 0 /* We assume that CMODE_CHANGE notify is sent to us after this. */
- /* Get the mode and set it to the channel */
- channel->mode = silc_channel_get_mode(payload);
+ /* XXX Dunno if this is supposed to be set in any server type. If set
+ here the CMODE_CHANGE that may follow sets mode that we already
+ have, and we may loose data from the CMODE_CHANGE notify. */
+ if (server_entry->server_type != SILC_BACKUP_ROUTER)
+ channel->mode = silc_channel_get_mode(payload);
+#endif
/* Send the new channel key to the server */
- id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
- id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
- chk = silc_channel_key_payload_encode(id_len, id,
- strlen(channel->channel_key->
- cipher->name),
- channel->channel_key->cipher->name,
- channel->key_len / 8,
+ silc_id_id2str(channel->id, SILC_ID_CHANNEL, cid, sizeof(cid),
+ &id_len);
+ cipher = silc_cipher_get_name(channel->send_key);
+ cipher_len = strlen(cipher);
+ chk = silc_channel_key_payload_encode(id_len, cid,
+ cipher_len, cipher,
+ channel->key_len / 8,
channel->key);
- silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
- chk->data, chk->len, FALSE);
+ silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
+ chk->data, silc_buffer_len(chk));
silc_buffer_free(chk);
-
} else {
/* The channel exist by that name, check whether the ID's match.
If they don't then we'll force the server to use the ID we have.
We also create a new key for the channel. */
- SilcBuffer users = NULL, users_modes = NULL;
+ SilcBuffer modes = NULL, users = NULL, users_modes = NULL;
- if (!SILC_ID_CHANNEL_COMPARE(channel_id, channel->id)) {
+ SILC_LOG_DEBUG(("Channel already exists"));
+
+ if (!SILC_ID_CHANNEL_COMPARE(&channel_id, channel->id)) {
/* They don't match, send CHANNEL_CHANGE notify to the server to
force the ID change. */
SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
- silc_server_send_notify_channel_change(server, sock, FALSE,
- channel_id, channel->id);
+ silc_server_send_notify_channel_change(server, sock, FALSE,
+ &channel_id, channel->id);
+ silc_channel_payload_free(payload);
+
+ /* Wait that server re-announces this channel */
+ return;
}
+#if 0 /* We will announce our CMODE anyway for this channel, so no need
+ to check it (implicit enforce). */
+
/* If the mode is different from what we have then enforce the
mode change. */
mode = silc_channel_get_mode(payload);
SILC_LOG_DEBUG(("Forcing the server to change channel mode"));
silc_server_send_notify_cmode(server, sock, FALSE, channel,
channel->mode, server->id,
- SILC_ID_SERVER,
- channel->cipher, channel->hmac_name,
- channel->passphrase);
+ SILC_ID_SERVER, channel->cipher,
+ channel->hmac_name,
+ channel->passphrase,
+ channel->founder_key);
}
+#endif
/* Create new key for the channel and send it to the server and
everybody else possibly on the channel. */
-
if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
- if (!silc_server_create_channel_key(server, channel, 0))
- return;
-
- /* Send to the channel */
- silc_server_send_channel_key(server, sock, channel, FALSE);
- id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
- id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
+
+ if (silc_hash_table_count(channel->user_list)) {
+ if (!silc_server_create_channel_key(server, channel, 0)) {
+ silc_channel_payload_free(payload);
+ return;
+ }
+
+ /* Send to the channel */
+ silc_server_send_channel_key(server, sock, channel, FALSE);
+ }
/* Send to the server */
- chk = silc_channel_key_payload_encode(id_len, id,
- strlen(channel->channel_key->
- cipher->name),
- channel->channel_key->
- cipher->name,
- channel->key_len / 8,
+ silc_id_id2str(channel->id, SILC_ID_CHANNEL, cid, sizeof(cid),
+ &id_len);
+ cipher = silc_cipher_get_name(channel->send_key);
+ cipher_len = strlen(cipher);
+ chk = silc_channel_key_payload_encode(id_len, cid,
+ cipher_len, cipher,
+ channel->key_len / 8,
channel->key);
- silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
- chk->data, chk->len, FALSE);
+ silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
+ chk->data, silc_buffer_len(chk));
silc_buffer_free(chk);
- silc_free(id);
}
- silc_free(channel_id);
-
/* Since the channel is coming from server and we also know about it
then send the JOIN notify to the server so that it see's our
users on the channel "joining" the channel. */
- silc_server_announce_get_channel_users(server, channel, &users,
+ silc_server_announce_get_channel_users(server, channel, &modes, &users,
&users_modes);
if (users) {
silc_buffer_push(users, users->data - users->head);
silc_server_packet_send(server, sock,
SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
- users->data, users->len, FALSE);
+ users->data, silc_buffer_len(users));
silc_buffer_free(users);
}
+ if (modes) {
+ silc_buffer_push(modes, modes->data - modes->head);
+ silc_server_packet_send_dest(server, sock,
+ SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
+ channel->id, SILC_ID_CHANNEL,
+ modes->data, silc_buffer_len(modes));
+ silc_buffer_free(modes);
+ }
if (users_modes) {
silc_buffer_push(users_modes, users_modes->data - users_modes->head);
silc_server_packet_send_dest(server, sock,
SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
channel->id, SILC_ID_CHANNEL,
- users_modes->data,
- users_modes->len, FALSE);
+ users_modes->data,
+ silc_buffer_len(users_modes));
silc_buffer_free(users_modes);
}
+ if (channel->topic) {
+ silc_server_send_notify_topic_set(server, sock,
+ server->server_type == SILC_ROUTER ?
+ TRUE : FALSE, channel,
+ server->id, SILC_ID_SERVER,
+ channel->topic);
+ }
}
}
+ /* If the sender of this packet is server and we are router we need to
+ broadcast this packet to other routers in the network. Broadcast
+ this list packet instead of multiple New Channel packets. */
+ if (server->server_type == SILC_ROUTER &&
+ idata->conn_type == SILC_CONN_SERVER &&
+ !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
+ SILC_LOG_DEBUG(("Broadcasting received New Channel packet"));
+ silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
+ packet->type,
+ packet->flags | SILC_PACKET_FLAG_BROADCAST,
+ buffer->data, silc_buffer_len(buffer));
+ silc_server_backup_send(server, (SilcServerEntry)idata,
+ packet->type, packet->flags,
+ buffer->data, silc_buffer_len(buffer),
+ FALSE, TRUE);
+ }
+
+ silc_free(channel_namec);
silc_channel_payload_free(payload);
}
+/* Received New Channel packet. Information about new channels in the
+ network are distributed using this packet. Save the information about
+ the new channel. This usually comes from router but also normal server
+ can send this to notify channels it has when it connects to us. */
+
+void silc_server_new_channel(SilcServer server,
+ SilcPacketStream sock,
+ SilcPacket packet)
+{
+ silc_server_new_channel_process(server, sock, packet, &packet->buffer);
+ silc_packet_free(packet);
+}
+
/* Received New Channel List packet, list of New Channel List payloads inside
one packet. Process the New Channel payloads one by one. */
void silc_server_new_channel_list(SilcServer server,
- SilcSocketConnection sock,
- SilcPacketContext *packet)
+ SilcPacketStream sock,
+ SilcPacket packet)
{
- SilcPacketContext *new;
+ SilcIDListData idata = silc_packet_get_context(sock);
SilcBuffer buffer;
SilcUInt16 len1, len2;
SILC_LOG_DEBUG(("Processing New Channel List"));
- if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
+ if (idata->conn_type == SILC_CONN_CLIENT ||
packet->src_id_type != SILC_ID_SERVER ||
- server->server_type == SILC_SERVER)
+ server->server_type == SILC_SERVER) {
+ silc_packet_free(packet);
return;
-
- /* If the sender of this packet is server and we are router we need to
- broadcast this packet to other routers in the network. Broadcast
- this list packet instead of multiple New Channel packets. */
- if (!server->standalone && server->server_type == SILC_ROUTER &&
- sock->type == SILC_SOCKET_TYPE_SERVER &&
- !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
- SILC_LOG_DEBUG(("Broadcasting received New Channel List packet"));
- silc_server_packet_send(server, server->router->connection,
- packet->type,
- packet->flags | SILC_PACKET_FLAG_BROADCAST,
- packet->buffer->data, packet->buffer->len, FALSE);
- silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
- packet->type, packet->flags,
- packet->buffer->data, packet->buffer->len,
- FALSE, TRUE);
}
- /* Make copy of the original packet context, except for the actual
- data buffer, which we will here now fetch from the original buffer. */
- new = silc_packet_context_alloc();
- new->type = SILC_PACKET_NEW_CHANNEL;
- new->flags = packet->flags;
- new->src_id = packet->src_id;
- new->src_id_len = packet->src_id_len;
- new->src_id_type = packet->src_id_type;
- new->dst_id = packet->dst_id;
- new->dst_id_len = packet->dst_id_len;
- new->dst_id_type = packet->dst_id_type;
-
buffer = silc_buffer_alloc(512);
- new->buffer = buffer;
+ if (!buffer) {
+ silc_packet_free(packet);
+ return;
+ }
- while (packet->buffer->len) {
- SILC_GET16_MSB(len1, packet->buffer->data);
- if ((len1 > packet->buffer->len) ||
- (len1 > buffer->truelen))
+ while (silc_buffer_len(&packet->buffer)) {
+ SILC_GET16_MSB(len1, packet->buffer.data);
+ if ((len1 > silc_buffer_len(&packet->buffer)) ||
+ (len1 > silc_buffer_truelen(buffer)))
break;
- SILC_GET16_MSB(len2, packet->buffer->data + 2 + len1);
- if ((len2 > packet->buffer->len) ||
- (len2 > buffer->truelen))
+ SILC_GET16_MSB(len2, packet->buffer.data + 2 + len1);
+ if ((len2 > silc_buffer_len(&packet->buffer)) ||
+ (len2 > silc_buffer_truelen(buffer)))
break;
silc_buffer_pull_tail(buffer, 8 + len1 + len2);
- silc_buffer_put(buffer, packet->buffer->data, 8 + len1 + len2);
+ silc_buffer_put(buffer, packet->buffer.data, 8 + len1 + len2);
/* Process the New Channel */
- silc_server_new_channel(server, sock, new);
+ silc_server_new_channel_process(server, sock, packet, buffer);
silc_buffer_push_tail(buffer, 8 + len1 + len2);
- silc_buffer_pull(packet->buffer, 8 + len1 + len2);
+ silc_buffer_pull(&packet->buffer, 8 + len1 + len2);
}
silc_buffer_free(buffer);
- silc_free(new);
+ silc_packet_free(packet);
}
/* Received key agreement packet. This packet is never for us. It is to
one client to another. */
void silc_server_key_agreement(SilcServer server,
- SilcSocketConnection sock,
- SilcPacketContext *packet)
+ SilcPacketStream sock,
+ SilcPacket packet)
{
- SilcSocketConnection dst_sock;
+ SilcPacketStream dst_sock;
SilcIDListData idata;
SILC_LOG_DEBUG(("Start"));
if (packet->src_id_type != SILC_ID_CLIENT ||
- packet->dst_id_type != SILC_ID_CLIENT)
- return;
-
- if (!packet->dst_id)
+ packet->dst_id_type != SILC_ID_CLIENT || !packet->dst_id) {
+ silc_packet_free(packet);
return;
+ }
/* Get the route to the client */
dst_sock = silc_server_get_client_route(server, packet->dst_id,
- packet->dst_id_len, NULL,
+ packet->dst_id_len, NULL,
&idata, NULL);
- if (!dst_sock)
+ if (!dst_sock) {
+ silc_packet_free(packet);
return;
+ }
/* Relay the packet */
- silc_server_relay_packet(server, dst_sock, idata->send_key,
- idata->hmac_send, idata->psn_send++,
- packet, FALSE);
+ silc_server_packet_route(server, dst_sock, packet);
+ silc_packet_free(packet);
}
/* Received connection auth request packet that is used during connection
method to use. */
void silc_server_connection_auth_request(SilcServer server,
- SilcSocketConnection sock,
- SilcPacketContext *packet)
+ SilcPacketStream sock,
+ SilcPacket packet)
{
SilcServerConfigClient *client = NULL;
SilcUInt16 conn_type;
int ret;
SilcAuthMethod auth_meth = SILC_AUTH_NONE;
+ const char *hostname, *ip;
- SILC_LOG_DEBUG(("Start"));
-
- if (packet->src_id_type && packet->src_id_type != SILC_ID_CLIENT)
+ if (packet->src_id_type && packet->src_id_type != SILC_ID_CLIENT) {
+ SILC_LOG_DEBUG(("Request not from client"));
+ silc_packet_free(packet);
return;
+ }
+
+ silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
+ NULL, &hostname, &ip, NULL);
/* Parse the payload */
- ret = silc_buffer_unformat(packet->buffer,
+ ret = silc_buffer_unformat(&packet->buffer,
SILC_STR_UI_SHORT(&conn_type),
SILC_STR_UI_SHORT(NULL),
SILC_STR_END);
- if (ret == -1)
- return;
-
- if (conn_type != SILC_SOCKET_TYPE_CLIENT)
+ if (ret == -1 || conn_type != SILC_CONN_CLIENT) {
+ silc_packet_free(packet);
return;
+ }
/* Get the authentication method for the client */
auth_meth = SILC_AUTH_NONE;
- client = silc_server_config_find_client(server, sock->ip);
+ client = silc_server_config_find_client(server, (char *)ip);
if (!client)
- client = silc_server_config_find_client(server, sock->hostname);
+ client = silc_server_config_find_client(server, (char *)hostname);
if (client) {
if (client->passphrase) {
if (client->publickeys && !server->config->prefer_passphrase_auth)
auth_meth = SILC_AUTH_PUBLIC_KEY;
}
+ SILC_LOG_DEBUG(("Authentication method is [%s]",
+ (auth_meth == SILC_AUTH_NONE ? "None" :
+ auth_meth == SILC_AUTH_PASSWORD ? "Passphrase" :
+ "Digital signatures")));
+
/* Send it back to the client */
silc_server_send_connection_auth_request(server, sock, conn_type, auth_meth);
-}
-
-/* Received REKEY packet. The sender of the packet wants to regenerate
- its session keys. This starts the REKEY protocol. */
-
-void silc_server_rekey(SilcServer server,
- SilcSocketConnection sock,
- SilcPacketContext *packet)
-{
- SilcProtocol protocol;
- SilcServerRekeyInternalContext *proto_ctx;
- SilcIDListData idata = (SilcIDListData)sock->user_data;
-
- SILC_LOG_DEBUG(("Start"));
-
- /* Allocate internal protocol context. This is sent as context
- to the protocol. */
- proto_ctx = silc_calloc(1, sizeof(*proto_ctx));
- proto_ctx->server = (void *)server;
- proto_ctx->sock = sock;
- proto_ctx->responder = TRUE;
- proto_ctx->pfs = idata->rekey->pfs;
-
- /* Perform rekey protocol. Will call the final callback after the
- protocol is over. */
- silc_protocol_alloc(SILC_PROTOCOL_SERVER_REKEY,
- &protocol, proto_ctx, silc_server_rekey_final);
- sock->protocol = protocol;
-
- if (proto_ctx->pfs == FALSE)
- /* Run the protocol */
- silc_protocol_execute(protocol, server->schedule, 0, 0);
+ silc_packet_free(packet);
}
/* Received file transger packet. This packet is never for us. It is to
one client to another. */
void silc_server_ftp(SilcServer server,
- SilcSocketConnection sock,
- SilcPacketContext *packet)
+ SilcPacketStream sock,
+ SilcPacket packet)
{
- SilcSocketConnection dst_sock;
+ SilcPacketStream dst_sock;
SilcIDListData idata;
SILC_LOG_DEBUG(("Start"));
if (packet->src_id_type != SILC_ID_CLIENT ||
- packet->dst_id_type != SILC_ID_CLIENT)
- return;
-
- if (!packet->dst_id)
+ packet->dst_id_type != SILC_ID_CLIENT || !packet->dst_id) {
+ silc_packet_free(packet);
return;
+ }
/* Get the route to the client */
dst_sock = silc_server_get_client_route(server, packet->dst_id,
- packet->dst_id_len, NULL,
+ packet->dst_id_len, NULL,
&idata, NULL);
- if (!dst_sock)
+ if (!dst_sock) {
+ silc_packet_free(packet);
return;
+ }
/* Relay the packet */
- silc_server_relay_packet(server, dst_sock, idata->send_key,
- idata->hmac_send, idata->psn_send++,
- packet, FALSE);
+ silc_server_packet_route(server, dst_sock, packet);
+ silc_packet_free(packet);
}
typedef struct {
SilcServer server;
- SilcSocketConnection sock;
- SilcPacketContext *packet;
- void *data;
+ SilcPacketStream sock;
+ SilcPacket packet;
+ SilcClientID client_id;
} *SilcServerResumeResolve;
SILC_SERVER_CMD_FUNC(resume_resolve)
{
SilcServerResumeResolve r = (SilcServerResumeResolve)context;
SilcServer server = r->server;
- SilcSocketConnection sock = r->sock;
+ SilcPacketStream sock = r->sock;
SilcServerCommandReplyContext reply = context2;
SilcClientEntry client;
+ const char *hostname, *ip;
SILC_LOG_DEBUG(("Start"));
+ silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
+ NULL, &hostname, &ip, NULL);
+
if (!reply || !silc_command_get_status(reply->payload, NULL, NULL)) {
SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
- "closing connection", sock->hostname, sock->ip));
+ "closing connection", hostname, ip));
silc_server_disconnect_remote(server, sock,
SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
"Resuming not possible");
+ silc_server_free_sock_user_data(server, sock, NULL);
goto out;
}
if (reply && silc_command_get(reply->payload) == SILC_COMMAND_WHOIS) {
/* Get entry to the client, and resolve it if we don't have it. */
- client = silc_idlist_find_client_by_id(server->local_list,
- r->data, TRUE, NULL);
+ client = silc_idlist_find_client_by_id(server->local_list,
+ &r->client_id, TRUE, NULL);
if (!client) {
client = silc_idlist_find_client_by_id(server->global_list,
- r->data, TRUE, NULL);
+ &r->client_id, TRUE, NULL);
if (!client) {
SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
- "closing connection", sock->hostname, sock->ip));
+ "closing connection", hostname, ip));
silc_server_disconnect_remote(server, sock,
SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
"Resuming not possible");
+ silc_server_free_sock_user_data(server, sock, NULL);
goto out;
}
}
if (!(client->mode & SILC_UMODE_DETACHED)) {
SILC_LOG_ERROR(("Client %s (%s) tried to resume un-detached client, "
- "closing connection", sock->hostname, sock->ip));
+ "closing connection", hostname, ip));
silc_server_disconnect_remote(server, sock,
SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
"Resuming not possible");
+ silc_server_free_sock_user_data(server, sock, NULL);
goto out;
}
+
+ client->data.status |= SILC_IDLIST_STATUS_RESUME_RES;
}
/* Reprocess the packet */
silc_server_resume_client(server, sock, r->packet);
out:
- silc_socket_free(r->sock);
- silc_packet_context_free(r->packet);
- silc_free(r->data);
+ silc_packet_stream_unref(r->sock);
silc_free(r);
}
that the client is not detached anymore. */
void silc_server_resume_client(SilcServer server,
- SilcSocketConnection sock,
- SilcPacketContext *packet)
+ SilcPacketStream sock,
+ SilcPacket packet)
{
- SilcBuffer buffer = packet->buffer, buf;
- SilcIDListData idata;
+ SilcBuffer buffer = &packet->buffer, buf;
+ SilcIDListData idata = silc_packet_get_context(sock);
+ SilcIDCacheEntry id_cache = NULL;
SilcClientEntry detached_client;
- SilcClientID *client_id = NULL;
- unsigned char *id_string, *auth = NULL;
+ SilcClientID client_id;
+ unsigned char *id_string, *auth = NULL, *nicknamec = NULL;
+ unsigned char cid[32];
+ SilcUInt32 cid_len;
SilcUInt16 id_len, auth_len = 0;
- int ret, nickfail = 0;
- bool resolved, local, nick_change = FALSE;
+ SilcBool resolved, local, nick_change = FALSE, resolve = FALSE;
SilcChannelEntry channel;
SilcHashTableList htl;
SilcChannelClientEntry chl;
SilcServerResumeResolve r;
+ SilcPublicKey public_key;
+ const char *cipher, *hostname, *ip;
- SILC_LOG_DEBUG(("Start"));
+ SILC_LOG_DEBUG(("Resuming client"));
- ret = silc_buffer_unformat(buffer,
- SILC_STR_UI16_NSTRING(&id_string, &id_len),
- SILC_STR_END);
- if (ret != -1)
- client_id = silc_id_str2id(id_string, id_len, SILC_ID_CLIENT);
+ silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
+ NULL, &hostname, &ip, NULL);
+
+ if (silc_buffer_unformat(buffer,
+ SILC_STR_UI16_NSTRING(&id_string, &id_len),
+ SILC_STR_END) < 0) {
+ if (idata->conn_type == SILC_CONN_CLIENT) {
+ SILC_LOG_ERROR(("Client %s (%s) sent incomplete resume information, "
+ "closing connection", hostname, ip));
+ silc_server_disconnect_remote(server, sock,
+ SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
+ "Resuming not possible");
+ silc_server_free_sock_user_data(server, sock, NULL);
+ }
+ goto out;
+ }
+
+ silc_id_str2id(id_string, id_len, SILC_ID_CLIENT, &client_id,
+ sizeof(client_id));
- if (sock->type == SILC_SOCKET_TYPE_CLIENT) {
+ if (idata->conn_type == SILC_CONN_CLIENT) {
/* Client send this and is attempting to resume to old client session */
SilcClientEntry client;
SilcBuffer keyp;
- if (ret != -1) {
- silc_buffer_pull(buffer, 2 + id_len);
- auth = buffer->data;
- auth_len = buffer->len;
- silc_buffer_push(buffer, 2 + id_len);
- }
+ silc_buffer_pull(buffer, 2 + id_len);
+ auth = buffer->data;
+ auth_len = silc_buffer_len(buffer);
+ silc_buffer_push(buffer, 2 + id_len);
- if (!client_id || auth_len < 128) {
+ if (auth_len < 128) {
SILC_LOG_ERROR(("Client %s (%s) sent incomplete resume information, "
- "closing connection", sock->hostname, sock->ip));
+ "closing connection", hostname, ip));
silc_server_disconnect_remote(server, sock,
SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
"Resuming not possible");
- return;
+ silc_server_free_sock_user_data(server, sock, NULL);
+ goto out;
}
/* Take client entry of this connection */
- client = (SilcClientEntry)sock->user_data;
- idata = (SilcIDListData)client;
+ client = (SilcClientEntry)idata;
/* Get entry to the client, and resolve it if we don't have it. */
- detached_client = silc_server_get_client_resolve(server, client_id, FALSE,
- &resolved);
+ detached_client = silc_server_query_client(server, &client_id, FALSE,
+ &resolved);
if (!detached_client) {
if (resolved) {
/* The client info is being resolved. Reprocess this packet after
SILC_LOG_DEBUG(("Resolving client"));
r = silc_calloc(1, sizeof(*r));
if (!r)
- return;
+ goto out;
+ silc_packet_stream_ref(sock);
r->server = server;
- r->sock = silc_socket_dup(sock);
- r->packet = silc_packet_context_dup(packet);
- r->data = silc_id_dup(client_id, SILC_ID_CLIENT);
+ r->sock = sock;
+ r->packet = packet;
+ r->client_id = client_id;
silc_server_command_pending(server, SILC_COMMAND_WHOIS,
server->cmd_ident,
silc_server_command_resume_resolve, r);
+ return;
} else {
SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
- "closing connection", sock->hostname, sock->ip));
+ "closing connection", hostname, ip));
silc_server_disconnect_remote(server, sock,
SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
"Resuming not possible");
+ silc_server_free_sock_user_data(server, sock, NULL);
+ goto out;
}
- return;
}
- /* Check that the client is detached, and that we have other info too */
- if (!(detached_client->mode & SILC_UMODE_DETACHED) ||
- !silc_hash_table_count(detached_client->channels) ||
- !detached_client->nickname) {
+ if (detached_client->data.status & SILC_IDLIST_STATUS_RESUMED) {
+ SILC_LOG_ERROR(("Client %s (%s) tried to attach more than once, "
+ "closing connection", hostname, ip));
+ silc_server_disconnect_remote(server, sock,
+ SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
+ "Resuming not possible");
+ silc_server_free_sock_user_data(server, sock, NULL);
+ goto out;
+ }
+
+ if (detached_client->resuming_client &&
+ detached_client->resuming_client != client) {
+ SILC_LOG_ERROR(("Client %s (%s) tried to attach more than once, "
+ "closing connection", hostname, ip));
+ silc_server_disconnect_remote(server, sock,
+ SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
+ "Resuming not possible");
+ silc_server_free_sock_user_data(server, sock, NULL);
+ goto out;
+ }
+
+ if (!detached_client->resuming_client)
+ detached_client->resuming_client = client;
+
+ if (!(detached_client->mode & SILC_UMODE_DETACHED))
+ resolve = TRUE;
+ if (!silc_hash_table_count(detached_client->channels) &&
+ detached_client->router)
+ resolve = TRUE;
+ if (!detached_client->nickname)
+ resolve = TRUE;
+ if (detached_client->data.status & SILC_IDLIST_STATUS_RESUME_RES)
+ resolve = FALSE;
+
+ if (resolve) {
if (server->server_type == SILC_SERVER && !server->standalone) {
/* The client info is being resolved. Reprocess this packet after
receiving the reply to the query. */
SILC_LOG_DEBUG(("Resolving client info"));
- silc_server_get_client_resolve(server, client_id, TRUE, NULL);
+ silc_server_query_client(server, &client_id, TRUE, NULL);
r = silc_calloc(1, sizeof(*r));
if (!r)
return;
+ silc_packet_stream_ref(sock);
r->server = server;
- r->sock = silc_socket_dup(sock);
- r->packet = silc_packet_context_dup(packet);
- r->data = silc_id_dup(client_id, SILC_ID_CLIENT);
+ r->sock = sock;
+ r->packet = packet;
+ r->client_id = client_id;
silc_server_command_pending(server, SILC_COMMAND_WHOIS,
server->cmd_ident,
silc_server_command_resume_resolve, r);
}
if (server->server_type == SILC_SERVER) {
SILC_LOG_ERROR(("Client %s (%s) tried to resume un-detached client, "
- "closing connection", sock->hostname, sock->ip));
+ "closing connection", hostname, ip));
silc_server_disconnect_remote(server, sock,
SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
"Resuming not possible");
- return;
+ silc_server_free_sock_user_data(server, sock, NULL);
+ goto out;
}
}
/* Check that we have the public key of the client, if not then we must
resolve it first. */
if (!detached_client->data.public_key) {
- if (server->standalone) {
+ if (server->server_type == SILC_SERVER && server->standalone) {
+ SILC_LOG_ERROR(("Detached client's public key not present, "
+ "closing connection"));
silc_server_disconnect_remote(server, sock,
SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
"Resuming not possible");
+ silc_server_free_sock_user_data(server, sock, NULL);
+ goto out;
} else {
/* We must retrieve the detached client's public key by sending
GETKEY command. Reprocess this packet after receiving the key */
- SilcBuffer idp = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
- SilcSocketConnection dest_sock =
- silc_server_get_client_route(server, NULL, 0, client_id, NULL, NULL);
+ SilcBuffer idp = silc_id_payload_encode(&client_id, SILC_ID_CLIENT);
+ SilcPacketStream dest_sock =
+ silc_server_get_client_route(server, NULL, 0, &client_id,
+ NULL, NULL);
SILC_LOG_DEBUG(("Resolving client public key"));
- silc_server_send_command(server, dest_sock ? dest_sock :
- server->router->connection,
+ silc_server_send_command(server, dest_sock ? dest_sock :
+ SILC_PRIMARY_ROUTE(server),
SILC_COMMAND_GETKEY, ++server->cmd_ident,
- 1, 1, idp->data, idp->len);
+ 1, 1, idp->data, silc_buffer_len(idp));
r = silc_calloc(1, sizeof(*r));
if (!r)
return;
-
+ silc_packet_stream_ref(sock);
r->server = server;
- r->sock = silc_socket_dup(sock);
- r->packet = silc_packet_context_dup(packet);
+ r->sock = sock;
+ r->packet = packet;
+ r->client_id = client_id;
silc_server_command_pending(server, SILC_COMMAND_GETKEY,
server->cmd_ident,
silc_server_command_resume_resolve, r);
silc_buffer_free(idp);
+ return;
}
- return;
} else if (!silc_pkcs_public_key_compare(detached_client->data.public_key,
idata->public_key)) {
/* We require that the connection and resuming authentication data
must be using same key pair. */
+ SILC_LOG_ERROR(("Resuming attempted with wrong public key, "
+ "closing connection"));
silc_server_disconnect_remote(server, sock,
SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
"Resuming not possible");
- return;
+ silc_server_free_sock_user_data(server, sock, NULL);
+ goto out;
}
/* Verify the authentication payload. This has to be successful in
order to allow the resuming */
- if (!silc_auth_verify_data(auth, auth_len, SILC_AUTH_PUBLIC_KEY,
+ if (!idata->hash ||
+ !silc_auth_verify_data(auth, auth_len, SILC_AUTH_PUBLIC_KEY,
detached_client->data.public_key, 0,
- idata->hash, detached_client->id,
+ idata->hash, detached_client->id,
SILC_ID_CLIENT)) {
SILC_LOG_ERROR(("Client %s (%s) resume authentication failed, "
- "closing connection", sock->hostname, sock->ip));
+ "closing connection", hostname, ip));
silc_server_disconnect_remote(server, sock,
SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
"Resuming not possible");
- return;
+ silc_server_free_sock_user_data(server, sock, NULL);
+ goto out;
+ }
+
+ /* Check nickname */
+ nicknamec = silc_identifier_check(detached_client->nickname,
+ strlen(detached_client->nickname),
+ SILC_STRING_UTF8, 128, NULL);
+ if (!nicknamec) {
+ silc_server_disconnect_remote(server, sock,
+ SILC_STATUS_ERR_BAD_NICKNAME,
+ "Malformed nickname, cannot resume");
+ silc_server_free_sock_user_data(server, sock, NULL);
+ goto out;
+ }
+
+ /* If the ID is not based in our ID then change it */
+ if (!SILC_ID_COMPARE(detached_client->id, server->id,
+ server->id->ip.data_len)) {
+ SilcClientID *new_id;
+ if (!silc_id_create_client_id(server, server->id, server->rng,
+ server->md5hash, nicknamec,
+ strlen(nicknamec), &new_id)) {
+ silc_server_disconnect_remote(server, sock,
+ SILC_STATUS_ERR_BAD_NICKNAME,
+ "Resuming not possible");
+ silc_server_free_sock_user_data(server, sock, NULL);
+ goto out;
+ }
+ nick_change = TRUE;
+ client_id = *new_id;
+ silc_free(new_id);
}
/* Now resume the client to the network */
silc_schedule_task_del_by_context(server->schedule, detached_client);
- sock->user_data = detached_client;
+ silc_packet_set_context(sock, detached_client);
detached_client->connection = sock;
+ if (detached_client->data.public_key) {
+ /* Delete the detached client's public key from repository */
+ silc_skr_del_public_key(server->repository,
+ detached_client->data.public_key,
+ detached_client);
+ detached_client->data.public_key = NULL;
+ }
+
+ if (idata->public_key) {
+ /* Delete the resuming client's public key from repository. It will
+ be added later again. */
+ public_key = silc_pkcs_public_key_copy(idata->public_key);
+ silc_skr_del_public_key(server->repository, idata->public_key, idata);
+ idata->public_key = public_key;
+ }
+
/* Take new keys and stuff into use in the old entry */
silc_idlist_del_data(detached_client);
silc_idlist_add_data(detached_client, idata);
+ idata->public_key = NULL;
+
+ if (detached_client->data.public_key) {
+ /* Add the resumed client's public key back to repository. */
+ if (!silc_server_get_public_key_by_client(server, detached_client, NULL))
+ silc_skr_add_public_key_simple(server->repository,
+ detached_client->data.public_key,
+ SILC_SKR_USAGE_IDENTIFICATION,
+ detached_client, NULL);
+ }
+
detached_client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
detached_client->data.status |= SILC_IDLIST_STATUS_RESUMED;
+ detached_client->data.status |= SILC_IDLIST_STATUS_LOCAL;
+ detached_client->data.status &= ~SILC_IDLIST_STATUS_RESUME_RES;
detached_client->mode &= ~SILC_UMODE_DETACHED;
+ server->stat.my_detached--;
+ silc_dlist_del(server->expired_clients, detached_client);
+
+ /* We are finished - reset resuming client */
+ detached_client->resuming_client = NULL;
+
+ /* Check if anyone is watching this client */
+ if (server->server_type == SILC_ROUTER)
+ silc_server_check_watcher_list(server, detached_client, NULL,
+ SILC_NOTIFY_TYPE_UMODE_CHANGE);
+
+ /* Delete this current client entry since we're resuming to old one. */
+ server->stat.my_clients--;
+ server->stat.clients--;
+ if (server->stat.cell_clients)
+ server->stat.cell_clients--;
+ silc_server_remove_from_channels(server, NULL, client, FALSE,
+ NULL, FALSE, FALSE);
+ silc_server_del_from_watcher_list(server, client);
+ silc_dlist_del(server->expired_clients, client);
+ if (!silc_idlist_del_client(server->local_list, client))
+ silc_idlist_del_client(server->global_list, client);
+ client = detached_client;
+ silc_free(client->servername);
+ client->servername = strdup(server->server_name);
/* Send the RESUME_CLIENT packet to our primary router so that others
know this client isn't detached anymore. */
SILC_STR_END);
/* Send to primary router */
- if (!server->standalone)
- silc_server_packet_send(server, server->router->connection,
- SILC_PACKET_RESUME_CLIENT, 0,
- buf->data, buf->len, TRUE);
+ silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
+ SILC_PACKET_RESUME_CLIENT, 0,
+ buf->data, silc_buffer_len(buf));
+ silc_server_backup_send(server, client->router,
+ SILC_PACKET_RESUME_CLIENT, 0,
+ buf->data, silc_buffer_len(buf), TRUE, TRUE);
/* As router we must deliver this packet directly to the original
server whom this client was earlier. */
- if (server->server_type == SILC_ROUTER && detached_client->router &&
- detached_client->router->server_type != SILC_ROUTER)
- silc_server_packet_send(server, detached_client->router->connection,
- SILC_PACKET_RESUME_CLIENT, 0,
- buf->data, buf->len, TRUE);
+ if (server->server_type == SILC_ROUTER && client->router &&
+ client->router->server_type != SILC_ROUTER)
+ silc_server_packet_send(server, client->router->connection,
+ SILC_PACKET_RESUME_CLIENT, 0,
+ buf->data, silc_buffer_len(buf));
silc_buffer_free(buf);
-
- detached_client->router = NULL;
-
- /* Delete this client entry since we're resuming to old one. */
- server->stat.my_clients--;
- server->stat.clients--;
- if (server->stat.cell_clients)
- server->stat.cell_clients--;
- silc_idlist_del_client(server->local_list, client);
- client = detached_client;
-
- /* If the ID is not based in our ID then change it */
- if (!SILC_ID_COMPARE(client->id, server->id, server->id->ip.data_len)) {
- while (!silc_id_create_client_id(server, server->id, server->rng,
- server->md5hash, client->nickname,
- &client_id)) {
- nickfail++;
- if (nickfail > 9) {
- silc_server_disconnect_remote(server, sock,
- SILC_STATUS_ERR_BAD_NICKNAME, NULL);
- return;
- }
- snprintf(&client->nickname[strlen(client->nickname) - 1], 1,
- "%d", nickfail);
- }
- nick_change = TRUE;
- }
+ client->router = NULL;
if (nick_change) {
/* Notify about Client ID change, nickname doesn't actually change. */
- if (!server->standalone)
- silc_server_send_notify_nick_change(server, server->router->connection,
- FALSE, client->id, client_id,
- client->nickname);
+ silc_server_send_notify_nick_change(server, SILC_PRIMARY_ROUTE(server),
+ SILC_BROADCAST(server),
+ client->id, &client_id,
+ client->nickname);
}
/* Resolve users on those channels that client has joined but we
haven't resolved user list yet. */
if (server->server_type == SILC_SERVER && !server->standalone) {
silc_hash_table_list(client->channels, &htl);
- while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
+ while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
channel = chl->channel;
- SILC_LOG_DEBUG(("Resolving users for %s channel",
+ SILC_LOG_DEBUG(("Resolving users for %s channel",
channel->channel_name));
if (channel->disabled || !channel->users_resolved) {
- silc_server_send_command(server, server->router->connection,
+ silc_server_send_command(server, SILC_PRIMARY_ROUTE(server),
SILC_COMMAND_USERS, ++server->cmd_ident,
1, 2, channel->channel_name,
strlen(channel->channel_name));
/* Send the new client ID to the client. After this client may start
receiving other packets, and may start sending packets too. */
- silc_server_send_new_id(server, sock, FALSE, client_id, SILC_ID_CLIENT,
- silc_id_get_len(client_id, SILC_ID_CLIENT));
+ silc_server_send_new_id(server, sock, FALSE, &client_id, SILC_ID_CLIENT,
+ silc_id_get_len(&client_id, SILC_ID_CLIENT));
if (nick_change) {
/* Send NICK change notify to channels as well. */
SilcBuffer oidp, nidp;
oidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
- nidp = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
- silc_server_send_notify_on_channels(server, NULL, client,
+ nidp = silc_id_payload_encode(&client_id, SILC_ID_CLIENT);
+ silc_server_send_notify_on_channels(server, NULL, client,
SILC_NOTIFY_TYPE_NICK_CHANGE, 3,
- oidp->data, oidp->len,
- nidp->data, nidp->len,
- client->nickname,
+ oidp->data, silc_buffer_len(oidp),
+ nidp->data, silc_buffer_len(nidp),
+ client->nickname,
strlen(client->nickname));
silc_buffer_free(oidp);
silc_buffer_free(nidp);
}
- /* Add the client again to the ID cache to get it to correct list */
- if (!silc_idcache_del_by_context(server->local_list->clients, client))
- silc_idcache_del_by_context(server->global_list->clients, client);
- silc_free(client->id);
- client->id = client_id;
- client_id = NULL;
- silc_idcache_add(server->local_list->clients, client->nickname,
- client->id, client, 0, NULL);
+ /* Update entry */
+ if (!silc_idcache_update_by_context(server->local_list->clients, client,
+ &client_id, NULL, FALSE))
+ silc_idcache_update_by_context(server->global_list->clients, client,
+ &client_id, NULL, FALSE);
+
+ /* Move entry to local list if it is in global list */
+ if (silc_idcache_find_by_context(server->global_list->clients, client,
+ &id_cache))
+ silc_idcache_move(server->global_list->clients,
+ server->local_list->clients, id_cache);
/* Send some nice info to the client */
silc_server_send_connect_notifys(server, sock, client);
/* Send all channel keys of channels the client has joined */
silc_hash_table_list(client->channels, &htl);
- while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
- bool created = FALSE;
+ while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
+ SilcBool created = FALSE;
channel = chl->channel;
if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY)
continue;
/* If we don't have channel key, then create one */
- if (!channel->channel_key) {
+ if (!channel->send_key) {
if (!silc_server_create_channel_key(server, channel, 0))
continue;
created = TRUE;
}
- id_string = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
- keyp =
- silc_channel_key_payload_encode(silc_id_get_len(channel->id,
- SILC_ID_CHANNEL),
- id_string,
- strlen(channel->channel_key->
- cipher->name),
- channel->channel_key->cipher->name,
+ silc_id_id2str(channel->id, SILC_ID_CHANNEL, cid, sizeof(cid),
+ &cid_len);
+ cipher = silc_cipher_get_name(channel->send_key);
+ keyp =
+ silc_channel_key_payload_encode(cid_len, cid,
+ strlen(cipher), cipher,
channel->key_len / 8, channel->key);
- silc_free(id_string);
-
- /* Send the key packet to client */
- silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
- keyp->data, keyp->len, FALSE);
- if (created && server->server_type == SILC_SERVER &&
- !server->standalone)
- silc_server_packet_send(server, server->router->connection,
- SILC_PACKET_CHANNEL_KEY, 0,
- keyp->data, keyp->len, FALSE);
+ /* Send the channel key to the client */
+ silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
+ keyp->data, silc_buffer_len(keyp));
+
+ /* Distribute the channel key to channel */
+ if (created) {
+ silc_server_send_channel_key(server, NULL, channel,
+ server->server_type == SILC_ROUTER ?
+ FALSE : !server->standalone);
+ silc_server_backup_send(server, NULL, SILC_PACKET_CHANNEL_KEY, 0,
+ keyp->data, silc_buffer_len(keyp),
+ FALSE, TRUE);
+ }
silc_buffer_free(keyp);
}
silc_hash_table_list_reset(&htl);
- } else if (sock->type != SILC_SOCKET_TYPE_CLIENT) {
+ } else if (idata->conn_type != SILC_CONN_CLIENT) {
/* Server or router sent this to us to notify that that a client has
been resumed. */
SilcServerEntry server_entry;
- SilcServerID *server_id;
-
- if (!client_id)
- return;
+ SilcServerID server_id;
/* Get entry to the client, and resolve it if we don't have it. */
- detached_client = silc_idlist_find_client_by_id(server->local_list,
- client_id, TRUE, NULL);
+ detached_client = silc_idlist_find_client_by_id(server->local_list,
+ &client_id, TRUE,
+ &id_cache);
if (!detached_client) {
detached_client = silc_idlist_find_client_by_id(server->global_list,
- client_id, TRUE, NULL);
- if (!detached_client)
- return;
+ &client_id, TRUE,
+ &id_cache);
+ if (!detached_client) {
+ SILC_LOG_DEBUG(("Resuming client is unknown"));
+ goto out;
+ }
}
/* Check that the client has not been resumed already because it is
/* The client is clearly attempting to resume more than once and
perhaps playing around by resuming from several different places
at the same time. */
+ SILC_LOG_DEBUG(("Attempting to re-resume client, killing both"));
silc_server_kill_client(server, detached_client, NULL,
server->id, SILC_ID_SERVER);
- return;
+ goto out;
}
/* Check whether client is detached at all */
- if (!(detached_client->mode & SILC_UMODE_DETACHED))
- return;
+ if (!(detached_client->mode & SILC_UMODE_DETACHED)) {
+ SILC_LOG_DEBUG(("Client is not detached"));
+ goto out;
+ }
+
+ /* Check nickname */
+ if (detached_client->nickname) {
+ nicknamec = silc_identifier_check(detached_client->nickname,
+ strlen(detached_client->nickname),
+ SILC_STRING_UTF8, 128, NULL);
+ if (!nicknamec)
+ goto out;
+ }
+
+ SILC_LOG_DEBUG(("Resuming detached client"));
+
+ /* If the sender of this packet is server and we are router we need to
+ broadcast this packet to other routers in the network. */
+ if (server->server_type == SILC_ROUTER &&
+ idata->conn_type == SILC_CONN_SERVER &&
+ !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
+ SILC_LOG_DEBUG(("Broadcasting received Resume Client packet"));
+ silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
+ packet->type,
+ packet->flags | SILC_PACKET_FLAG_BROADCAST,
+ buffer->data, silc_buffer_len(buffer));
+ silc_server_backup_send(server, (SilcServerEntry)idata,
+ packet->type, packet->flags,
+ packet->buffer.data,
+ silc_buffer_len(&packet->buffer),
+ FALSE, TRUE);
+ }
/* Client is detached, and now it is resumed. Remove the detached
mode and mark that it is resumed. */
+
+ if (detached_client->data.public_key) {
+ /* Delete the detached client's public key from repository */
+ silc_skr_del_public_key(server->repository,
+ detached_client->data.public_key,
+ detached_client);
+ detached_client->data.public_key = NULL;
+ }
+
+ silc_idlist_del_data(detached_client);
detached_client->mode &= ~SILC_UMODE_DETACHED;
detached_client->data.status |= SILC_IDLIST_STATUS_RESUMED;
+ detached_client->data.status &= ~SILC_IDLIST_STATUS_LOCAL;
+ silc_dlist_del(server->expired_clients, detached_client);
+
+ /* Check if anyone is watching this client */
+ if (server->server_type == SILC_ROUTER)
+ silc_server_check_watcher_list(server, detached_client, NULL,
+ SILC_NOTIFY_TYPE_UMODE_CHANGE);
+
+ silc_schedule_task_del_by_context(server->schedule, detached_client);
/* Get the new owner of the resumed client */
- server_id = silc_id_str2id(packet->src_id, packet->src_id_len,
- packet->src_id_type);
- if (!server_id)
- return;
+ if (!silc_id_str2id(packet->src_id, packet->src_id_len,
+ packet->src_id_type, &server_id, sizeof(server_id)))
+ goto out;
/* Get server entry */
- server_entry = silc_idlist_find_server_by_id(server->global_list,
- server_id, TRUE, NULL);
- local = TRUE;
+ server_entry = silc_idlist_find_server_by_id(server->global_list,
+ &server_id, TRUE, NULL);
+ local = FALSE;
if (!server_entry) {
- server_entry = silc_idlist_find_server_by_id(server->local_list,
- server_id, TRUE, NULL);
- local = FALSE;
- if (!server_entry) {
- silc_free(server_id);
- return;
- }
+ server_entry = silc_idlist_find_server_by_id(server->local_list,
+ &server_id, TRUE, NULL);
+ local = TRUE;
+ if (!server_entry)
+ goto out;
}
if (server->server_type == SILC_ROUTER &&
- sock->type == SILC_SOCKET_TYPE_ROUTER &&
+ idata->conn_type == SILC_CONN_ROUTER &&
server_entry->server_type == SILC_ROUTER)
local = FALSE;
- SILC_LOG_DEBUG(("Resuming detached client"));
+ /* Move entry to correct list */
+ if (local && server->server_type == SILC_ROUTER) {
+ if (silc_idcache_find_by_context(server->global_list->clients,
+ detached_client, &id_cache))
+ silc_idcache_move(server->global_list->clients,
+ server->local_list->clients, id_cache);
+ } else {
+ if (silc_idcache_find_by_context(server->local_list->clients,
+ detached_client, &id_cache))
+ silc_idcache_move(server->local_list->clients,
+ server->global_list->clients, id_cache);
+ }
- /* Change the client to correct list. */
- if (!silc_idcache_del_by_context(server->local_list->clients,
- detached_client))
- silc_idcache_del_by_context(server->global_list->clients,
- detached_client);
- silc_idcache_add(local && server->server_type == SILC_ROUTER ?
- server->local_list->clients :
- server->global_list->clients,
- detached_client->nickname,
- detached_client->id, detached_client, FALSE, NULL);
-
- /* Change the owner of the client if needed */
- if (detached_client->router != server_entry)
- detached_client->router = server_entry;
+ /* Change the owner of the client */
+ detached_client->router = server_entry;
/* Update channel information regarding global clients on channel. */
- if (server->server_type == SILC_SERVER) {
+ if (server->server_type != SILC_ROUTER) {
silc_hash_table_list(detached_client->channels, &htl);
- while (silc_hash_table_get(&htl, NULL, (void **)&chl))
- chl->channel->global_users =
+ while (silc_hash_table_get(&htl, NULL, (void *)&chl))
+ chl->channel->global_users =
silc_server_channel_has_global(chl->channel);
silc_hash_table_list_reset(&htl);
}
-
- silc_schedule_task_del_by_context(server->schedule, detached_client);
-
- /* If the sender of this packet is server and we are router we need to
- broadcast this packet to other routers in the network. */
- if (!server->standalone && server->server_type == SILC_ROUTER &&
- sock->type == SILC_SOCKET_TYPE_SERVER &&
- !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
- SILC_LOG_DEBUG(("Broadcasting received Resume Client packet"));
- silc_server_packet_send(server, server->router->connection,
- packet->type,
- packet->flags | SILC_PACKET_FLAG_BROADCAST,
- buffer->data, buffer->len, FALSE);
- silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
- packet->type, packet->flags,
- packet->buffer->data, packet->buffer->len,
- FALSE, TRUE);
- }
-
- silc_free(server_id);
}
- silc_free(client_id);
+ out:
+ silc_packet_free(packet);
}
projects / silc.git / blobdiff