Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
- Copyright (C) 1997 - 2000 Pekka Riikonen
+ Copyright (C) 1997 - 2001 Pekka Riikonen
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
SILC_LOG_DEBUG(("Start"));
- if (!packet->dst_id) {
- SILC_LOG_ERROR(("Bad Client ID in private message packet, dropped"));
+ if (!packet->dst_id)
goto err;
- }
/* Decode destination Client ID */
- id = silc_id_str2id(packet->dst_id, SILC_ID_CLIENT);
+ id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CLIENT);
if (!id) {
SILC_LOG_ERROR(("Could not decode destination Client ID, dropped"));
goto err;
/* If the destination belongs to our server we don't have to route
the message anywhere but to send it to the local destination. */
- client = silc_idlist_find_client_by_id(server->local_list, id);
+ client = silc_idlist_find_client_by_id(server->local_list, id, NULL);
if (client) {
/* It exists, now deliver the message to the destination */
dst_sock = (SilcSocketConnection)client->connection;
we will send the packet to that server. */
router = (SilcServerEntry)dst_sock->user_data;
idata = (SilcIDListData)router;
- // assert(client->router == server->id_entry);
silc_server_send_private_message(server, dst_sock,
idata->send_key,
/* We are router and we will perform route lookup for the destination
and send the message to fastest route. */
if (server->server_type == SILC_ROUTER && !server->standalone) {
- dst_sock = silc_server_route_get(server, id, SILC_ID_CLIENT);
- router = (SilcServerEntry)dst_sock->user_data;
- idata = (SilcIDListData)router;
+ /* Check first that the ID is valid */
+ client = silc_idlist_find_client_by_id(server->global_list, id, NULL);
+ if (client) {
+ dst_sock = silc_server_route_get(server, id, SILC_ID_CLIENT);
+ router = (SilcServerEntry)dst_sock->user_data;
+ idata = (SilcIDListData)router;
- /* Get fastest route and send packet. */
- if (router)
- silc_server_send_private_message(server, dst_sock,
- idata->send_key,
- idata->hmac, packet);
- return;
+ /* Get fastest route and send packet. */
+ if (router)
+ silc_server_send_private_message(server, dst_sock,
+ idata->send_key,
+ idata->hmac, packet);
+ return;
+ }
}
err:
"No such nickname: Private message not sent");
}
-/* Relays received command reply packet to the correct destination. The
- destination must be one of our locally connected client or the packet
- will be ignored. This is called when server has forwarded one of
- client's command request to router and router has now replied to the
- command. */
+/* 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
+ call the command reply routine after processing the packet. */
-void silc_server_packet_relay_command_reply(SilcServer server,
- SilcSocketConnection sock,
- SilcPacketContext *packet)
+void silc_server_command_reply(SilcServer server,
+ SilcSocketConnection sock,
+ SilcPacketContext *packet)
{
SilcBuffer buffer = packet->buffer;
- SilcClientEntry client;
- SilcClientID *id;
+ SilcClientEntry client = NULL;
SilcSocketConnection dst_sock;
SilcIDListData idata;
+ SilcClientID *id = NULL;
SILC_LOG_DEBUG(("Start"));
sock->type != SILC_SOCKET_TYPE_ROUTER)
return;
- /* Destination must be client */
- if (packet->dst_id_type != SILC_ID_CLIENT)
+ if (packet->dst_id_type == SILC_ID_CHANNEL)
return;
- /* Execute command reply locally for the command */
- silc_server_command_reply_process(server, sock, buffer);
-
- id = silc_id_str2id(packet->dst_id, SILC_ID_CLIENT);
-
- /* Destination must be one of ours */
- client = silc_idlist_find_client_by_id(server->local_list, id);
- if (!client) {
- SILC_LOG_ERROR(("Cannot relay command reply to unknown client"));
- silc_free(id);
- 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)
+ return;
+ client = silc_idlist_find_client_by_id(server->local_list, id, NULL);
+ if (!client) {
+ SILC_LOG_ERROR(("Cannot process command reply to unknown client"));
+ silc_free(id);
+ return;
+ }
}
- /* Relay the packet to the client */
-
- dst_sock = (SilcSocketConnection)client->connection;
- silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
- + packet->dst_id_len + packet->padlen);
-
- silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
- silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
+ if (packet->dst_id_type == SILC_ID_SERVER) {
+ /* For now this must be for us */
+ if (SILC_ID_SERVER_COMPARE(packet->dst_id, server->id_string)) {
+ SILC_LOG_ERROR(("Cannot process command reply to unknown server"));
+ return;
+ }
+ }
- idata = (SilcIDListData)client;
+ /* Execute command reply locally for the command */
+ silc_server_command_reply_process(server, sock, buffer);
- /* Encrypt packet */
- silc_packet_encrypt(idata->send_key, idata->hmac, dst_sock->outbuf,
- buffer->len);
+ if (packet->dst_id_type == SILC_ID_CLIENT && client && id) {
+ /* Relay the packet to the client */
+
+ dst_sock = (SilcSocketConnection)client->connection;
+ silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
+ + packet->dst_id_len + packet->padlen);
+
+ silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
+ silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
+
+ idata = (SilcIDListData)client;
- /* Send the packet */
- silc_server_packet_send_real(server, dst_sock, TRUE);
+ /* Encrypt packet */
+ silc_packet_encrypt(idata->send_key, idata->hmac, dst_sock->outbuf,
+ buffer->len);
+
+ /* Send the packet */
+ silc_server_packet_send_real(server, dst_sock, TRUE);
- silc_free(id);
+ silc_free(id);
+ }
}
/* Process received channel message. The message can be originated from
/* Sanity checks */
if (packet->dst_id_type != SILC_ID_CHANNEL) {
- SILC_LOG_ERROR(("Received bad message for channel, dropped"));
SILC_LOG_DEBUG(("Received bad message for channel, dropped"));
goto out;
}
/* Find channel entry */
- id = silc_id_str2id(packet->dst_id, SILC_ID_CHANNEL);
- channel = silc_idlist_find_channel_by_id(server->local_list, id);
- if (!channel) {
- SILC_LOG_DEBUG(("Could not find channel"));
+ id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CHANNEL);
+ if (!id)
goto out;
+ 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);
+ if (!channel) {
+ SILC_LOG_DEBUG(("Could not find channel"));
+ goto out;
+ }
}
/* See that this client is on the channel. If the message is coming
from router we won't do the check as the message is from client that
we don't know about. Also, if the original sender is not client
(as it can be server as well) we don't do the check. */
- sender = silc_id_str2id(packet->src_id, packet->src_id_type);
+ sender = silc_id_str2id(packet->src_id, packet->src_id_len,
+ packet->src_id_type);
+ if (!sender)
+ goto out;
if (sock->type != SILC_SOCKET_TYPE_ROUTER &&
packet->src_id_type == SILC_ID_CLIENT) {
silc_list_start(channel->user_list);
SilcPacketContext *packet)
{
SilcBuffer buffer = packet->buffer;
- SilcChannelKeyPayload payload = NULL;
- SilcChannelID *id = NULL;
SilcChannelEntry channel;
- SilcChannelClientEntry chl;
- unsigned char *tmp;
- unsigned int tmp_len;
- char *cipher;
- int exist = FALSE;
if (packet->src_id_type != SILC_ID_SERVER)
- goto out;
-
- /* Decode channel key payload */
- payload = silc_channel_key_payload_parse(buffer);
- if (!payload) {
- SILC_LOG_ERROR(("Bad channel key payload, dropped"));
- goto out;
- }
-
- /* Get channel ID */
- tmp = silc_channel_key_get_id(payload, &tmp_len);
- id = silc_id_payload_parse_id(tmp, tmp_len);
- if (!id)
- goto out;
-
- /* Get the channel entry */
- channel = silc_idlist_find_channel_by_id(server->local_list, id);
- if (!channel) {
- SILC_LOG_ERROR(("Received key for non-existent channel"));
- goto out;
- }
-
- tmp = silc_channel_key_get_key(payload, &tmp_len);
- if (!tmp)
- goto out;
-
- cipher = silc_channel_key_get_cipher(payload, NULL);;
- if (!cipher)
- goto out;
-
- /* Remove old key if exists */
- if (channel->key) {
- memset(channel->key, 0, channel->key_len);
- silc_free(channel->key);
- silc_cipher_free(channel->channel_key);
- exist = TRUE;
- }
-
- /* Create new cipher */
- if (!silc_cipher_alloc(cipher, &channel->channel_key))
- goto out;
+ return;
- /* Save the key */
- channel->key_len = tmp_len * 8;
- channel->key = silc_calloc(tmp_len, sizeof(unsigned char));
- memcpy(channel->key, tmp, tmp_len);
- channel->channel_key->cipher->set_key(channel->channel_key->context,
- tmp, tmp_len);
+ /* Save the channel key */
+ channel = silc_server_save_channel_key(server, buffer, NULL);
+ if (!channel)
+ 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, channel, FALSE);
-
- out:
- if (id)
- silc_free(id);
- if (payload)
- silc_channel_key_payload_free(payload);
+ silc_server_send_channel_key(server, sock, channel, FALSE);
}
/* Received packet to replace a ID. This checks that the requested ID
SilcIdType old_id_type, new_id_type;
unsigned short old_id_len, new_id_len;
void *id = NULL, *id2 = NULL;
+ int ret;
if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
packet->src_id_type == SILC_ID_CLIENT)
SILC_LOG_DEBUG(("Replacing ID"));
- silc_buffer_unformat(buffer,
- SILC_STR_UI_SHORT(&old_id_type),
- SILC_STR_UI16_NSTRING_ALLOC(&old_id, &old_id_len),
- SILC_STR_UI_SHORT(&new_id_type),
- SILC_STR_UI16_NSTRING_ALLOC(&new_id, &new_id_len),
- SILC_STR_END);
+ ret = silc_buffer_unformat(buffer,
+ SILC_STR_UI_SHORT(&old_id_type),
+ SILC_STR_UI16_NSTRING_ALLOC(&old_id, &old_id_len),
+ SILC_STR_UI_SHORT(&new_id_type),
+ SILC_STR_UI16_NSTRING_ALLOC(&new_id, &new_id_len),
+ SILC_STR_END);
+ if (ret == -1)
+ goto out;
if (old_id_type != new_id_type)
goto out;
new_id_len != silc_id_get_len(new_id_type))
goto out;
- id = silc_id_str2id(old_id, old_id_type);
+ id = silc_id_str2id(old_id, old_id_len, old_id_type);
if (!id)
goto out;
- id2 = silc_id_str2id(new_id, new_id_type);
+ id2 = silc_id_str2id(new_id, new_id_len, new_id_type);
if (!id2)
goto out;
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->server_type == SILC_ROUTER &&
+ 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 Replace ID packet"));
/* Replace the old ID */
switch(old_id_type) {
case SILC_ID_CLIENT:
- if (silc_idlist_replace_client_id(server->local_list, id, id2) == NULL)
- if (server->server_type == SILC_ROUTER)
- silc_idlist_replace_client_id(server->global_list, id, id2);
- break;
+ {
+ SilcBuffer nidp, oidp;
+ SilcClientEntry client = NULL;
+
+ SILC_LOG_DEBUG(("Old Client ID id(%s)",
+ silc_id_render(id, SILC_ID_CLIENT)));
+ SILC_LOG_DEBUG(("New Client ID id(%s)",
+ silc_id_render(id2, SILC_ID_CLIENT)));
+
+ if ((client = silc_idlist_replace_client_id(server->local_list,
+ id, id2)) == NULL)
+ if (server->server_type == SILC_ROUTER)
+ client = silc_idlist_replace_client_id(server->global_list, id, id2);
+
+ if (client) {
+ oidp = silc_id_payload_encode(id, SILC_ID_CLIENT);
+ nidp = silc_id_payload_encode(id2, SILC_ID_CLIENT);
+
+ /* Send the NICK_CHANGE notify type to local clients on the channels
+ this client is joined to. */
+ silc_server_send_notify_on_channels(server, client,
+ SILC_NOTIFY_TYPE_NICK_CHANGE, 2,
+ oidp->data, oidp->len,
+ nidp->data, nidp->len);
+
+ silc_buffer_free(nidp);
+ silc_buffer_free(oidp);
+ }
+ break;
+ }
case SILC_ID_SERVER:
+ SILC_LOG_DEBUG(("Old Server ID id(%s)",
+ silc_id_render(id, SILC_ID_CLIENT)));
+ SILC_LOG_DEBUG(("New Server ID id(%s)",
+ silc_id_render(id2, SILC_ID_CLIENT)));
if (silc_idlist_replace_server_id(server->local_list, id, id2) == NULL)
if (server->server_type == SILC_ROUTER)
silc_idlist_replace_server_id(server->global_list, id, id2);
SilcBuffer reply;
SilcIDListData idata;
char *username = NULL, *realname = NULL, *id_string;
+ int ret;
SILC_LOG_DEBUG(("Creating new client"));
}
/* Parse incoming packet */
- silc_buffer_unformat(buffer,
- SILC_STR_UI16_STRING_ALLOC(&username),
- SILC_STR_UI16_STRING_ALLOC(&realname),
- SILC_STR_END);
+ ret = silc_buffer_unformat(buffer,
+ SILC_STR_UI16_STRING_ALLOC(&username),
+ SILC_STR_UI16_STRING_ALLOC(&realname),
+ SILC_STR_END);
+ if (ret == -1) {
+ if (username)
+ silc_free(username);
+ if (realname)
+ silc_free(realname);
+ return NULL;
+ }
/* Create Client ID */
silc_id_create_client_id(server->id, server->rng, server->md5hash,
("Your host is %s, running version %s",
server->config->server_info->server_name,
server_version));
+ if (server->server_type == SILC_ROUTER) {
+ SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
+ ("There are %d clients on %d servers in SILC "
+ "Network", server->stat.clients,
+ server->stat.servers + 1));
+ SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
+ ("There are %d clients on %d server in our cell",
+ server->stat.cell_clients,
+ server->stat.cell_servers));
+ SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
+ ("I have %d clients, %d channels, %d servers and "
+ "%d routers",
+ server->stat.my_clients,
+ server->stat.my_channels,
+ server->stat.my_servers,
+ server->stat.my_routers));
+ SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
+ ("%d server operators and %d router operators "
+ "online",
+ server->stat.my_server_ops,
+ server->stat.my_router_ops));
+ } else {
+ SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
+ ("I have %d clients and %d channels formed",
+ server->stat.my_clients,
+ server->stat.my_channels));
+ SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
+ ("%d operators online",
+ server->stat.my_server_ops));
+ }
SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
("Your connection is secured with %s cipher, "
"key length %d bits",
SilcIDListData idata;
unsigned char *server_name, *id_string;
unsigned short id_len;
+ int ret;
SILC_LOG_DEBUG(("Creating new server"));
}
/* Parse the incoming packet */
- silc_buffer_unformat(buffer,
- SILC_STR_UI16_NSTRING_ALLOC(&id_string, &id_len),
- SILC_STR_UI16_STRING_ALLOC(&server_name),
- SILC_STR_END);
+ ret = silc_buffer_unformat(buffer,
+ SILC_STR_UI16_NSTRING_ALLOC(&id_string, &id_len),
+ SILC_STR_UI16_STRING_ALLOC(&server_name),
+ SILC_STR_END);
+ if (ret == -1) {
+ if (id_string)
+ silc_free(id_string);
+ if (server_name)
+ silc_free(server_name);
+ return NULL;
+ }
if (id_len > buffer->len) {
silc_free(id_string);
}
/* Get Server ID */
- server_id = silc_id_str2id(id_string, SILC_ID_SERVER);
+ server_id = silc_id_str2id(id_string, id_len, SILC_ID_SERVER);
+ if (!server_id) {
+ silc_free(id_string);
+ silc_free(server_name);
+ return NULL;
+ }
silc_free(id_string);
/* Update client entry */
TRUE, new_server->id, SILC_ID_SERVER,
SILC_ID_SERVER_LEN);
+ if (server->server_type == SILC_ROUTER)
+ server->stat.cell_servers++;
+
return new_server;
}
{
SilcBuffer buffer = packet->buffer;
SilcIDList id_list;
- SilcServerEntry tmpserver, router;
+ SilcServerEntry router;
SilcSocketConnection router_sock;
SilcIDPayload idp;
SilcIdType id_type;
- void *id, *tmpid;
+ unsigned char *hash = NULL;
+ void *id;
SILC_LOG_DEBUG(("Processing new ID"));
buffer->data, buffer->len, FALSE);
}
-#if 0
- /* If the packet is originated from the one who sent it to us we know
- that the ID belongs to our cell, unless the sender was router. */
- tmpid = silc_id_str2id(packet->src_id, SILC_ID_SERVER);
- tmpserver = (SilcServerEntry)sock->user_data;
-
- if (!SILC_ID_SERVER_COMPARE(tmpid, tmpserver->id) &&
- sock->type == SILC_SOCKET_TYPE_SERVER) {
- id_list = server->local_list;
- router_sock = sock;
- router = sock->user_data;
- /* router = server->id_entry; */
- } else {
- id_list = server->global_list;
- router_sock = (SilcSocketConnection)server->router->connection;
- router = server->router;
- }
-
- silc_free(tmpid);
-#endif
-
if (sock->type == SILC_SOCKET_TYPE_SERVER)
id_list = server->local_list;
else
switch(id_type) {
case SILC_ID_CLIENT:
- 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));
+ {
+ SilcClientEntry entry;
+
+ 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));
- /* Add the client to our local list. We are router and we keep
- cell specific local database of all clients in the cell. */
- silc_idlist_add_client(id_list, NULL, NULL, NULL, id, router, router_sock);
+ /* As a router we keep information of all global information in our
+ global list. Cell wide information however is kept in the local
+ list. The client is put to global list and we will take the hash
+ value of the Client ID and save it to the ID Cache system for fast
+ searching in the future. */
+ hash = silc_calloc(sizeof(((SilcClientID *)id)->hash),
+ sizeof(unsigned char));
+ memcpy(hash, ((SilcClientID *)id)->hash,
+ sizeof(((SilcClientID *)id)->hash));
+ entry = silc_idlist_add_client(id_list, hash, NULL, NULL, id,
+ router, router_sock);
+ entry->nickname = NULL;
+
+ if (sock->type == SILC_SOCKET_TYPE_SERVER)
+ server->stat.cell_clients++;
+ server->stat.clients++;
- /* Add route cache for this ID */
- silc_server_route_add(silc_server_route_hash(
- ((SilcClientID *)id)->ip.s_addr,
- server->id->port), ((SilcClientID *)id)->ip.s_addr,
- router);
+#if 0
+ /* XXX Adding two ID's with same IP number replaces the old entry thus
+ gives wrong route. Thus, now disabled until figured out a better way
+ to do this or when removed the whole thing. This could be removed
+ because entry->router->connection gives always the most optimal route
+ for the ID anyway (unless new routes (faster perhaps) are established
+ after receiving this ID, this we don't know however). */
+ /* Add route cache for this ID */
+ silc_server_route_add(silc_server_route_hash(
+ ((SilcClientID *)id)->ip.s_addr,
+ server->id->port), ((SilcClientID *)id)->ip.s_addr,
+ router);
+#endif
+ }
break;
case SILC_ID_SERVER:
sock->type == SILC_SOCKET_TYPE_SERVER ?
"Server" : "Router", sock->hostname));
- /* Add the server to our local list. We are router and we keep
- cell specific local database of all servers in the cell. */
+ /* As a router we keep information of all global information in our global
+ list. Cell wide information however is kept in the local list. */
silc_idlist_add_server(id_list, NULL, 0, id, router, router_sock);
+ if (sock->type == SILC_SOCKET_TYPE_SERVER)
+ server->stat.cell_servers++;
+ server->stat.servers++;
+
+#if 0
/* Add route cache for this ID */
silc_server_route_add(silc_server_route_hash(
((SilcServerID *)id)->ip.s_addr,
((SilcServerID *)id)->port),
((SilcServerID *)id)->ip.s_addr,
router);
+#endif
break;
case SILC_ID_CHANNEL:
/* Received Remove Channel User packet to remove a user from a channel.
Routers notify other routers that user has left a channel. Client must
- not send this packet.. Normal server may send this packet but must not
+ not send this packet. Normal server may send this packet but must not
receive it. */
void silc_server_remove_channel_user(SilcServer server,
{
SilcBuffer buffer = packet->buffer;
unsigned char *tmp1 = NULL, *tmp2 = NULL;
+ unsigned int tmp1_len, tmp2_len;
SilcClientID *client_id = NULL;
SilcChannelID *channel_id = NULL;
SilcChannelEntry channel;
SilcClientEntry client;
+ int ret;
SILC_LOG_DEBUG(("Removing user from channel"));
server->server_type == SILC_SERVER)
return;
- silc_buffer_unformat(buffer,
- SILC_STR_UI16_STRING_ALLOC(&tmp1),
- SILC_STR_UI16_STRING_ALLOC(&tmp2),
- SILC_STR_END);
-
- if (!tmp1 || !tmp2)
+ ret = silc_buffer_unformat(buffer,
+ SILC_STR_UI16_NSTRING_ALLOC(&tmp1, &tmp1_len),
+ SILC_STR_UI16_NSTRING_ALLOC(&tmp2, &tmp2_len),
+ SILC_STR_END);
+ if (ret == -1)
goto out;
- client_id = silc_id_str2id(tmp1, SILC_ID_CLIENT);
- channel_id = silc_id_str2id(tmp2, SILC_ID_CHANNEL);
+ client_id = silc_id_str2id(tmp1, tmp1_len, SILC_ID_CLIENT);
+ channel_id = silc_id_str2id(tmp2, tmp2_len, SILC_ID_CHANNEL);
if (!client_id || !channel_id)
goto out;
buffer->data, buffer->len, FALSE);
}
- /* XXX routers should check server->global_list as well */
/* Get channel entry */
- channel = silc_idlist_find_channel_by_id(server->local_list, channel_id);
- if (!channel)
- goto out;
-
- /* XXX routers should check server->global_list as well */
+ channel = silc_idlist_find_channel_by_id(server->local_list,
+ channel_id, NULL);
+ if (!channel) {
+ channel = silc_idlist_find_channel_by_id(server->global_list,
+ channel_id, NULL);
+ if (!channel)
+ goto out;
+ }
+
/* Get client entry */
- client = silc_idlist_find_client_by_id(server->local_list, client_id);
- if (!client)
- goto out;
+ client = silc_idlist_find_client_by_id(server->local_list, client_id, NULL);
+ if (!client) {
+ client = silc_idlist_find_client_by_id(server->global_list,
+ client_id, NULL);
+ if (!client)
+ goto out;
+ }
- /* Remove from channel */
- silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
+ /* Remove user from channel */
+ silc_server_remove_from_one_channel(server, sock, channel, client, TRUE);
out:
if (tmp1)
SilcChannelID *channel_id;
unsigned short channel_id_len;
char *channel_name;
+ int ret;
SILC_LOG_DEBUG(("Processing New Channel"));
return;
/* Parse payload */
- if (!silc_buffer_unformat(packet->buffer,
- SILC_STR_UI16_STRING_ALLOC(&channel_name),
- SILC_STR_UI16_NSTRING_ALLOC(&id, &channel_id_len),
- SILC_STR_END))
+ ret = silc_buffer_unformat(packet->buffer,
+ SILC_STR_UI16_STRING_ALLOC(&channel_name),
+ SILC_STR_UI16_NSTRING_ALLOC(&id, &channel_id_len),
+ SILC_STR_END);
+ if (ret == -1) {
+ if (channel_name)
+ silc_free(channel_name);
+ if (id)
+ silc_free(id);
return;
+ }
- if (!channel_name || !id)
- return;
-
/* Decode the channel ID */
- channel_id = silc_id_str2id(id, SILC_ID_CHANNEL);
+ channel_id = silc_id_str2id(id, channel_id_len, SILC_ID_CHANNEL);
if (!channel_id)
return;
silc_free(id);
router hence global channel. */
silc_idlist_add_channel(server->global_list, channel_name, 0, channel_id,
server->router->connection, NULL);
+
+ server->stat.channels++;
}
/* Received notify packet. Server can receive notify packets from router.
SilcNotifyType type;
SilcArgumentPayload args;
SilcChannelID *channel_id;
+ SilcClientID *client_id, *client_id2;
SilcChannelEntry channel;
+ SilcClientEntry client;
+ unsigned char *tmp;
+ unsigned int tmp_len;
SILC_LOG_DEBUG(("Start"));
/*
* Distribute the notify to local clients on the channel
*/
+ SILC_LOG_DEBUG(("JOIN notify"));
- channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_type);
+ channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
+ packet->dst_id_type);
if (!channel_id)
goto out;
/* Get channel entry */
- channel = silc_idlist_find_channel_by_id(server->local_list, channel_id);
+ channel = silc_idlist_find_channel_by_id(server->local_list,
+ channel_id, NULL);
if (!channel) {
silc_free(channel_id);
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);
+ if (!client_id) {
+ silc_free(channel_id);
+ goto out;
+ }
+
/* Send to channel */
- silc_server_packet_send_to_channel(server, channel, packet->type, FALSE,
- packet->buffer->data,
+ silc_server_packet_send_to_channel(server, NULL, channel, packet->type,
+ FALSE, packet->buffer->data,
packet->buffer->len, FALSE);
+
+ /* 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->local_list,
+ client_id, NULL);
+ if (!client) {
+ SilcChannelClientEntry chl;
+
+ client = silc_idlist_find_client_by_id(server->global_list,
+ client_id, NULL);
+ if (!client) {
+ client = silc_idlist_add_client(server->global_list, NULL, NULL, NULL,
+ client_id, sock->user_data, sock);
+ if (!client) {
+ silc_free(channel_id);
+ silc_free(client_id);
+ goto out;
+ }
+ }
+
+ /* The channel is global now */
+ channel->global_users = TRUE;
+
+ /* Now actually JOIN the global client to the channel */
+ chl = silc_calloc(1, sizeof(*chl));
+ chl->client = client;
+ chl->channel = channel;
+ silc_list_add(channel->user_list, chl);
+ silc_list_add(client->channels, chl);
+ } else {
+ silc_free(client_id);
+ }
break;
case SILC_NOTIFY_TYPE_LEAVE:
+ /*
+ * Distribute the notify to local clients on the channel
+ */
+ SILC_LOG_DEBUG(("LEAVE notify"));
+
+ channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
+ packet->dst_id_type);
+ if (!channel_id)
+ goto out;
+
+ /* Get channel entry */
+ channel = silc_idlist_find_channel_by_id(server->local_list,
+ channel_id, NULL);
+ if (!channel) {
+ silc_free(channel_id);
+ 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);
+ if (!client_id) {
+ silc_free(channel_id);
+ goto out;
+ }
+
+ /* Send to channel */
+ silc_server_packet_send_to_channel(server, NULL, channel, packet->type,
+ FALSE, packet->buffer->data,
+ packet->buffer->len, FALSE);
+
+ /* Get client entry */
+ client = silc_idlist_find_client_by_id(server->global_list,
+ client_id, NULL);
+ if (!client) {
+ client = silc_idlist_find_client_by_id(server->local_list,
+ client_id, NULL);
+ if (!client) {
+ silc_free(client_id);
+ silc_free(channel_id);
+ goto out;
+ }
+ }
+ silc_free(client_id);
+
+ /* 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);
+ if (!client_id)
+ goto out;
+
+ /* Get client entry */
+ client = silc_idlist_find_client_by_id(server->global_list,
+ client_id, NULL);
+ if (!client) {
+ client = silc_idlist_find_client_by_id(server->local_list,
+ client_id, NULL);
+ if (!client) {
+ silc_free(client_id);
+ goto out;
+ }
+ }
+ silc_free(client_id);
+
+ /* Remove the client from all channels */
+ silc_server_remove_from_channels(server, NULL, client);
+
+ /* Remove the client entry */
+ silc_idlist_del_client(server->global_list, client);
break;
- /* Ignore rest notify types for now */
- case SILC_NOTIFY_TYPE_NONE:
- case SILC_NOTIFY_TYPE_INVITE:
+ case SILC_NOTIFY_TYPE_NICK_CHANGE:
+ {
+ /*
+ * Distribute the notify to local clients on the channel
+ */
+ unsigned char *id, *id2;
+
+ 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);
+ if (!client_id)
+ 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);
+ if (!client_id2)
+ 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)));
+
+ /* Replace the Client ID */
+ client = silc_idlist_replace_client_id(server->global_list, client_id,
+ client_id2);
+ if (!client)
+ client = silc_idlist_replace_client_id(server->local_list, client_id,
+ client_id2);
+
+ if (client)
+ /* Send the NICK_CHANGE notify type to local clients on the channels
+ this client is joined to. */
+ silc_server_send_notify_on_channels(server, client,
+ SILC_NOTIFY_TYPE_NICK_CHANGE, 2,
+ id, tmp_len,
+ id2, tmp_len);
+
+ silc_free(client_id);
+ if (!client)
+ silc_free(client_id2);
+ break;
+ }
case SILC_NOTIFY_TYPE_TOPIC_SET:
+ /*
+ * Distribute the notify to local clients on the channel
+ */
+ SILC_LOG_DEBUG(("TOPIC SET notify (not-impl XXX)"));
+ break;
+
case SILC_NOTIFY_TYPE_CMODE_CHANGE:
+ /*
+ * Distribute the notify to local clients on the channel
+ */
+ SILC_LOG_DEBUG(("CMODE CHANGE notify (not-impl XXX)"));
+ break;
+
case SILC_NOTIFY_TYPE_CUMODE_CHANGE:
+ /*
+ * Distribute the notify to local clients on the channel
+ */
+ SILC_LOG_DEBUG(("CUMODE CHANGE notify (not-impl XXX)"));
+ break;
+
+ /* Ignore rest notify types for now */
+ case SILC_NOTIFY_TYPE_NONE:
+ case SILC_NOTIFY_TYPE_INVITE:
case SILC_NOTIFY_TYPE_MOTD:
default:
break;
SilcClientEntry client;
SilcChannelEntry channel;
SilcChannelClientEntry chl;
- SilcIDList id_list;
- SilcServerEntry tmpserver, router;
- SilcSocketConnection router_sock;
SilcBuffer clidp;
- void *tmpid;
+ int ret;
SILC_LOG_DEBUG(("Start"));
return;
/* Parse payload */
- if (!silc_buffer_unformat(packet->buffer,
- SILC_STR_UI16_NSTRING_ALLOC(&tmpid1,
- &channel_id_len),
- SILC_STR_UI16_NSTRING_ALLOC(&tmpid2,
- &client_id_len),
- SILC_STR_END))
- return;
-
- if (!tmpid1 || !tmpid2)
+ ret = silc_buffer_unformat(packet->buffer,
+ SILC_STR_UI16_NSTRING_ALLOC(&tmpid1,
+ &channel_id_len),
+ SILC_STR_UI16_NSTRING_ALLOC(&tmpid2,
+ &client_id_len),
+ SILC_STR_END);
+ if (ret == -1) {
+ if (tmpid1)
+ silc_free(tmpid1);
+ if (tmpid2)
+ silc_free(tmpid2);
return;
+ }
/* Decode the channel ID */
- channel_id = silc_id_str2id(tmpid1, SILC_ID_CHANNEL);
+ channel_id = silc_id_str2id(tmpid1, channel_id_len, SILC_ID_CHANNEL);
if (!channel_id)
goto out;
/* Decode the client ID */
- client_id = silc_id_str2id(tmpid1, SILC_ID_CLIENT);
+ client_id = silc_id_str2id(tmpid2, client_id_len, SILC_ID_CLIENT);
if (!client_id)
goto out;
- /* If the packet is originated from the one who sent it to us we know
- that the ID belongs to our cell, unless the sender was router. */
- tmpid = silc_id_str2id(packet->src_id, SILC_ID_SERVER);
- tmpserver = (SilcServerEntry)sock->user_data;
-
- if (!SILC_ID_SERVER_COMPARE(tmpid, tmpserver->id) &&
- sock->type == SILC_SOCKET_TYPE_SERVER) {
- id_list = server->local_list;
- router_sock = sock;
- router = sock->user_data;
- } else {
- id_list = server->global_list;
- router_sock = (SilcSocketConnection)server->router->connection;
- router = server->router;
- }
- silc_free(tmpid);
-
/* Find the channel */
- channel = silc_idlist_find_channel_by_id(id_list, channel_id);
+ channel = silc_idlist_find_channel_by_id(server->local_list,
+ channel_id, NULL);
if (!channel) {
- SILC_LOG_ERROR(("Received channel user for non-existent channel"));
- goto out;
+ channel = silc_idlist_find_channel_by_id(server->global_list,
+ channel_id, NULL);
+ if (!channel)
+ goto out;
}
/* If we are router and this packet is not already broadcast packet
}
/* Get client entry */
- client = silc_idlist_find_client_by_id(id_list, client_id);
+ client = silc_idlist_find_client_by_id(server->local_list, client_id, NULL);
if (!client) {
- /* This is new client to us, add entry to ID list */
- client = silc_idlist_add_client(id_list, NULL, NULL, NULL,
- client_id, router, router_sock);
+ client = silc_idlist_find_client_by_id(server->global_list,
+ client_id, NULL);
if (!client)
goto out;
}
silc_list_add(channel->user_list, chl);
silc_list_add(client->channels, chl);
+ server->stat.chanclients++;
+
/* Send JOIN notify to local clients on the channel. As we are router
it is assured that this is sent only to our local clients and locally
connected servers if needed. */
clidp = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
- silc_server_send_notify_to_channel(server, channel, FALSE,
+ silc_server_send_notify_to_channel(server, sock, channel, FALSE,
SILC_NOTIFY_TYPE_JOIN,
1, clidp->data, clidp->len);
silc_buffer_free(clidp);
silc_free(tmpid1);
silc_free(tmpid2);
}
+
+/* Processes incoming REMOVE_ID packet. The packet is used to notify routers
+ that certain ID should be removed. After that the ID will become invalid. */
+
+void silc_server_remove_id(SilcServer server,
+ SilcSocketConnection sock,
+ SilcPacketContext *packet)
+{
+ SilcIDList id_list;
+ SilcIDPayload idp;
+ SilcIdType id_type;
+ void *id, *id_entry;
+
+ SILC_LOG_DEBUG(("Start"));
+
+ if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
+ server->server_type == SILC_SERVER ||
+ packet->src_id_type != SILC_ID_SERVER)
+ return;
+
+ idp = silc_id_payload_parse(packet->buffer);
+ if (!idp)
+ return;
+
+ id_type = silc_id_payload_get_type(idp);
+
+ id = silc_id_payload_get_id(idp);
+ if (!id)
+ goto out;
+
+ /* 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 Remove ID packet"));
+ silc_server_packet_send(server, server->router->connection,
+ packet->type,
+ packet->flags | SILC_PACKET_FLAG_BROADCAST,
+ packet->buffer->data, packet->buffer->len, FALSE);
+ }
+
+ if (sock->type == SILC_SOCKET_TYPE_SERVER)
+ id_list = server->local_list;
+ else
+ id_list = server->global_list;
+
+ /* Remove the ID */
+ switch (id_type) {
+ case SILC_ID_CLIENT:
+ id_entry = silc_idlist_find_client_by_id(id_list, (SilcClientID *)id,
+ NULL);
+ if (id_entry) {
+ /* Remove from channels */
+ silc_server_remove_from_channels(server, NULL, id_entry);
+
+ /* Remove the client entry */
+ silc_idlist_del_client(id_list, (SilcClientEntry)id_entry);
+ server->stat.clients--;
+
+ SILC_LOG_DEBUG(("Removed client id(%s) from [%s] %s",
+ silc_id_render(id, SILC_ID_CLIENT),
+ sock->type == SILC_SOCKET_TYPE_SERVER ?
+ "Server" : "Router", sock->hostname));
+ }
+ break;
+
+ case SILC_ID_SERVER:
+ id_entry = silc_idlist_find_server_by_id(id_list, (SilcServerID *)id,
+ NULL);
+ if (id_entry) {
+ silc_idlist_del_server(id_list, (SilcServerEntry)id_entry);
+ server->stat.servers--;
+
+ SILC_LOG_DEBUG(("Removed server id(%s) from [%s] %s",
+ silc_id_render(id, SILC_ID_SERVER),
+ sock->type == SILC_SOCKET_TYPE_SERVER ?
+ "Server" : "Router", sock->hostname));
+ }
+ break;
+
+ case SILC_ID_CHANNEL:
+ id_entry = silc_idlist_find_channel_by_id(id_list, (SilcChannelID *)id,
+ NULL);
+ if (id_entry) {
+ silc_idlist_del_channel(id_list, (SilcChannelEntry)id_entry);
+ server->stat.channels--;
+
+ SILC_LOG_DEBUG(("Removed channel id(%s) from [%s] %s",
+ silc_id_render(id, SILC_ID_CHANNEL),
+ sock->type == SILC_SOCKET_TYPE_SERVER ?
+ "Server" : "Router", sock->hostname));
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ out:
+ silc_id_payload_free(idp);
+}
+
+/* Processes received SET_MODE packet. The packet is used to distribute
+ the information about changed channel's or client's channel modes. */
+
+void silc_server_set_mode(SilcServer server,
+ SilcSocketConnection sock,
+ SilcPacketContext *packet)
+{
+ SilcSetModePayload payload = NULL;
+ SilcArgumentPayload args = NULL;
+ unsigned short mode_type;
+ unsigned int mode_mask;
+ unsigned char *tmp, *tmp2;
+ unsigned int tmp_len, tmp_len2;
+ unsigned char mode[4];
+ SilcClientID *client_id;
+ SilcChannelID *channel_id = NULL;
+ SilcClientEntry client;
+ SilcChannelEntry channel;
+ SilcChannelClientEntry chl;
+
+ if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
+ packet->src_id_type == SILC_ID_CLIENT)
+ return;
+
+ SILC_LOG_DEBUG(("Start"));
+
+ /* 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 &&
+ !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
+ SILC_LOG_DEBUG(("Broadcasting received Set Mode packet"));
+ silc_server_packet_send(server, server->router->connection, packet->type,
+ packet->flags | SILC_PACKET_FLAG_BROADCAST,
+ packet->buffer->data, packet->buffer->len, FALSE);
+ }
+
+ /* Parse Set Mode payload */
+ payload = silc_set_mode_payload_parse(packet->buffer);
+ if (!payload)
+ return;
+
+ mode_type = silc_set_mode_get_type(payload);
+ args = silc_set_mode_get_args(payload);
+ if (!args)
+ goto out;
+
+ mode_mask = silc_set_mode_get_mode(payload);
+ SILC_PUT32_MSB(mode_mask, mode);
+
+ switch (mode_type) {
+ case SILC_MODE_TYPE_CHANNEL:
+ /* 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);
+ if (!channel_id)
+ goto out;
+
+ /* Get channel entry */
+ channel = silc_idlist_find_channel_by_id(server->local_list,
+ channel_id, NULL);
+ if (!channel) {
+ channel = silc_idlist_find_channel_by_id(server->global_list,
+ channel_id, NULL);
+ if (!channel)
+ goto out;
+ }
+
+ /* Get Client ID payload */
+ tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
+ if (!tmp)
+ goto out;
+
+ /* Send CMODE_CHANGE notify to local channel */
+ silc_server_send_notify_to_channel(server, sock, channel, FALSE,
+ SILC_NOTIFY_TYPE_CMODE_CHANGE,
+ 2, tmp, tmp_len,
+ mode, sizeof(mode));
+
+ /* Change the mode */
+ channel->mode = mode_mask;
+ break;
+
+ case SILC_MODE_TYPE_UCHANNEL:
+ /* 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);
+ if (!channel_id)
+ goto out;
+
+ /* Get channel entry */
+ channel = silc_idlist_find_channel_by_id(server->local_list,
+ channel_id, NULL);
+ if (!channel) {
+ channel = silc_idlist_find_channel_by_id(server->global_list,
+ channel_id, NULL);
+ if (!channel)
+ goto out;
+ }
+
+ /* Get Client ID payload */
+ tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
+ if (!tmp)
+ goto out;
+
+ /* Get target Client ID */
+ tmp2 = silc_argument_get_arg_type(args, 3, &tmp_len2);
+ if (!tmp2)
+ goto out;
+ client_id = silc_id_payload_parse_id(tmp2, tmp_len2);
+ if (!client_id)
+ goto out;
+
+ /* Get target client entry */
+ client = silc_idlist_find_client_by_id(server->global_list,
+ client_id, NULL);
+ if (!client) {
+ client = silc_idlist_find_client_by_id(server->local_list,
+ client_id, NULL);
+ if (!client) {
+ silc_free(client_id);
+ goto out;
+ }
+ }
+ silc_free(client_id);
+
+ /* Send CUMODE_CHANGE notify to local channel */
+ silc_server_send_notify_to_channel(server, sock, channel, FALSE,
+ SILC_NOTIFY_TYPE_CUMODE_CHANGE, 2,
+ tmp, tmp_len,
+ mode, sizeof(mode),
+ tmp2, tmp_len2);
+
+ /* Get entry to the channel user list */
+ silc_list_start(channel->user_list);
+ while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END)
+ if (chl->client == client) {
+ /* Change the mode */
+ chl->mode = mode_mask;
+ break;
+ }
+
+ break;
+
+ default:
+ break;
+ }
+
+ out:
+ if (channel_id)
+ silc_free(channel_id);
+ if (args)
+ silc_argument_payload_free(args);
+ if (payload)
+ silc_set_mode_payload_free(payload);
+}
projects / silc.git / blobdiff