5 Author: Pekka Riikonen <priikone@silcnet.org>
7 Copyright (C) 1997 - 2002 Pekka Riikonen
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
21 * Server packet routines to handle received packets.
25 #include "serverincludes.h"
26 #include "server_internal.h"
28 /* Received notify packet. Server can receive notify packets from router.
29 Server then relays the notify messages to clients if needed. */
31 void silc_server_notify(SilcServer server,
32 SilcSocketConnection sock,
33 SilcPacketContext *packet)
35 SilcNotifyPayload payload;
37 SilcArgumentPayload args;
38 SilcChannelID *channel_id = NULL, *channel_id2;
39 SilcClientID *client_id, *client_id2;
40 SilcServerID *server_id;
42 SilcChannelEntry channel = NULL;
43 SilcClientEntry client = NULL, client2 = NULL;
44 SilcServerEntry server_entry = NULL;
45 SilcChannelClientEntry chl;
46 SilcIDCacheEntry cache = NULL;
47 SilcHashTableList htl;
53 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
54 packet->src_id_type != SILC_ID_SERVER || !packet->dst_id) {
55 SILC_LOG_DEBUG(("Bad notify packet received"));
59 /* If the packet is destined directly to a client then relay the packet
60 before processing it. */
61 if (packet->dst_id_type == SILC_ID_CLIENT) {
63 SilcSocketConnection dst_sock;
65 /* Get the route to the client */
66 dst_sock = silc_server_get_client_route(server, packet->dst_id,
67 packet->dst_id_len, NULL,
70 /* Relay the packet */
71 silc_server_relay_packet(server, dst_sock, idata->send_key,
72 idata->hmac_send, idata->psn_send++,
76 /* Parse the Notify Payload */
77 payload = silc_notify_payload_parse(packet->buffer->data,
82 /* If we are router and this packet is not already broadcast packet
83 we will broadcast it. The sending socket really cannot be router or
84 the router is buggy. If this packet is coming from router then it must
85 have the broadcast flag set already and we won't do anything. */
86 if (server->server_type == SILC_ROUTER &&
87 sock->type == SILC_SOCKET_TYPE_SERVER &&
88 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
89 SILC_LOG_DEBUG(("Broadcasting received Notify packet"));
90 if (packet->dst_id_type == SILC_ID_CHANNEL) {
91 /* Packet is destined to channel */
92 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
97 silc_server_packet_send_dest(server, SILC_PRIMARY_ROUTE(server),
98 packet->type, packet->flags |
99 SILC_PACKET_FLAG_BROADCAST,
100 channel_id, SILC_ID_CHANNEL,
101 packet->buffer->data,
102 packet->buffer->len, FALSE);
103 silc_server_backup_send_dest(server, sock->user_data,
104 packet->type, packet->flags,
105 channel_id, SILC_ID_CHANNEL,
106 packet->buffer->data, packet->buffer->len,
109 /* Packet is destined to client or server */
110 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
112 packet->flags | SILC_PACKET_FLAG_BROADCAST,
113 packet->buffer->data, packet->buffer->len,
115 silc_server_backup_send(server, sock->user_data,
116 packet->type, packet->flags,
117 packet->buffer->data, packet->buffer->len,
122 type = silc_notify_get_type(payload);
123 args = silc_notify_get_args(payload);
128 case SILC_NOTIFY_TYPE_JOIN:
130 * Distribute the notify to local clients on the channel
132 SILC_LOG_DEBUG(("JOIN notify"));
135 silc_free(channel_id);
138 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
141 channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
145 /* Get channel entry */
146 channel = silc_idlist_find_channel_by_id(server->global_list,
149 channel = silc_idlist_find_channel_by_id(server->local_list,
152 SILC_LOG_DEBUG(("Notify for unknown channel"));
153 silc_free(channel_id);
157 silc_free(channel_id);
160 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
163 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
167 /* If the the client is not in local list we check global list (ie. the
168 channel will be global channel) and if it does not exist then create
169 entry for the client. */
170 client = silc_idlist_find_client_by_id(server->global_list,
171 client_id, server->server_type,
174 client = silc_idlist_find_client_by_id(server->local_list,
175 client_id, server->server_type,
178 /* If router did not find the client the it is bogus */
179 if (server->server_type != SILC_SERVER) {
180 silc_free(client_id);
185 silc_idlist_add_client(server->global_list, NULL, NULL, NULL,
186 silc_id_dup(client_id, SILC_ID_CLIENT),
187 sock->user_data, NULL, 0);
189 SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
190 silc_free(client_id);
194 client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
197 silc_free(client_id);
199 /* Do not process the notify if the client is not registered */
200 if (!(client->data.status & SILC_IDLIST_STATUS_REGISTERED))
203 /* Do not add client to channel if it is there already */
204 if (silc_server_client_on_channel(client, channel, NULL)) {
205 SILC_LOG_DEBUG(("Client already on channel %s",
206 channel->channel_name));
210 /* Send to channel */
211 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
212 FALSE, packet->buffer->data,
213 packet->buffer->len, FALSE);
215 if (server->server_type != SILC_ROUTER &&
216 sock->type == SILC_SOCKET_TYPE_ROUTER)
217 /* The channel is global now */
218 channel->global_users = TRUE;
220 SILC_LOG_DEBUG(("Joining to channel %s", channel->channel_name));
222 /* JOIN the global client to the channel (local clients (if router
223 created the channel) is joined in the pending JOIN command). */
224 chl = silc_calloc(1, sizeof(*chl));
225 chl->client = client;
226 chl->channel = channel;
228 if (server->server_type != SILC_ROUTER ||
229 sock->type == SILC_SOCKET_TYPE_ROUTER) {
230 /* If this is the first one on the channel then it is the founder of
231 the channel. This is done on normal server and on router if this
232 notify is coming from router */
233 if (!silc_hash_table_count(channel->user_list)) {
234 SILC_LOG_DEBUG(("Client %s is founder on channel",
235 silc_id_render(chl->client->id, SILC_ID_CLIENT)));
236 chl->mode = (SILC_CHANNEL_UMODE_CHANOP | SILC_CHANNEL_UMODE_CHANFO);
240 silc_hash_table_add(channel->user_list, client, chl);
241 silc_hash_table_add(client->channels, channel, chl);
242 channel->user_count++;
243 channel->disabled = FALSE;
245 /* Make sure we don't expire clients that are on channel */
249 /* Update statistics */
250 if (server->server_type == SILC_ROUTER) {
251 if (sock->type != SILC_SOCKET_TYPE_ROUTER)
252 server->stat.cell_chanclients++;
253 server->stat.chanclients++;
258 case SILC_NOTIFY_TYPE_LEAVE:
260 * Distribute the notify to local clients on the channel
262 SILC_LOG_DEBUG(("LEAVE notify"));
265 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
266 packet->dst_id_type);
271 /* Get channel entry */
272 channel = silc_idlist_find_channel_by_id(server->global_list,
275 channel = silc_idlist_find_channel_by_id(server->local_list,
278 SILC_LOG_DEBUG(("Notify for unknown channel"));
279 silc_free(channel_id);
285 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
287 silc_free(channel_id);
290 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
292 silc_free(channel_id);
296 /* Get client entry */
297 client = silc_idlist_find_client_by_id(server->global_list,
298 client_id, TRUE, NULL);
300 client = silc_idlist_find_client_by_id(server->local_list,
301 client_id, TRUE, NULL);
303 silc_free(client_id);
304 silc_free(channel_id);
308 silc_free(client_id);
309 silc_free(channel_id);
311 /* Check if on channel */
312 if (!silc_server_client_on_channel(client, channel, NULL))
315 /* Send the leave notify to channel */
316 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
317 FALSE, packet->buffer->data,
318 packet->buffer->len, FALSE);
320 /* Remove the user from channel */
321 silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
324 case SILC_NOTIFY_TYPE_SIGNOFF:
326 * Distribute the notify to local clients on the channel
328 SILC_LOG_DEBUG(("SIGNOFF notify"));
331 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
334 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
338 /* Get client entry */
339 client = silc_idlist_find_client_by_id(server->global_list,
340 client_id, TRUE, &cache);
342 client = silc_idlist_find_client_by_id(server->local_list,
343 client_id, TRUE, &cache);
345 silc_free(client_id);
349 silc_free(client_id);
351 /* Get signoff message */
352 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
356 /* Update statistics */
357 server->stat.clients--;
358 if (server->stat.cell_clients)
359 server->stat.cell_clients--;
360 SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
361 SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
362 silc_schedule_task_del_by_context(server->schedule, client);
364 /* Remove the client from all channels. */
365 silc_server_remove_from_channels(server, NULL, client, TRUE,
368 /* Check if anyone is watching this nickname */
369 if (server->server_type == SILC_ROUTER)
370 silc_server_check_watcher_list(server, client, NULL,
371 SILC_NOTIFY_TYPE_SIGNOFF);
373 /* Remove this client from watcher list if it is */
374 silc_server_del_from_watcher_list(server, client);
376 client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
377 cache->expire = SILC_ID_CACHE_EXPIRE_DEF;
380 case SILC_NOTIFY_TYPE_TOPIC_SET:
382 * Distribute the notify to local clients on the channel
385 SILC_LOG_DEBUG(("TOPIC SET notify"));
388 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
391 client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
395 /* Get client entry */
396 if (id_type == SILC_ID_CLIENT) {
397 client = silc_idlist_find_client_by_id(server->global_list,
398 client_id, TRUE, &cache);
400 client = silc_idlist_find_client_by_id(server->local_list,
401 client_id, TRUE, &cache);
403 silc_free(client_id);
407 silc_free(client_id);
411 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
413 silc_free(channel_id);
418 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
419 packet->dst_id_type);
424 /* Get channel entry */
425 channel = silc_idlist_find_channel_by_id(server->global_list,
428 channel = silc_idlist_find_channel_by_id(server->local_list,
431 SILC_LOG_DEBUG(("Notify for unknown channel"));
432 silc_free(channel_id);
436 silc_free(channel_id);
438 if (channel->topic && !strcmp(channel->topic, tmp)) {
439 SILC_LOG_DEBUG(("Topic is already set and same"));
444 /* Get user's channel entry and check that topic set is allowed. */
445 if (!silc_server_client_on_channel(client, channel, &chl))
447 if (channel->mode & SILC_CHANNEL_MODE_TOPIC &&
448 !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
449 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
450 SILC_LOG_DEBUG(("Topic change is not allowed"));
455 /* Change the topic */
456 silc_free(channel->topic);
457 channel->topic = strdup(tmp);
459 /* Send the same notify to the channel */
460 silc_server_packet_send_to_channel(server, NULL, channel, packet->type,
461 FALSE, packet->buffer->data,
462 packet->buffer->len, FALSE);
465 case SILC_NOTIFY_TYPE_NICK_CHANGE:
468 * Distribute the notify to local clients on the channel
470 unsigned char *id, *id2;
472 SilcUInt32 nickname_len;
474 SILC_LOG_DEBUG(("NICK CHANGE notify"));
476 /* Get old client ID */
477 id = silc_argument_get_arg_type(args, 1, &tmp_len);
480 client_id = silc_id_payload_parse_id(id, tmp_len, NULL);
484 /* Get new client ID */
485 id2 = silc_argument_get_arg_type(args, 2, &tmp_len);
488 client_id2 = silc_id_payload_parse_id(id2, tmp_len, NULL);
490 silc_free(client_id);
494 SILC_LOG_DEBUG(("Old Client ID id(%s)",
495 silc_id_render(client_id, SILC_ID_CLIENT)));
496 SILC_LOG_DEBUG(("New Client ID id(%s)",
497 silc_id_render(client_id2, SILC_ID_CLIENT)));
499 /* From protocol version 1.1 we also get the new nickname */
500 nickname = silc_argument_get_arg_type(args, 3, &nickname_len);;
502 /* Replace the Client ID */
503 client = silc_idlist_replace_client_id(server,
504 server->global_list, client_id,
505 client_id2, nickname);
507 client = silc_idlist_replace_client_id(server,
508 server->local_list, client_id,
509 client_id2, nickname);
512 /* Send the NICK_CHANGE notify type to local clients on the channels
513 this client is joined to. */
514 silc_server_send_notify_on_channels(server, client, client,
515 SILC_NOTIFY_TYPE_NICK_CHANGE, 3,
516 id, tmp_len, id2, tmp_len,
521 silc_free(client_id);
523 silc_free(client_id2);
527 case SILC_NOTIFY_TYPE_CMODE_CHANGE:
529 * Distribute the notify to local clients on the channel
532 SILC_LOG_DEBUG(("CMODE CHANGE notify"));
535 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
538 client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
542 /* Get client entry */
543 if (id_type == SILC_ID_CLIENT) {
544 client = silc_idlist_find_client_by_id(server->global_list,
545 client_id, TRUE, &cache);
547 client = silc_idlist_find_client_by_id(server->local_list,
548 client_id, TRUE, &cache);
550 silc_free(client_id);
555 silc_free(client_id);
558 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
559 packet->dst_id_type);
564 /* Get channel entry */
565 channel = silc_idlist_find_channel_by_id(server->global_list,
568 channel = silc_idlist_find_channel_by_id(server->local_list,
571 SILC_LOG_DEBUG(("Notify for unknown channel"));
572 silc_free(channel_id);
576 silc_free(channel_id);
579 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
582 SILC_GET32_MSB(mode, tmp);
584 /* Check if mode changed */
585 if (channel->mode == mode) {
586 SILC_LOG_DEBUG(("Mode is changed already"));
588 /* If this mode change has founder mode then we'll enforce the
589 change so that the server gets the real founder public key */
590 if (server->server_type != SILC_SERVER &&
591 sock != SILC_PRIMARY_ROUTE(server) &&
592 mode & SILC_CHANNEL_MODE_FOUNDER_AUTH && channel->founder_key) {
593 SILC_LOG_DEBUG(("Sending founder public key to server"));
594 silc_server_send_notify_cmode(server, sock, FALSE, channel,
595 channel->mode, server->id,
596 SILC_ID_SERVER, channel->cipher,
599 channel->founder_key);
602 /* If we received same mode from our primary check whether founder
603 mode and key in the notify is set. We update the founder key
604 here since we may have wrong one */
605 if (server->server_type == SILC_SERVER &&
606 sock == SILC_PRIMARY_ROUTE(server) &&
607 mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
608 SILC_LOG_DEBUG(("Founder public key received from router"));
609 tmp = silc_argument_get_arg_type(args, 6, &tmp_len);
613 if (channel->founder_key)
614 silc_pkcs_public_key_free(channel->founder_key);
615 channel->founder_key = NULL;
616 silc_pkcs_public_key_payload_decode(tmp, tmp_len,
617 &channel->founder_key);
623 /* Get user's channel entry and check that mode change is allowed */
625 if (!silc_server_client_on_channel(client, channel, &chl))
627 if (!silc_server_check_cmode_rights(server, channel, chl, mode)) {
628 SILC_LOG_DEBUG(("CMODE change is not allowed"));
629 silc_server_send_notify_cmode(server, sock, FALSE, channel,
630 channel->mode, server->id,
631 SILC_ID_SERVER, channel->cipher,
634 channel->founder_key);
638 /* Assure that server is not removing founder mode from us */
639 if (server->server_type == SILC_ROUTER &&
640 sock != SILC_PRIMARY_ROUTE(server) &&
641 channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH &&
642 !(mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
643 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
644 silc_server_send_notify_cmode(server, sock, FALSE, channel,
645 channel->mode, server->id,
646 SILC_ID_SERVER, channel->cipher,
649 channel->founder_key);
653 /* If server is adding founder mode, check whether there is founder
654 on channel already and is not from this server */
655 if (server->server_type == SILC_ROUTER &&
656 sock != SILC_PRIMARY_ROUTE(server) &&
657 mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
658 silc_hash_table_list(channel->user_list, &htl);
659 while (silc_hash_table_get(&htl, NULL, (void *)&chl))
660 if (chl->mode & SILC_CHANNEL_UMODE_CHANFO &&
661 chl->client->router != sock->user_data) {
662 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
663 silc_server_send_notify_cmode(server, sock, FALSE, channel,
664 channel->mode, server->id,
665 SILC_ID_SERVER, channel->cipher,
668 channel->founder_key);
669 silc_hash_table_list_reset(&htl);
672 silc_hash_table_list_reset(&htl);
676 /* If the channel had private keys set and the mode was removed then
677 we must re-generate and re-distribute a new channel key */
678 if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY &&
679 !(mode & SILC_CHANNEL_MODE_PRIVKEY)) {
680 /* Re-generate channel key */
681 if (!silc_server_create_channel_key(server, channel, 0))
684 /* Send the channel key. This sends it to our local clients and if
685 we are normal server to our router as well. */
686 silc_server_send_channel_key(server, NULL, channel,
687 server->server_type == SILC_ROUTER ?
688 FALSE : !server->standalone);
692 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
694 unsigned char hash[32];
697 silc_hmac_free(channel->hmac);
698 if (!silc_hmac_alloc(tmp, NULL, &channel->hmac))
701 /* Set the HMAC key out of current channel key. The client must do
703 silc_hash_make(silc_hmac_get_hash(channel->hmac), channel->key,
704 channel->key_len / 8, hash);
705 silc_hmac_set_key(channel->hmac, hash,
706 silc_hash_len(silc_hmac_get_hash(channel->hmac)));
707 memset(hash, 0, sizeof(hash));
710 /* Get the passphrase */
711 tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
713 silc_free(channel->passphrase);
714 channel->passphrase = silc_memdup(tmp, tmp_len);
717 /* Get founder public key */
718 tmp = silc_argument_get_arg_type(args, 6, &tmp_len);
719 if (tmp && mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
720 if (channel->founder_key)
721 silc_pkcs_public_key_free(channel->founder_key);
722 channel->founder_key = NULL;
723 silc_pkcs_public_key_payload_decode(tmp, tmp_len, &channel->founder_key);
725 if (!channel->founder_key ||
726 (client && client->data.public_key &&
727 server->server_type == SILC_ROUTER &&
728 !silc_pkcs_public_key_compare(channel->founder_key,
729 client->data.public_key))) {
730 /* A really buggy server isn't checking public keys correctly.
731 It's not possible that the mode setter and founder wouldn't
732 have same public key. */
733 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
735 mode &= ~SILC_CHANNEL_MODE_FOUNDER_AUTH;
736 silc_server_send_notify_cmode(server, sock, FALSE, channel,
737 mode, server->id, SILC_ID_SERVER,
740 channel->passphrase, NULL);
741 if (channel->founder_key)
742 silc_pkcs_public_key_free(channel->founder_key);
743 channel->founder_key = NULL;
744 } else if (client && !client->data.public_key) {
745 client->data.public_key =
746 silc_pkcs_public_key_copy(channel->founder_key);
750 if (mode & SILC_CHANNEL_MODE_FOUNDER_AUTH && !channel->founder_key &&
751 server->server_type == SILC_ROUTER) {
752 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
753 mode &= ~SILC_CHANNEL_MODE_FOUNDER_AUTH;
754 silc_server_send_notify_cmode(server, sock, FALSE, channel,
755 mode, server->id, SILC_ID_SERVER,
758 channel->passphrase, NULL);
761 /* Send the same notify to the channel */
762 silc_server_packet_send_to_channel(server, NULL, channel, packet->type,
763 FALSE, packet->buffer->data,
764 packet->buffer->len, FALSE);
767 channel->mode = mode;
769 if (!(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) &&
770 channel->founder_key) {
771 silc_pkcs_public_key_free(channel->founder_key);
772 channel->founder_key = NULL;
777 case SILC_NOTIFY_TYPE_CUMODE_CHANGE:
780 * Distribute the notify to local clients on the channel
782 SilcChannelClientEntry chl2 = NULL;
783 bool notify_sent = FALSE;
785 SILC_LOG_DEBUG(("CUMODE CHANGE notify"));
788 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
791 client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
795 /* Get client entry */
796 if (id_type == SILC_ID_CLIENT) {
797 client = silc_idlist_find_client_by_id(server->global_list,
798 client_id, TRUE, &cache);
800 client = silc_idlist_find_client_by_id(server->local_list,
801 client_id, TRUE, &cache);
803 silc_free(client_id);
808 silc_free(client_id);
811 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
812 packet->dst_id_type);
817 /* Get channel entry */
818 channel = silc_idlist_find_channel_by_id(server->global_list,
821 channel = silc_idlist_find_channel_by_id(server->local_list,
824 SILC_LOG_DEBUG(("Notify for unknown channel"));
825 silc_free(channel_id);
831 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
833 silc_free(channel_id);
837 SILC_GET32_MSB(mode, tmp);
839 /* Get target client */
840 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
843 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
847 /* Get client entry */
848 client2 = silc_idlist_find_client_by_id(server->global_list,
849 client_id, TRUE, NULL);
851 client2 = silc_idlist_find_client_by_id(server->local_list,
852 client_id, TRUE, NULL);
854 silc_free(client_id);
858 silc_free(client_id);
861 /* Check that sender is on channel */
862 if (!silc_server_client_on_channel(client, channel, &chl))
865 if (client != client2 && server->server_type == SILC_ROUTER) {
866 /* Sender must be operator */
867 if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
868 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
869 SILC_LOG_DEBUG(("CUMODE change is not allowed"));
873 if (!silc_server_client_on_channel(client2, channel, &chl))
876 /* If target is founder mode change is not allowed. */
877 if (chl->mode & SILC_CHANNEL_UMODE_CHANFO) {
878 SILC_LOG_DEBUG(("CUMODE change is not allowed"));
884 /* Get target channel user entry */
885 if (!silc_server_client_on_channel(client2, channel, &chl))
888 if (server->server_type == SILC_SERVER && chl->mode == mode) {
889 SILC_LOG_DEBUG(("Mode is changed already"));
893 if (mode & SILC_CHANNEL_UMODE_CHANFO &&
894 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO) &&
895 server->server_type == SILC_ROUTER &&
896 sock != SILC_PRIMARY_ROUTE(server)) {
897 SilcPublicKey founder_key = NULL;
899 /* If channel doesn't have founder auth mode then it's impossible
900 that someone would be getting founder rights with CUMODE command.
901 In that case there already either is founder or there isn't
902 founder at all on the channel. */
903 if (client && !(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
904 /* Force the mode to not have founder mode */
905 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
906 silc_server_force_cumode_change(server, sock, channel, chl, mode);
911 /* Get the founder of the channel and if found then this client
912 cannot be the founder since there already is one. */
913 silc_hash_table_list(channel->user_list, &htl);
914 while (silc_hash_table_get(&htl, NULL, (void *)&chl2))
915 if (chl2->mode & SILC_CHANNEL_UMODE_CHANFO) {
916 /* If the founder on the channel is not the one whom has set
917 the founder mode, then it's possible that this CUMODE_CHANGE
918 is correct. Due to netsplits it's possible that this
919 situation happens. */
920 if (!(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) ||
921 (channel->founder_key && chl2->client->data.public_key &&
922 silc_pkcs_public_key_compare(
923 channel->founder_key,
924 chl2->client->data.public_key))) {
925 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
926 silc_server_force_cumode_change(server, sock, channel,
932 silc_hash_table_list_reset(&htl);
933 if (!(mode & SILC_CHANNEL_UMODE_CHANFO))
936 /* Founder not found of the channel. Since the founder auth mode
937 is set on the channel now check whether this is the client that
938 originally set the mode. */
940 if (channel->founder_key) {
941 /* Get public key that must be present in notify */
942 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
943 if (!tmp || !silc_pkcs_public_key_payload_decode(tmp, tmp_len,
945 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
946 silc_server_force_cumode_change(server, sock, channel, chl, mode);
951 /* Now match the public key we have cached and public key sent.
953 #if 0 /* The key may be other than the client's in 1.2 */
954 if (client && client->data.public_key &&
955 !silc_pkcs_public_key_compare(channel->founder_key,
956 client->data.public_key)) {
957 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
958 silc_server_force_cumode_change(server, sock, channel, chl, mode);
963 if (!silc_pkcs_public_key_compare(channel->founder_key,
965 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
966 silc_server_force_cumode_change(server, sock, channel, chl, mode);
972 /* There cannot be anyone else as founder on the channel now. This
973 client is definitely the founder due to this authentication */
974 silc_hash_table_list(channel->user_list, &htl);
975 while (silc_hash_table_get(&htl, NULL, (void *)&chl2))
976 if (chl2->mode & SILC_CHANNEL_UMODE_CHANFO) {
977 chl2->mode &= ~SILC_CHANNEL_UMODE_CHANFO;
978 silc_server_force_cumode_change(server, NULL, channel, chl2,
982 silc_hash_table_list_reset(&htl);
985 silc_pkcs_public_key_free(founder_key);
988 if (server->server_type != SILC_SERVER && chl->mode == mode) {
989 SILC_LOG_DEBUG(("Mode is changed already"));
993 SILC_LOG_DEBUG(("Changing %s channel user mode",
994 chl->client->nickname ? chl->client->nickname :
995 (unsigned char *)""));
997 /* Change the mode */
1000 /* Send the same notify to the channel */
1002 silc_server_packet_send_to_channel(server, NULL, channel,
1004 FALSE, packet->buffer->data,
1005 packet->buffer->len, FALSE);
1007 silc_free(channel_id);
1011 case SILC_NOTIFY_TYPE_INVITE:
1013 if (packet->dst_id_type == SILC_ID_CLIENT)
1016 SILC_LOG_DEBUG(("INVITE notify"));
1018 /* Get Channel ID */
1019 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1022 channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1026 /* Get channel entry */
1027 channel = silc_idlist_find_channel_by_id(server->global_list,
1030 channel = silc_idlist_find_channel_by_id(server->local_list,
1033 SILC_LOG_DEBUG(("Notify for unknown channel"));
1034 silc_free(channel_id);
1038 silc_free(channel_id);
1041 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1044 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1048 /* Get client entry */
1049 client = silc_idlist_find_client_by_id(server->global_list,
1050 client_id, TRUE, &cache);
1052 client = silc_idlist_find_client_by_id(server->local_list,
1053 client_id, TRUE, &cache);
1055 silc_free(client_id);
1059 silc_free(client_id);
1061 /* Get user's channel entry and check that inviting is allowed. */
1062 if (!silc_server_client_on_channel(client, channel, &chl))
1064 if (channel->mode & SILC_CHANNEL_MODE_INVITE &&
1065 !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
1066 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
1067 SILC_LOG_DEBUG(("Inviting is not allowed"));
1071 /* Get the invite action */
1072 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
1073 if (tmp && tmp_len == 1) {
1074 SilcUInt8 action = (SilcUInt8)tmp[0];
1075 SilcUInt16 iargc = 0;
1076 SilcArgumentPayload iargs;
1078 /* Get invite list */
1079 tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
1080 if (!tmp || tmp_len < 2)
1083 /* Parse the arguments to see they are constructed correctly */
1084 SILC_GET16_MSB(iargc, tmp);
1085 iargs = silc_argument_payload_parse(tmp + 2, tmp_len - 2, iargc);
1089 if (action == 0 && !channel->invite_list)
1090 channel->invite_list = silc_hash_table_alloc(0, silc_hash_ptr,
1094 /* Proces the invite action */
1095 silc_server_inviteban_process(server, channel->invite_list, action,
1097 silc_argument_payload_free(iargs);
1102 case SILC_NOTIFY_TYPE_CHANNEL_CHANGE:
1104 * Distribute to the local clients on the channel and change the
1108 SILC_LOG_DEBUG(("CHANNEL CHANGE"));
1110 if (sock->type != SILC_SOCKET_TYPE_ROUTER)
1113 /* Get the old Channel ID */
1114 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1117 channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1121 /* Get the channel entry */
1122 channel = silc_idlist_find_channel_by_id(server->local_list,
1125 channel = silc_idlist_find_channel_by_id(server->global_list,
1128 SILC_LOG_DEBUG(("Notify for unknown channel"));
1129 silc_free(channel_id);
1134 /* Send the notify to the channel */
1135 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
1136 FALSE, packet->buffer->data,
1137 packet->buffer->len, FALSE);
1139 /* Get the new Channel ID */
1140 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1143 channel_id2 = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1147 SILC_LOG_DEBUG(("Old Channel ID id(%s)",
1148 silc_id_render(channel_id, SILC_ID_CHANNEL)));
1149 SILC_LOG_DEBUG(("New Channel ID id(%s)",
1150 silc_id_render(channel_id2, SILC_ID_CHANNEL)));
1152 /* Replace the Channel ID */
1153 if (!silc_idlist_replace_channel_id(server->local_list, channel_id,
1155 if (!silc_idlist_replace_channel_id(server->global_list, channel_id,
1157 silc_free(channel_id2);
1162 SilcBuffer modes = NULL, users = NULL, users_modes = NULL;
1164 /* Re-announce this channel which ID was changed. */
1165 silc_server_send_new_channel(server, sock, FALSE, channel->channel_name,
1167 silc_id_get_len(channel->id,
1171 /* Re-announce our clients on the channel as the ID has changed now */
1172 silc_server_announce_get_channel_users(server, channel, &modes, &users,
1175 silc_buffer_push(users, users->data - users->head);
1176 silc_server_packet_send(server, sock,
1177 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1178 users->data, users->len, FALSE);
1179 silc_buffer_free(users);
1182 silc_buffer_push(modes, modes->data - modes->head);
1183 silc_server_packet_send_dest(server, sock,
1184 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1185 channel->id, SILC_ID_CHANNEL,
1186 modes->data, modes->len, FALSE);
1187 silc_buffer_free(modes);
1190 silc_buffer_push(users_modes, users_modes->data - users_modes->head);
1191 silc_server_packet_send_dest(server, sock,
1192 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1193 channel->id, SILC_ID_CHANNEL,
1195 users_modes->len, FALSE);
1196 silc_buffer_free(users_modes);
1199 /* Re-announce channel's topic */
1200 if (channel->topic) {
1201 silc_server_send_notify_topic_set(server, sock,
1202 server->server_type == SILC_ROUTER ?
1203 TRUE : FALSE, channel,
1204 server->id, SILC_ID_SERVER,
1209 silc_free(channel_id);
1213 case SILC_NOTIFY_TYPE_SERVER_SIGNOFF:
1215 * Remove the server entry and all clients that this server owns.
1218 SILC_LOG_DEBUG(("SERVER SIGNOFF notify"));
1221 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1224 server_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1228 /* If the ID is mine, this notify is not allowed. */
1229 if (SILC_ID_SERVER_COMPARE(server_id, server->id)) {
1230 SILC_LOG_DEBUG(("Ignoring my own ID for SERVER_SIGNOFF"));
1234 /* Get server entry */
1235 server_entry = silc_idlist_find_server_by_id(server->global_list,
1236 server_id, TRUE, NULL);
1238 if (!server_entry) {
1239 server_entry = silc_idlist_find_server_by_id(server->local_list,
1240 server_id, TRUE, NULL);
1242 if (!server_entry) {
1243 /* If we are normal server then we might not have the server. Check
1244 whether router was kind enough to send the list of all clients
1245 that actually was to be removed. Remove them if the list is
1247 if (server->server_type != SILC_ROUTER &&
1248 silc_argument_get_arg_num(args) > 1) {
1251 for (i = 1; i < silc_argument_get_arg_num(args); i++) {
1253 tmp = silc_argument_get_arg_type(args, i + 1, &tmp_len);
1256 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1260 /* Get client entry */
1261 client = silc_idlist_find_client_by_id(server->global_list,
1262 client_id, TRUE, &cache);
1265 client = silc_idlist_find_client_by_id(server->local_list,
1266 client_id, TRUE, &cache);
1269 silc_free(client_id);
1273 silc_free(client_id);
1275 /* Update statistics */
1276 server->stat.clients--;
1277 if (server->stat.cell_clients)
1278 server->stat.cell_clients--;
1279 SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
1280 SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
1282 /* Remove the client from all channels. */
1283 silc_server_remove_from_channels(server, NULL, client,
1284 TRUE, NULL, FALSE, FALSE);
1286 /* Check if anyone is watching this nickname */
1287 if (server->server_type == SILC_ROUTER)
1288 silc_server_check_watcher_list(server, client, NULL,
1289 SILC_NOTIFY_TYPE_SERVER_SIGNOFF);
1291 /* Remove this client from watcher list if it is */
1293 silc_server_del_from_watcher_list(server, client);
1295 /* Remove the client */
1296 silc_idlist_del_data(client);
1297 silc_idlist_del_client(local ? server->local_list :
1298 server->global_list, client);
1302 silc_free(server_id);
1306 silc_free(server_id);
1308 /* Sending SERVER_SIGNOFF is not right way to signoff local connection */
1309 if (SILC_IS_LOCAL(server_entry))
1312 /* Remove all servers that are originated from this server, and
1313 remove the clients of those servers too. */
1314 silc_server_remove_servers_by_server(server, server_entry, TRUE);
1316 /* Remove the clients that this server owns as they will become
1318 silc_server_remove_clients_by_server(server, server_entry->router,
1319 server_entry, TRUE);
1320 silc_server_backup_del(server, server_entry);
1322 /* Remove the server entry */
1323 silc_idlist_del_server(local ? server->local_list :
1324 server->global_list, server_entry);
1326 /* Update statistics */
1327 if (server->server_type == SILC_ROUTER)
1328 server->stat.servers--;
1332 case SILC_NOTIFY_TYPE_KICKED:
1334 * Distribute the notify to local clients on the channel
1337 SILC_LOG_DEBUG(("KICKED notify"));
1340 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
1341 packet->dst_id_type);
1346 /* Get channel entry */
1347 channel = silc_idlist_find_channel_by_id(server->global_list,
1350 channel = silc_idlist_find_channel_by_id(server->local_list,
1353 SILC_LOG_DEBUG(("Notify for unknown channel"));
1354 silc_free(channel_id);
1358 silc_free(channel_id);
1361 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1364 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1368 /* If the the client is not in local list we check global list */
1369 client = silc_idlist_find_client_by_id(server->global_list,
1370 client_id, TRUE, NULL);
1372 client = silc_idlist_find_client_by_id(server->local_list,
1373 client_id, TRUE, NULL);
1375 silc_free(client_id);
1379 silc_free(client_id);
1381 /* If target is founder they cannot be kicked */
1382 if (!silc_server_client_on_channel(client, channel, &chl))
1384 if (chl->mode & SILC_CHANNEL_UMODE_CHANFO)
1387 /* Get the kicker's Client ID */
1388 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1391 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1395 /* If the the client is not in local list we check global list */
1396 client2 = silc_idlist_find_client_by_id(server->global_list,
1397 client_id, TRUE, NULL);
1399 client2 = silc_idlist_find_client_by_id(server->local_list,
1400 client_id, TRUE, NULL);
1402 silc_free(client_id);
1406 silc_free(client_id);
1408 /* Kicker must be operator on channel */
1409 if (!silc_server_client_on_channel(client2, channel, &chl))
1411 if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
1412 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
1413 SILC_LOG_DEBUG(("Kicking is not allowed"));
1417 /* Send to channel */
1418 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
1419 FALSE, packet->buffer->data,
1420 packet->buffer->len, FALSE);
1422 /* Remove the client from channel's invite list */
1423 if (channel->invite_list && silc_hash_table_count(channel->invite_list)) {
1425 SilcArgumentPayload iargs;
1426 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1427 ab = silc_argument_payload_encode_one(NULL, tmp, tmp_len, 3);
1428 iargs = silc_argument_payload_parse(ab->data, ab->len, 1);
1429 silc_server_inviteban_process(server, channel->invite_list, 1, iargs);
1430 silc_buffer_free(ab);
1431 silc_argument_payload_free(iargs);
1434 /* Remove the client from channel */
1435 silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
1439 case SILC_NOTIFY_TYPE_KILLED:
1442 * Distribute the notify to local clients on channels
1444 unsigned char *id, *comment;
1445 SilcUInt32 id_len, comment_len;
1447 SILC_LOG_DEBUG(("KILLED notify"));
1450 id = silc_argument_get_arg_type(args, 1, &id_len);
1453 client_id = silc_id_payload_parse_id(id, id_len, NULL);
1457 /* If the the client is not in local list we check global list */
1458 client = silc_idlist_find_client_by_id(server->global_list,
1459 client_id, TRUE, &cache);
1461 client = silc_idlist_find_client_by_id(server->local_list,
1462 client_id, TRUE, &cache);
1464 silc_free(client_id);
1468 silc_free(client_id);
1470 /* If the client is one of ours, then close the connection to the
1471 client now. This removes the client from all channels as well. */
1472 if (packet->dst_id_type == SILC_ID_CLIENT && client->connection) {
1473 sock = client->connection;
1474 silc_server_free_client_data(server, NULL, client, FALSE, NULL);
1475 silc_server_close_connection(server, sock);
1480 comment = silc_argument_get_arg_type(args, 2, &comment_len);
1481 if (comment_len > 128)
1484 /* Get the killer's Client ID */
1485 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1488 client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
1492 if (id_type == SILC_ID_CLIENT) {
1493 /* If the the client is not in local list we check global list */
1494 client2 = silc_idlist_find_client_by_id(server->global_list,
1495 client_id, TRUE, NULL);
1497 client2 = silc_idlist_find_client_by_id(server->local_list,
1498 client_id, TRUE, NULL);
1500 silc_free(client_id);
1504 silc_free(client_id);
1506 /* Killer must be router operator */
1507 if (server->server_type != SILC_SERVER &&
1508 !(client2->mode & SILC_UMODE_ROUTER_OPERATOR)) {
1509 SILC_LOG_DEBUG(("Killing is not allowed"));
1514 /* Send the notify to local clients on the channels except to the
1515 client who is killed. */
1516 silc_server_send_notify_on_channels(server, client, client,
1517 SILC_NOTIFY_TYPE_KILLED, 3,
1518 id, id_len, comment, comment_len,
1521 /* Remove the client from all channels */
1522 silc_server_remove_from_channels(server, NULL, client, FALSE, NULL,
1525 /* Check if anyone is watching this nickname */
1526 silc_server_check_watcher_list(server, client, NULL,
1527 SILC_NOTIFY_TYPE_KILLED);
1529 /* Update statistics */
1530 server->stat.clients--;
1531 if (server->stat.cell_clients)
1532 server->stat.cell_clients--;
1533 SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
1534 SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
1536 if (SILC_IS_LOCAL(client)) {
1537 server->stat.my_clients--;
1538 silc_schedule_task_del_by_context(server->schedule, client);
1539 silc_idlist_del_data(client);
1543 client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
1544 cache->expire = SILC_ID_CACHE_EXPIRE_DEF;
1548 case SILC_NOTIFY_TYPE_UMODE_CHANGE:
1550 * Save the mode of the client.
1553 SILC_LOG_DEBUG(("UMODE_CHANGE notify"));
1556 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1559 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1563 /* Get client entry */
1564 client = silc_idlist_find_client_by_id(server->global_list,
1565 client_id, TRUE, NULL);
1567 client = silc_idlist_find_client_by_id(server->local_list,
1568 client_id, TRUE, NULL);
1570 silc_free(client_id);
1574 silc_free(client_id);
1577 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1580 SILC_GET32_MSB(mode, tmp);
1582 /* Remove internal resumed flag if client is marked detached now */
1583 if (mode & SILC_UMODE_DETACHED)
1584 client->data.status &= ~SILC_IDLIST_STATUS_RESUMED;
1586 /* Update statistics */
1587 if (server->server_type == SILC_ROUTER) {
1588 if (mode & SILC_UMODE_GONE) {
1589 if (!(client->mode & SILC_UMODE_GONE))
1590 server->stat.aways++;
1592 if (client->mode & SILC_UMODE_GONE)
1593 server->stat.aways--;
1595 if (mode & SILC_UMODE_DETACHED) {
1596 if (!(client->mode & SILC_UMODE_DETACHED))
1597 server->stat.detached++;
1599 if (client->mode & SILC_UMODE_DETACHED)
1600 server->stat.detached--;
1603 SILC_UMODE_STATS_UPDATE(server, SILC_UMODE_SERVER_OPERATOR);
1604 SILC_UMODE_STATS_UPDATE(router, SILC_UMODE_ROUTER_OPERATOR);
1606 /* Change the mode */
1607 client->mode = mode;
1609 /* Check if anyone is watching this nickname */
1610 if (server->server_type == SILC_ROUTER)
1611 silc_server_check_watcher_list(server, client, NULL,
1612 SILC_NOTIFY_TYPE_UMODE_CHANGE);
1616 case SILC_NOTIFY_TYPE_BAN:
1621 SILC_LOG_DEBUG(("BAN notify"));
1623 /* Get Channel ID */
1624 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1627 channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1631 /* Get channel entry */
1632 channel = silc_idlist_find_channel_by_id(server->global_list,
1635 channel = silc_idlist_find_channel_by_id(server->local_list,
1638 SILC_LOG_DEBUG(("Notify for unknown channel"));
1639 silc_free(channel_id);
1643 silc_free(channel_id);
1645 /* Get the ban action */
1646 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1647 if (tmp && tmp_len == 1) {
1648 SilcUInt8 action = (SilcUInt8)tmp[0];
1649 SilcUInt16 iargc = 0;
1650 SilcArgumentPayload iargs;
1653 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1654 if (!tmp || tmp_len < 2)
1657 /* Parse the arguments to see they are constructed correctly */
1658 SILC_GET16_MSB(iargc, tmp);
1659 iargs = silc_argument_payload_parse(tmp + 2, tmp_len - 2, iargc);
1663 if (action == 0 && !channel->ban_list)
1664 channel->ban_list = silc_hash_table_alloc(0, silc_hash_ptr,
1668 /* Proces the ban action */
1669 silc_server_inviteban_process(server, channel->ban_list, action,
1671 silc_argument_payload_free(iargs);
1675 case SILC_NOTIFY_TYPE_ERROR:
1682 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1683 if (!tmp && tmp_len != 1)
1685 error = (SilcStatus)tmp[0];
1687 SILC_LOG_DEBUG(("ERROR notify (%d)", error));
1689 if (error == SILC_STATUS_ERR_NO_SUCH_CLIENT_ID &&
1690 sock->type == SILC_SOCKET_TYPE_ROUTER) {
1691 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1693 SILC_LOG_DEBUG(("Received invalid client ID notification, deleting "
1694 "the entry from cache"));
1695 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1698 client = silc_idlist_find_client_by_id(server->global_list,
1699 client_id, FALSE, NULL);
1701 silc_server_remove_from_channels(server, NULL, client, TRUE,
1703 silc_idlist_del_data(client);
1704 silc_idlist_del_client(server->global_list, client);
1706 silc_free(client_id);
1712 /* Ignore rest of the notify types for now */
1713 case SILC_NOTIFY_TYPE_NONE:
1714 case SILC_NOTIFY_TYPE_MOTD:
1721 silc_notify_payload_free(payload);
1724 void silc_server_notify_list(SilcServer server,
1725 SilcSocketConnection sock,
1726 SilcPacketContext *packet)
1728 SilcPacketContext *new;
1732 SILC_LOG_DEBUG(("Processing Notify List"));
1734 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
1735 packet->src_id_type != SILC_ID_SERVER)
1738 /* Make copy of the original packet context, except for the actual
1739 data buffer, which we will here now fetch from the original buffer. */
1740 new = silc_packet_context_alloc();
1741 new->type = SILC_PACKET_NOTIFY;
1742 new->flags = packet->flags;
1743 new->src_id = packet->src_id;
1744 new->src_id_len = packet->src_id_len;
1745 new->src_id_type = packet->src_id_type;
1746 new->dst_id = packet->dst_id;
1747 new->dst_id_len = packet->dst_id_len;
1748 new->dst_id_type = packet->dst_id_type;
1750 buffer = silc_buffer_alloc(1024);
1751 new->buffer = buffer;
1753 while (packet->buffer->len) {
1754 SILC_GET16_MSB(len, packet->buffer->data + 2);
1755 if (len > packet->buffer->len)
1758 if (len > buffer->truelen) {
1759 silc_buffer_free(buffer);
1760 buffer = silc_buffer_alloc(1024 + len);
1763 silc_buffer_pull_tail(buffer, len);
1764 silc_buffer_put(buffer, packet->buffer->data, len);
1766 /* Process the Notify */
1767 silc_server_notify(server, sock, new);
1769 silc_buffer_push_tail(buffer, len);
1770 silc_buffer_pull(packet->buffer, len);
1773 silc_buffer_free(buffer);
1777 /* Received private message. This resolves the destination of the message
1778 and sends the packet. This is used by both server and router. If the
1779 destination is our locally connected client this sends the packet to
1780 the client. This may also send the message for further routing if
1781 the destination is not in our server (or router). */
1783 void silc_server_private_message(SilcServer server,
1784 SilcSocketConnection sock,
1785 SilcPacketContext *packet)
1787 SilcSocketConnection dst_sock;
1788 SilcIDListData idata;
1789 SilcClientEntry client;
1791 SILC_LOG_DEBUG(("Start"));
1793 if (packet->src_id_type != SILC_ID_CLIENT ||
1794 packet->dst_id_type != SILC_ID_CLIENT || !packet->dst_id)
1797 /* Get the route to the client */
1798 dst_sock = silc_server_get_client_route(server, packet->dst_id,
1799 packet->dst_id_len, NULL,
1803 unsigned char error;
1805 if (client && client->mode & SILC_UMODE_DETACHED) {
1806 SILC_LOG_DEBUG(("Client is detached, discarding packet"));
1810 /* Send SILC_NOTIFY_TYPE_ERROR to indicate that such destination ID
1811 does not exist or is invalid. */
1812 idp = silc_id_payload_encode_data(packet->dst_id,
1814 packet->dst_id_type);
1818 error = SILC_STATUS_ERR_NO_SUCH_CLIENT_ID;
1819 if (packet->src_id_type == SILC_ID_CLIENT) {
1820 SilcClientID *client_id = silc_id_str2id(packet->src_id,
1822 packet->src_id_type);
1823 silc_server_send_notify_dest(server, sock, FALSE,
1824 client_id, SILC_ID_CLIENT,
1825 SILC_NOTIFY_TYPE_ERROR, 2,
1827 idp->data, idp->len);
1828 silc_free(client_id);
1830 silc_server_send_notify(server, sock, FALSE,
1831 SILC_NOTIFY_TYPE_ERROR, 2,
1833 idp->data, idp->len);
1836 silc_buffer_free(idp);
1840 /* Check whether destination client wishes to receive private messages */
1841 if (client && !(packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY) &&
1842 client->mode & SILC_UMODE_BLOCK_PRIVMSG) {
1843 SILC_LOG_DEBUG(("Client blocks private messages, discarding packet"));
1847 /* Send the private message */
1848 silc_server_send_private_message(server, dst_sock, idata->send_key,
1849 idata->hmac_send, idata->psn_send++,
1853 /* Received private message key packet.. This packet is never for us. It is to
1854 the client in the packet's destination ID. Sending of this sort of packet
1855 equals sending private message, ie. it is sent point to point from
1856 one client to another. */
1858 void silc_server_private_message_key(SilcServer server,
1859 SilcSocketConnection sock,
1860 SilcPacketContext *packet)
1862 SilcSocketConnection dst_sock;
1863 SilcIDListData idata;
1865 SILC_LOG_DEBUG(("Start"));
1867 if (packet->src_id_type != SILC_ID_CLIENT ||
1868 packet->dst_id_type != SILC_ID_CLIENT)
1871 if (!packet->dst_id)
1874 /* Get the route to the client */
1875 dst_sock = silc_server_get_client_route(server, packet->dst_id,
1876 packet->dst_id_len, NULL,
1881 /* Relay the packet */
1882 silc_server_relay_packet(server, dst_sock, idata->send_key,
1883 idata->hmac_send, idata->psn_send++, packet, FALSE);
1886 /* Processes incoming command reply packet. The command reply packet may
1887 be destined to one of our clients or it may directly for us. We will
1888 call the command reply routine after processing the packet. */
1890 void silc_server_command_reply(SilcServer server,
1891 SilcSocketConnection sock,
1892 SilcPacketContext *packet)
1894 SilcBuffer buffer = packet->buffer;
1895 SilcClientEntry client = NULL;
1896 SilcSocketConnection dst_sock;
1897 SilcIDListData idata;
1898 SilcClientID *id = NULL;
1900 SILC_LOG_DEBUG(("Start"));
1902 if (packet->dst_id_type == SILC_ID_CHANNEL)
1905 if (packet->dst_id_type == SILC_ID_CLIENT) {
1906 /* Destination must be one of ours */
1907 id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CLIENT);
1910 client = silc_idlist_find_client_by_id(server->local_list, id, TRUE, NULL);
1912 SILC_LOG_ERROR(("Cannot process command reply to unknown client"));
1918 if (packet->dst_id_type == SILC_ID_SERVER) {
1919 /* For now this must be for us */
1920 if (memcmp(packet->dst_id, server->id_string, server->id_string_len)) {
1921 SILC_LOG_ERROR(("Cannot process command reply to unknown server"));
1926 /* Execute command reply locally for the command */
1927 silc_server_command_reply_process(server, sock, buffer);
1929 if (packet->dst_id_type == SILC_ID_CLIENT && client && id) {
1930 /* Relay the packet to the client */
1931 const SilcBufferStruct p;
1933 dst_sock = (SilcSocketConnection)client->connection;
1934 idata = (SilcIDListData)client;
1936 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1937 + packet->dst_id_len + packet->padlen);
1938 if (!silc_packet_send_prepare(dst_sock, 0, 0, buffer->len,
1939 idata->hmac_send, (const SilcBuffer)&p)) {
1940 SILC_LOG_ERROR(("Cannot send packet"));
1943 silc_buffer_put((SilcBuffer)&p, buffer->data, buffer->len);
1945 /* Encrypt packet */
1946 silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
1947 (SilcBuffer)&p, buffer->len);
1949 /* Send the packet */
1950 silc_server_packet_send_real(server, dst_sock, TRUE);
1956 /* Process received channel message. The message can be originated from
1957 client or server. */
1959 void silc_server_channel_message(SilcServer server,
1960 SilcSocketConnection sock,
1961 SilcPacketContext *packet)
1963 SilcChannelEntry channel = NULL;
1964 SilcChannelID *id = NULL;
1965 void *sender_id = NULL;
1966 SilcClientEntry sender_entry = NULL;
1967 SilcChannelClientEntry chl;
1970 SILC_LOG_DEBUG(("Processing channel message"));
1973 if (packet->dst_id_type != SILC_ID_CHANNEL) {
1974 SILC_LOG_DEBUG(("Received bad message for channel, dropped"));
1978 /* Find channel entry */
1979 id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CHANNEL);
1982 channel = silc_idlist_find_channel_by_id(server->local_list, id, NULL);
1984 channel = silc_idlist_find_channel_by_id(server->global_list, id, NULL);
1987 unsigned char error;
1989 /* Send SILC_NOTIFY_TYPE_ERROR to indicate that such destination ID
1990 does not exist or is invalid. */
1991 idp = silc_id_payload_encode_data(packet->dst_id,
1993 packet->dst_id_type);
1997 error = SILC_STATUS_ERR_NO_SUCH_CHANNEL_ID;
1998 if (packet->src_id_type == SILC_ID_CLIENT) {
1999 SilcClientID *client_id = silc_id_str2id(packet->src_id,
2001 packet->src_id_type);
2002 silc_server_send_notify_dest(server, sock, FALSE,
2003 client_id, SILC_ID_CLIENT,
2004 SILC_NOTIFY_TYPE_ERROR, 2,
2005 &error, 1, idp->data, idp->len);
2006 silc_free(client_id);
2008 silc_server_send_notify(server, sock, FALSE,
2009 SILC_NOTIFY_TYPE_ERROR, 2,
2010 &error, 1, idp->data, idp->len);
2013 silc_buffer_free(idp);
2018 /* See that this client is on the channel. If the original sender is
2019 not client (as it can be server as well) we don't do the check. */
2020 sender_id = silc_id_str2id(packet->src_id, packet->src_id_len,
2021 packet->src_id_type);
2024 if (packet->src_id_type == SILC_ID_CLIENT) {
2025 sender_entry = silc_idlist_find_client_by_id(server->local_list,
2026 sender_id, TRUE, NULL);
2027 if (!sender_entry) {
2029 sender_entry = silc_idlist_find_client_by_id(server->global_list,
2030 sender_id, TRUE, NULL);
2032 if (!sender_entry || !silc_server_client_on_channel(sender_entry,
2034 SILC_LOG_DEBUG(("Client not on channel"));
2038 /* If channel is moderated check that client is allowed to send
2040 if (channel->mode & SILC_CHANNEL_MODE_SILENCE_USERS &&
2041 !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
2042 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
2043 SILC_LOG_DEBUG(("Channel is silenced from normal users"));
2046 if (channel->mode & SILC_CHANNEL_MODE_SILENCE_OPERS &&
2047 chl->mode & SILC_CHANNEL_UMODE_CHANOP &&
2048 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
2049 SILC_LOG_DEBUG(("Channel is silenced from operators"));
2052 if (chl->mode & SILC_CHANNEL_UMODE_QUIET) {
2053 SILC_LOG_DEBUG(("Sender is quieted on the channel"));
2057 /* If the packet is coming from router, but the client entry is local
2058 entry to us then some router is rerouting this to us and it is not
2059 allowed. When the client is local to us it means that we've routed
2060 this packet to network, and now someone is routing it back to us. */
2061 if (server->server_type == SILC_ROUTER &&
2062 sock->type == SILC_SOCKET_TYPE_ROUTER && local) {
2063 SILC_LOG_DEBUG(("Channel message rerouted to the sender, drop it"));
2068 /* Distribute the packet to our local clients. This will send the
2069 packet for further routing as well, if needed. */
2070 silc_server_packet_relay_to_channel(server, sock, channel, sender_id,
2071 packet->src_id_type, sender_entry,
2072 packet->buffer->data,
2073 packet->buffer->len, FALSE);
2076 silc_free(sender_id);
2080 /* Received channel key packet. We distribute the key to all of our locally
2081 connected clients on the channel. */
2083 void silc_server_channel_key(SilcServer server,
2084 SilcSocketConnection sock,
2085 SilcPacketContext *packet)
2087 SilcBuffer buffer = packet->buffer;
2088 SilcChannelEntry channel;
2090 if (packet->src_id_type != SILC_ID_SERVER ||
2091 (server->server_type == SILC_ROUTER && !server->backup_router &&
2092 sock->type == SILC_SOCKET_TYPE_ROUTER))
2095 /* Save the channel key */
2096 channel = silc_server_save_channel_key(server, buffer, NULL);
2100 /* Distribute the key to everybody who is on the channel. If we are router
2101 we will also send it to locally connected servers. */
2102 silc_server_send_channel_key(server, sock, channel, FALSE);
2104 if (server->server_type != SILC_BACKUP_ROUTER) {
2105 /* Distribute to local cell backup routers. */
2106 silc_server_backup_send(server, sock->user_data,
2107 SILC_PACKET_CHANNEL_KEY, 0,
2108 buffer->data, buffer->len, FALSE, TRUE);
2112 /* Received New Client packet and processes it. Creates Client ID for the
2113 client. Client becomes registered after calling this functions. */
2115 SilcClientEntry silc_server_new_client(SilcServer server,
2116 SilcSocketConnection sock,
2117 SilcPacketContext *packet)
2119 SilcBuffer buffer = packet->buffer;
2120 SilcClientEntry client;
2121 SilcClientID *client_id;
2122 SilcIDListData idata;
2123 char *username = NULL, *realname = NULL;
2124 SilcUInt16 username_len;
2127 char *hostname, *nickname;
2130 SILC_LOG_DEBUG(("Creating new client"));
2132 if (sock->type != SILC_SOCKET_TYPE_CLIENT)
2135 /* Take client entry */
2136 client = (SilcClientEntry)sock->user_data;
2137 idata = (SilcIDListData)client;
2139 /* Remove the old cache entry. */
2140 if (!silc_idcache_del_by_context(server->local_list->clients, client)) {
2141 SILC_LOG_INFO(("Unauthenticated client attempted to register to network"));
2142 silc_server_disconnect_remote(server, sock,
2143 SILC_STATUS_ERR_NOT_AUTHENTICATED, NULL);
2144 if (sock->user_data)
2145 silc_server_free_sock_user_data(server, sock, NULL);
2149 /* Parse incoming packet */
2150 ret = silc_buffer_unformat(buffer,
2151 SILC_STR_UI16_NSTRING_ALLOC(&username,
2153 SILC_STR_UI16_STRING_ALLOC(&realname),
2156 silc_free(username);
2157 silc_free(realname);
2158 SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
2159 "connection", sock->hostname, sock->ip));
2160 silc_server_disconnect_remote(server, sock,
2161 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2163 if (sock->user_data)
2164 silc_server_free_sock_user_data(server, sock, NULL);
2169 silc_free(username);
2170 silc_free(realname);
2171 SILC_LOG_ERROR(("Client %s (%s) did not send its username, closing "
2172 "connection", sock->hostname, sock->ip));
2173 silc_server_disconnect_remote(server, sock,
2174 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2176 if (sock->user_data)
2177 silc_server_free_sock_user_data(server, sock, NULL);
2181 if (username_len > 128)
2182 username[128] = '\0';
2184 /* Check for bad characters for nickname, and modify the nickname if
2185 it includes those. */
2186 if (silc_server_name_bad_chars(username, username_len)) {
2187 nickname = silc_server_name_modify_bad(username, username_len);
2189 nickname = strdup(username);
2192 /* Make sanity checks for the hostname of the client. If the hostname
2193 is provided in the `username' check that it is the same than the
2194 resolved hostname, or if not resolved the hostname that appears in
2195 the client's public key. If the hostname is not present then put
2196 it from the resolved name or from the public key. */
2197 if (strchr(username, '@')) {
2198 SilcPublicKeyIdentifier pident;
2199 int tlen = strcspn(username, "@");
2200 char *phostname = NULL;
2202 hostname = silc_memdup(username + tlen + 1, strlen(username) - tlen - 1);
2204 if (strcmp(sock->hostname, sock->ip) &&
2205 strcmp(sock->hostname, hostname)) {
2206 silc_free(username);
2207 silc_free(hostname);
2208 silc_free(realname);
2209 SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
2210 "connection", sock->hostname, sock->ip));
2211 silc_server_disconnect_remote(server, sock,
2212 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2214 if (sock->user_data)
2215 silc_server_free_sock_user_data(server, sock, NULL);
2219 pident = silc_pkcs_decode_identifier(client->data.public_key->identifier);
2221 phostname = strdup(pident->host);
2222 silc_pkcs_free_identifier(pident);
2225 if (!strcmp(sock->hostname, sock->ip) &&
2226 phostname && strcmp(phostname, hostname)) {
2227 silc_free(username);
2228 silc_free(hostname);
2229 silc_free(phostname);
2230 silc_free(realname);
2231 SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
2232 "connection", sock->hostname, sock->ip));
2233 silc_server_disconnect_remote(server, sock,
2234 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2236 if (sock->user_data)
2237 silc_server_free_sock_user_data(server, sock, NULL);
2241 silc_free(phostname);
2243 /* The hostname is not present, add it. */
2245 /* XXX For now we cannot take the host name from the public key since
2246 they are not trusted or we cannot verify them as trusted. Just take
2247 what the resolved name or address is. */
2249 if (strcmp(sock->hostname, sock->ip)) {
2251 newusername = silc_calloc(strlen(username) +
2252 strlen(sock->hostname) + 2,
2253 sizeof(*newusername));
2254 strncat(newusername, username, strlen(username));
2255 strncat(newusername, "@", 1);
2256 strncat(newusername, sock->hostname, strlen(sock->hostname));
2257 silc_free(username);
2258 username = newusername;
2261 SilcPublicKeyIdentifier pident =
2262 silc_pkcs_decode_identifier(client->data.public_key->identifier);
2265 newusername = silc_calloc(strlen(username) +
2266 strlen(pident->host) + 2,
2267 sizeof(*newusername));
2268 strncat(newusername, username, strlen(username));
2269 strncat(newusername, "@", 1);
2270 strncat(newusername, pident->host, strlen(pident->host));
2271 silc_free(username);
2272 username = newusername;
2273 silc_pkcs_free_identifier(pident);
2279 /* Create Client ID */
2280 while (!silc_id_create_client_id(server, server->id, server->rng,
2281 server->md5hash, nickname, &client_id)) {
2284 silc_server_disconnect_remote(server, sock,
2285 SILC_STATUS_ERR_BAD_NICKNAME, NULL);
2286 if (sock->user_data)
2287 silc_server_free_sock_user_data(server, sock, NULL);
2290 snprintf(&nickname[strlen(nickname) - 1], 1, "%d", nickfail);
2293 /* If client marked as anonymous, scramble the username and hostname */
2294 if (client->mode & SILC_UMODE_ANONYMOUS) {
2297 if (strlen(username) >= 2) {
2298 username[0] = silc_rng_get_byte_fast(server->rng);
2299 username[1] = silc_rng_get_byte_fast(server->rng);
2302 scramble = silc_hash_babbleprint(server->sha1hash, username,
2306 memcpy(&scramble[16], ".silc", 5);
2307 scramble[21] = '\0';
2308 silc_free(username);
2309 username = scramble;
2312 /* Update client entry */
2313 idata->status |= SILC_IDLIST_STATUS_REGISTERED;
2314 client->nickname = nickname;
2315 client->username = username;
2316 client->userinfo = realname ? realname : strdup(username);
2317 client->id = client_id;
2318 id_len = silc_id_get_len(client_id, SILC_ID_CLIENT);
2320 /* Add the client again to the ID cache */
2321 silc_idcache_add(server->local_list->clients, client->nickname,
2322 client_id, client, 0, NULL);
2324 /* Notify our router about new client on the SILC network */
2325 silc_server_send_new_id(server, SILC_PRIMARY_ROUTE(server),
2326 SILC_BROADCAST(server), client->id,
2327 SILC_ID_CLIENT, id_len);
2329 /* Distribute to backup routers */
2330 if (server->server_type == SILC_ROUTER) {
2331 SilcBuffer idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
2332 silc_server_backup_send(server, sock->user_data, SILC_PACKET_NEW_ID, 0,
2333 idp->data, idp->len, FALSE, TRUE);
2334 silc_buffer_free(idp);
2337 /* Send the new client ID to the client. */
2338 silc_server_send_new_id(server, sock, FALSE, client->id, SILC_ID_CLIENT,
2339 silc_id_get_len(client->id, SILC_ID_CLIENT));
2341 /* Send some nice info to the client */
2342 silc_server_send_connect_notifys(server, sock, client);
2344 /* Check if anyone is watching this nickname */
2345 if (server->server_type == SILC_ROUTER)
2346 silc_server_check_watcher_list(server, client, NULL, 0);
2351 /* Create new server. This processes received New Server packet and
2352 saves the received Server ID. The server is our locally connected
2353 server thus we save all the information and save it to local list.
2354 This funtion can be used by both normal server and router server.
2355 If normal server uses this it means that its router has connected
2356 to the server. If router uses this it means that one of the cell's
2357 servers is connected to the router. */
2359 SilcServerEntry silc_server_new_server(SilcServer server,
2360 SilcSocketConnection sock,
2361 SilcPacketContext *packet)
2363 SilcBuffer buffer = packet->buffer;
2364 SilcServerEntry new_server, server_entry;
2365 SilcServerID *server_id;
2366 SilcIDListData idata;
2367 unsigned char *server_name, *id_string;
2368 SilcUInt16 id_len, name_len;
2372 SILC_LOG_DEBUG(("Creating new server"));
2374 if (sock->type != SILC_SOCKET_TYPE_SERVER &&
2375 sock->type != SILC_SOCKET_TYPE_ROUTER)
2378 /* Take server entry */
2379 new_server = (SilcServerEntry)sock->user_data;
2380 idata = (SilcIDListData)new_server;
2382 /* Remove the old cache entry */
2383 if (!silc_idcache_del_by_context(server->local_list->servers, new_server)) {
2384 if (!silc_idcache_del_by_context(server->global_list->servers,
2386 SILC_LOG_INFO(("Unauthenticated %s attempted to register to "
2387 "network", (sock->type == SILC_SOCKET_TYPE_SERVER ?
2388 "server" : "router")));
2389 silc_server_disconnect_remote(server, sock,
2390 SILC_STATUS_ERR_NOT_AUTHENTICATED, NULL);
2391 if (sock->user_data)
2392 silc_server_free_sock_user_data(server, sock, NULL);
2398 /* Parse the incoming packet */
2399 ret = silc_buffer_unformat(buffer,
2400 SILC_STR_UI16_NSTRING_ALLOC(&id_string, &id_len),
2401 SILC_STR_UI16_NSTRING_ALLOC(&server_name,
2405 silc_free(id_string);
2406 silc_free(server_name);
2407 silc_server_disconnect_remote(server, sock,
2408 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2410 if (sock->user_data)
2411 silc_server_free_sock_user_data(server, sock, NULL);
2415 if (id_len > buffer->len) {
2416 silc_free(id_string);
2417 silc_free(server_name);
2418 silc_server_disconnect_remote(server, sock,
2419 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2421 if (sock->user_data)
2422 silc_server_free_sock_user_data(server, sock, NULL);
2427 server_name[255] = '\0';
2430 server_id = silc_id_str2id(id_string, id_len, SILC_ID_SERVER);
2432 silc_free(id_string);
2433 silc_free(server_name);
2434 silc_server_disconnect_remote(server, sock,
2435 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2437 if (sock->user_data)
2438 silc_server_free_sock_user_data(server, sock, NULL);
2441 silc_free(id_string);
2443 /* Check for valid server ID */
2444 if (!silc_id_is_valid_server_id(server, server_id, sock)) {
2445 SILC_LOG_INFO(("Invalid server ID sent by %s (%s)",
2446 sock->ip, sock->hostname));
2447 silc_server_disconnect_remote(server, sock,
2448 SILC_STATUS_ERR_BAD_SERVER_ID, NULL);
2449 if (sock->user_data)
2450 silc_server_free_sock_user_data(server, sock, NULL);
2451 silc_free(server_name);
2455 /* Check that we do not have this ID already */
2456 server_entry = silc_idlist_find_server_by_id(server->local_list,
2457 server_id, TRUE, NULL);
2459 silc_idcache_del_by_context(server->local_list->servers, server_entry);
2461 server_entry = silc_idlist_find_server_by_id(server->global_list,
2462 server_id, TRUE, NULL);
2464 silc_idcache_del_by_context(server->global_list->servers, server_entry);
2467 /* Update server entry */
2468 idata->status |= SILC_IDLIST_STATUS_REGISTERED;
2469 new_server->server_name = server_name;
2470 new_server->id = server_id;
2472 SILC_LOG_DEBUG(("New server id(%s)",
2473 silc_id_render(server_id, SILC_ID_SERVER)));
2475 /* Add again the entry to the ID cache. */
2476 silc_idcache_add(local ? server->local_list->servers :
2477 server->global_list->servers, server_name, server_id,
2478 new_server, 0, NULL);
2480 /* Distribute the information about new server in the SILC network
2481 to our router. If we are normal server we won't send anything
2482 since this connection must be our router connection. */
2483 if (server->server_type == SILC_ROUTER && !server->standalone &&
2484 SILC_PRIMARY_ROUTE(server) != sock)
2485 silc_server_send_new_id(server, SILC_PRIMARY_ROUTE(server),
2486 TRUE, new_server->id, SILC_ID_SERVER,
2487 silc_id_get_len(server_id, SILC_ID_SERVER));
2489 if (server->server_type == SILC_ROUTER) {
2490 /* Distribute to backup routers */
2491 SilcBuffer idp = silc_id_payload_encode(new_server->id, SILC_ID_SERVER);
2492 silc_server_backup_send(server, sock->user_data, SILC_PACKET_NEW_ID, 0,
2493 idp->data, idp->len, FALSE, TRUE);
2494 silc_buffer_free(idp);
2497 server->stat.cell_servers++;
2500 /* Check whether this router connection has been replaced by an
2501 backup router. If it has been then we'll disable the server and will
2502 ignore everything it will send until the backup router resuming
2503 protocol has been completed. */
2504 if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
2505 silc_server_backup_replaced_get(server, server_id, NULL)) {
2506 /* Send packet to the server indicating that it cannot use this
2507 connection as it has been replaced by backup router. */
2508 SilcBuffer packet = silc_buffer_alloc(2);
2509 silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
2510 silc_buffer_format(packet,
2511 SILC_STR_UI_CHAR(SILC_SERVER_BACKUP_REPLACED),
2512 SILC_STR_UI_CHAR(0),
2514 silc_server_packet_send(server, sock,
2515 SILC_PACKET_RESUME_ROUTER, 0,
2516 packet->data, packet->len, TRUE);
2517 silc_buffer_free(packet);
2519 /* Mark the router disabled. The data sent earlier will go but nothing
2520 after this does not go to this connection. */
2521 idata->status |= SILC_IDLIST_STATUS_DISABLED;
2523 /* If it is router announce our stuff to it. */
2524 if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
2525 server->server_type == SILC_ROUTER) {
2526 silc_server_announce_servers(server, FALSE, 0, sock);
2527 silc_server_announce_clients(server, 0, sock);
2528 silc_server_announce_channels(server, 0, sock);
2531 /* Announce our information to backup router */
2532 if (new_server->server_type == SILC_BACKUP_ROUTER &&
2533 sock->type == SILC_SOCKET_TYPE_SERVER &&
2534 server->server_type == SILC_ROUTER) {
2535 silc_server_announce_servers(server, TRUE, 0, sock);
2536 silc_server_announce_clients(server, 0, sock);
2537 silc_server_announce_channels(server, 0, sock);
2540 /* If backup router, mark it as one of ours. This server is considered
2541 to be backup router after this setting. */
2542 if (new_server->server_type == SILC_BACKUP_ROUTER) {
2543 SilcServerConfigRouter *backup;
2544 backup = silc_server_config_find_backup_conn(server, sock->ip);
2546 backup = silc_server_config_find_backup_conn(server, sock->hostname);
2548 /* Add as our backup router */
2549 silc_server_backup_add(server, new_server, backup->backup_replace_ip,
2550 backup->backup_replace_port,
2551 backup->backup_local);
2555 /* By default the servers connected to backup router are disabled
2556 until backup router has become the primary */
2557 if (server->server_type == SILC_BACKUP_ROUTER &&
2558 sock->type == SILC_SOCKET_TYPE_SERVER)
2559 idata->status |= SILC_IDLIST_STATUS_DISABLED;
2565 /* Processes incoming New ID packet. New ID Payload is used to distribute
2566 information about newly registered clients and servers. */
2568 static void silc_server_new_id_real(SilcServer server,
2569 SilcSocketConnection sock,
2570 SilcPacketContext *packet,
2573 SilcBuffer buffer = packet->buffer;
2575 SilcServerEntry router, server_entry;
2576 SilcSocketConnection router_sock;
2581 SILC_LOG_DEBUG(("Processing new ID"));
2583 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2584 server->server_type == SILC_SERVER ||
2585 packet->src_id_type != SILC_ID_SERVER)
2588 idp = silc_id_payload_parse(buffer->data, buffer->len);
2592 id_type = silc_id_payload_get_type(idp);
2594 /* Normal server cannot have other normal server connections */
2595 server_entry = (SilcServerEntry)sock->user_data;
2596 if (id_type == SILC_ID_SERVER && sock->type == SILC_SOCKET_TYPE_SERVER &&
2597 server_entry->server_type == SILC_SERVER)
2600 id = silc_id_payload_get_id(idp);
2604 /* If the packet is coming from server then use the sender as the
2605 origin of the the packet. If it came from router then check the real
2606 sender of the packet and use that as the origin. */
2607 if (sock->type == SILC_SOCKET_TYPE_SERVER) {
2608 id_list = server->local_list;
2610 router = sock->user_data;
2612 /* If the sender is backup router and ID is server (and we are not
2613 backup router) then switch the entry to global list. */
2614 if (server_entry->server_type == SILC_BACKUP_ROUTER &&
2615 id_type == SILC_ID_SERVER &&
2616 server->id_entry->server_type != SILC_BACKUP_ROUTER) {
2617 id_list = server->global_list;
2618 router_sock = server->router ? SILC_PRIMARY_ROUTE(server) : sock;
2621 void *sender_id = silc_id_str2id(packet->src_id, packet->src_id_len,
2622 packet->src_id_type);
2623 router = silc_idlist_find_server_by_id(server->global_list,
2624 sender_id, TRUE, NULL);
2626 router = silc_idlist_find_server_by_id(server->local_list,
2627 sender_id, TRUE, NULL);
2628 silc_free(sender_id);
2630 id_list = server->global_list;
2637 case SILC_ID_CLIENT:
2639 SilcClientEntry entry;
2641 /* Check that we do not have this client already */
2642 entry = silc_idlist_find_client_by_id(server->global_list,
2643 id, server->server_type,
2646 entry = silc_idlist_find_client_by_id(server->local_list,
2647 id, server->server_type,
2650 SILC_LOG_DEBUG(("Ignoring client that we already have"));
2654 SILC_LOG_DEBUG(("New client id(%s) from [%s] %s",
2655 silc_id_render(id, SILC_ID_CLIENT),
2656 sock->type == SILC_SOCKET_TYPE_SERVER ?
2657 "Server" : "Router", sock->hostname));
2659 /* As a router we keep information of all global information in our
2660 global list. Cell wide information however is kept in the local
2662 entry = silc_idlist_add_client(id_list, NULL, NULL, NULL,
2663 id, router, NULL, 0);
2665 SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
2667 /* Inform the sender that the ID is not usable */
2668 silc_server_send_notify_signoff(server, sock, FALSE, id, NULL);
2671 entry->nickname = NULL;
2672 entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
2674 if (sock->type == SILC_SOCKET_TYPE_SERVER)
2675 server->stat.cell_clients++;
2676 server->stat.clients++;
2678 /* Check if anyone is watching this nickname */
2679 if (server->server_type == SILC_ROUTER && id_list == server->local_list)
2680 silc_server_check_watcher_list(server, entry, NULL, 0);
2684 case SILC_ID_SERVER:
2686 SilcServerEntry entry;
2688 /* If the ID is mine, ignore it. */
2689 if (SILC_ID_SERVER_COMPARE(id, server->id)) {
2690 SILC_LOG_DEBUG(("Ignoring my own ID as new ID"));
2694 /* If the ID is the sender's ID, ignore it (we have it already) */
2695 if (SILC_ID_SERVER_COMPARE(id, router->id)) {
2696 SILC_LOG_DEBUG(("Ignoring sender's own ID"));
2700 /* Check that we do not have this server already */
2701 entry = silc_idlist_find_server_by_id(server->global_list,
2702 id, server->server_type,
2705 entry = silc_idlist_find_server_by_id(server->local_list,
2706 id, server->server_type,
2709 SILC_LOG_DEBUG(("Ignoring server that we already have"));
2713 SILC_LOG_DEBUG(("New server id(%s) from [%s] %s",
2714 silc_id_render(id, SILC_ID_SERVER),
2715 sock->type == SILC_SOCKET_TYPE_SERVER ?
2716 "Server" : "Router", sock->hostname));
2718 /* As a router we keep information of all global information in our
2719 global list. Cell wide information however is kept in the local
2721 entry = silc_idlist_add_server(id_list, NULL, 0, id, router,
2724 SILC_LOG_ERROR(("Could not add new server to the ID Cache"));
2727 entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
2729 if (sock->type == SILC_SOCKET_TYPE_SERVER)
2730 server->stat.cell_servers++;
2731 server->stat.servers++;
2735 case SILC_ID_CHANNEL:
2736 SILC_LOG_ERROR(("Channel cannot be registered with NEW_ID packet"));
2745 /* If the sender of this packet is server and we are router we need to
2746 broadcast this packet to other routers in the network. */
2747 if (broadcast && server->server_type == SILC_ROUTER &&
2748 sock->type == SILC_SOCKET_TYPE_SERVER &&
2749 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2750 SILC_LOG_DEBUG(("Broadcasting received New ID packet"));
2751 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
2753 packet->flags | SILC_PACKET_FLAG_BROADCAST,
2754 buffer->data, buffer->len, FALSE);
2755 silc_server_backup_send(server, sock->user_data,
2756 packet->type, packet->flags,
2757 packet->buffer->data, packet->buffer->len,
2762 silc_id_payload_free(idp);
2766 /* Processes incoming New ID packet. New ID Payload is used to distribute
2767 information about newly registered clients and servers. */
2769 void silc_server_new_id(SilcServer server, SilcSocketConnection sock,
2770 SilcPacketContext *packet)
2772 silc_server_new_id_real(server, sock, packet, TRUE);
2775 /* Receoved New Id List packet, list of New ID payloads inside one
2776 packet. Process the New ID payloads one by one. */
2778 void silc_server_new_id_list(SilcServer server, SilcSocketConnection sock,
2779 SilcPacketContext *packet)
2781 SilcPacketContext *new_id;
2785 SILC_LOG_DEBUG(("Processing New ID List"));
2787 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2788 packet->src_id_type != SILC_ID_SERVER)
2791 /* If the sender of this packet is server and we are router we need to
2792 broadcast this packet to other routers in the network. Broadcast
2793 this list packet instead of multiple New ID packets. */
2794 if (server->server_type == SILC_ROUTER &&
2795 sock->type == SILC_SOCKET_TYPE_SERVER &&
2796 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2797 SILC_LOG_DEBUG(("Broadcasting received New ID List packet"));
2798 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
2800 packet->flags | SILC_PACKET_FLAG_BROADCAST,
2801 packet->buffer->data,
2802 packet->buffer->len, FALSE);
2803 silc_server_backup_send(server, sock->user_data,
2804 packet->type, packet->flags,
2805 packet->buffer->data, packet->buffer->len,
2809 /* Make copy of the original packet context, except for the actual
2810 data buffer, which we will here now fetch from the original buffer. */
2811 new_id = silc_packet_context_alloc();
2812 new_id->type = SILC_PACKET_NEW_ID;
2813 new_id->flags = packet->flags & (~SILC_PACKET_FLAG_LIST);
2814 new_id->src_id = packet->src_id;
2815 new_id->src_id_len = packet->src_id_len;
2816 new_id->src_id_type = packet->src_id_type;
2817 new_id->dst_id = packet->dst_id;
2818 new_id->dst_id_len = packet->dst_id_len;
2819 new_id->dst_id_type = packet->dst_id_type;
2821 idp = silc_buffer_alloc(256);
2822 new_id->buffer = idp;
2824 while (packet->buffer->len) {
2825 SILC_GET16_MSB(id_len, packet->buffer->data + 2);
2826 if ((id_len > packet->buffer->len) ||
2827 (id_len > idp->truelen))
2830 silc_buffer_pull_tail(idp, 4 + id_len);
2831 silc_buffer_put(idp, packet->buffer->data, 4 + id_len);
2833 /* Process the New ID */
2834 silc_server_new_id_real(server, sock, new_id, FALSE);
2836 silc_buffer_push_tail(idp, 4 + id_len);
2837 silc_buffer_pull(packet->buffer, 4 + id_len);
2840 silc_buffer_free(idp);
2844 /* Received New Channel packet. Information about new channels in the
2845 network are distributed using this packet. Save the information about
2846 the new channel. This usually comes from router but also normal server
2847 can send this to notify channels it has when it connects to us. */
2849 void silc_server_new_channel(SilcServer server,
2850 SilcSocketConnection sock,
2851 SilcPacketContext *packet)
2853 SilcChannelPayload payload;
2854 SilcChannelID *channel_id;
2856 SilcUInt32 name_len;
2858 SilcUInt32 id_len, cipher_len;
2859 SilcServerEntry server_entry;
2860 SilcChannelEntry channel;
2863 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2864 packet->src_id_type != SILC_ID_SERVER ||
2865 server->server_type == SILC_SERVER)
2868 /* Parse the channel payload */
2869 payload = silc_channel_payload_parse(packet->buffer->data,
2870 packet->buffer->len);
2874 /* Get the channel ID */
2875 channel_id = silc_channel_get_id_parse(payload);
2877 silc_channel_payload_free(payload);
2881 channel_name = silc_channel_get_name(payload, &name_len);
2883 channel_name[255] = '\0';
2885 id = silc_channel_get_id(payload, &id_len);
2887 server_entry = (SilcServerEntry)sock->user_data;
2889 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
2890 /* Add the channel to global list as it is coming from router. It
2891 cannot be our own channel as it is coming from router. */
2893 /* Check that we don't already have this channel */
2894 channel = silc_idlist_find_channel_by_name(server->local_list,
2895 channel_name, NULL);
2897 channel = silc_idlist_find_channel_by_name(server->global_list,
2898 channel_name, NULL);
2900 SILC_LOG_DEBUG(("New channel id(%s) from [Router] %s",
2901 silc_id_render(channel_id, SILC_ID_CHANNEL),
2905 silc_idlist_add_channel(server->global_list, strdup(channel_name),
2906 0, channel_id, sock->user_data, NULL, NULL, 0);
2908 silc_channel_payload_free(payload);
2909 silc_free(channel_id);
2912 channel->disabled = TRUE; /* Disabled until someone JOINs */
2914 server->stat.channels++;
2915 if (server->server_type == SILC_ROUTER)
2916 channel->users_resolved = TRUE;
2919 /* The channel is coming from our server, thus it is in our cell
2920 we will add it to our local list. */
2923 SILC_LOG_DEBUG(("Channel id(%s) from [Server] %s",
2924 silc_id_render(channel_id, SILC_ID_CHANNEL),
2927 /* Check that we don't already have this channel */
2928 channel = silc_idlist_find_channel_by_name(server->local_list,
2929 channel_name, NULL);
2931 channel = silc_idlist_find_channel_by_name(server->global_list,
2932 channel_name, NULL);
2934 /* If the channel does not exist, then create it. This creates a new
2935 key to the channel as well that we will send to the server. */
2937 SILC_LOG_DEBUG(("Channel is new to us"));
2939 /* The protocol says that the Channel ID's IP address must be based
2940 on the router's IP address. Check whether the ID is based in our
2941 IP and if it is not then create a new ID and enforce the server
2942 to switch the ID. */
2943 if (server_entry->server_type != SILC_BACKUP_ROUTER &&
2944 !SILC_ID_COMPARE(channel_id, server->id, server->id->ip.data_len)) {
2946 SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
2947 if (silc_id_create_channel_id(server, server->id, server->rng, &tmp)) {
2948 silc_server_send_notify_channel_change(server, sock, FALSE,
2950 silc_channel_payload_free(payload);
2951 silc_free(channel_id);
2955 /* Wait that server re-announces this channel */
2959 /* Create the channel with the provided Channel ID */
2960 channel = silc_server_create_new_channel_with_id(server, NULL, NULL,
2964 silc_channel_payload_free(payload);
2965 silc_free(channel_id);
2968 channel->disabled = TRUE; /* Disabled until someone JOINs */
2970 #if 0 /* We assume that CMODE_CHANGE notify is sent to us after this. */
2972 /* XXX Dunno if this is supposed to be set in any server type. If set
2973 here the CMODE_CHANGE that may follow sets mode that we already
2974 have, and we may loose data from the CMODE_CHANGE notify. */
2975 if (server_entry->server_type != SILC_BACKUP_ROUTER)
2976 channel->mode = silc_channel_get_mode(payload);
2979 /* Send the new channel key to the server */
2980 id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
2981 id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
2982 cipher = silc_cipher_get_name(channel->channel_key);
2983 cipher_len = strlen(cipher);
2984 chk = silc_channel_key_payload_encode(id_len, id,
2986 channel->key_len / 8,
2988 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
2989 chk->data, chk->len, FALSE);
2990 silc_buffer_free(chk);
2993 /* The channel exist by that name, check whether the ID's match.
2994 If they don't then we'll force the server to use the ID we have.
2995 We also create a new key for the channel. */
2996 SilcBuffer modes = NULL, users = NULL, users_modes = NULL;
2998 SILC_LOG_DEBUG(("Channel already exists"));
3000 if (!SILC_ID_CHANNEL_COMPARE(channel_id, channel->id)) {
3001 /* They don't match, send CHANNEL_CHANGE notify to the server to
3002 force the ID change. */
3003 SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
3004 silc_server_send_notify_channel_change(server, sock, FALSE,
3005 channel_id, channel->id);
3006 silc_channel_payload_free(payload);
3007 silc_free(channel_id);
3009 /* Wait that server re-announces this channel */
3013 #if 0 /* We will announce our CMODE anyway for this channel, so no need
3014 to check it (implicit enforce). */
3016 /* If the mode is different from what we have then enforce the
3018 mode = silc_channel_get_mode(payload);
3019 if (channel->mode != mode) {
3020 SILC_LOG_DEBUG(("Forcing the server to change channel mode"));
3021 silc_server_send_notify_cmode(server, sock, FALSE, channel,
3022 channel->mode, server->id,
3023 SILC_ID_SERVER, channel->cipher,
3025 channel->passphrase,
3026 channel->founder_key);
3030 /* Create new key for the channel and send it to the server and
3031 everybody else possibly on the channel. */
3032 if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
3034 if (silc_hash_table_count(channel->user_list)) {
3035 if (!silc_server_create_channel_key(server, channel, 0)) {
3036 silc_channel_payload_free(payload);
3037 silc_free(channel_id);
3041 /* Send to the channel */
3042 silc_server_send_channel_key(server, sock, channel, FALSE);
3045 /* Send to the server */
3046 id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
3047 id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
3048 cipher = silc_cipher_get_name(channel->channel_key);
3049 cipher_len = strlen(cipher);
3050 chk = silc_channel_key_payload_encode(id_len, id,
3052 channel->key_len / 8,
3054 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
3055 chk->data, chk->len, FALSE);
3056 silc_buffer_free(chk);
3060 silc_free(channel_id);
3062 /* Since the channel is coming from server and we also know about it
3063 then send the JOIN notify to the server so that it see's our
3064 users on the channel "joining" the channel. */
3065 silc_server_announce_get_channel_users(server, channel, &modes, &users,
3068 silc_buffer_push(users, users->data - users->head);
3069 silc_server_packet_send(server, sock,
3070 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
3071 users->data, users->len, FALSE);
3072 silc_buffer_free(users);
3075 silc_buffer_push(modes, modes->data - modes->head);
3076 silc_server_packet_send_dest(server, sock,
3077 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
3078 channel->id, SILC_ID_CHANNEL,
3079 modes->data, modes->len, FALSE);
3080 silc_buffer_free(modes);
3083 silc_buffer_push(users_modes, users_modes->data - users_modes->head);
3084 silc_server_packet_send_dest(server, sock,
3085 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
3086 channel->id, SILC_ID_CHANNEL,
3088 users_modes->len, FALSE);
3089 silc_buffer_free(users_modes);
3091 if (channel->topic) {
3092 silc_server_send_notify_topic_set(server, sock,
3093 server->server_type == SILC_ROUTER ?
3094 TRUE : FALSE, channel,
3095 server->id, SILC_ID_SERVER,
3101 /* If the sender of this packet is server and we are router we need to
3102 broadcast this packet to other routers in the network. Broadcast
3103 this list packet instead of multiple New Channel packets. */
3104 if (server->server_type == SILC_ROUTER &&
3105 sock->type == SILC_SOCKET_TYPE_SERVER &&
3106 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
3107 SILC_LOG_DEBUG(("Broadcasting received New Channel packet"));
3108 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3110 packet->flags | SILC_PACKET_FLAG_BROADCAST,
3111 packet->buffer->data,
3112 packet->buffer->len, FALSE);
3113 silc_server_backup_send(server, sock->user_data,
3114 packet->type, packet->flags,
3115 packet->buffer->data, packet->buffer->len,
3119 silc_channel_payload_free(payload);
3122 /* Received New Channel List packet, list of New Channel List payloads inside
3123 one packet. Process the New Channel payloads one by one. */
3125 void silc_server_new_channel_list(SilcServer server,
3126 SilcSocketConnection sock,
3127 SilcPacketContext *packet)
3129 SilcPacketContext *new;
3131 SilcUInt16 len1, len2;
3133 SILC_LOG_DEBUG(("Processing New Channel List"));
3135 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
3136 packet->src_id_type != SILC_ID_SERVER ||
3137 server->server_type == SILC_SERVER)
3140 /* Make copy of the original packet context, except for the actual
3141 data buffer, which we will here now fetch from the original buffer. */
3142 new = silc_packet_context_alloc();
3143 new->type = SILC_PACKET_NEW_CHANNEL;
3144 new->flags = packet->flags & (~SILC_PACKET_FLAG_LIST);
3145 new->src_id = packet->src_id;
3146 new->src_id_len = packet->src_id_len;
3147 new->src_id_type = packet->src_id_type;
3148 new->dst_id = packet->dst_id;
3149 new->dst_id_len = packet->dst_id_len;
3150 new->dst_id_type = packet->dst_id_type;
3152 buffer = silc_buffer_alloc(512);
3153 new->buffer = buffer;
3155 while (packet->buffer->len) {
3156 SILC_GET16_MSB(len1, packet->buffer->data);
3157 if ((len1 > packet->buffer->len) ||
3158 (len1 > buffer->truelen))
3161 SILC_GET16_MSB(len2, packet->buffer->data + 2 + len1);
3162 if ((len2 > packet->buffer->len) ||
3163 (len2 > buffer->truelen))
3166 silc_buffer_pull_tail(buffer, 8 + len1 + len2);
3167 silc_buffer_put(buffer, packet->buffer->data, 8 + len1 + len2);
3169 /* Process the New Channel */
3170 silc_server_new_channel(server, sock, new);
3172 silc_buffer_push_tail(buffer, 8 + len1 + len2);
3173 silc_buffer_pull(packet->buffer, 8 + len1 + len2);
3176 silc_buffer_free(buffer);
3180 /* Received key agreement packet. This packet is never for us. It is to
3181 the client in the packet's destination ID. Sending of this sort of packet
3182 equals sending private message, ie. it is sent point to point from
3183 one client to another. */
3185 void silc_server_key_agreement(SilcServer server,
3186 SilcSocketConnection sock,
3187 SilcPacketContext *packet)
3189 SilcSocketConnection dst_sock;
3190 SilcIDListData idata;
3192 SILC_LOG_DEBUG(("Start"));
3194 if (packet->src_id_type != SILC_ID_CLIENT ||
3195 packet->dst_id_type != SILC_ID_CLIENT)
3198 if (!packet->dst_id)
3201 /* Get the route to the client */
3202 dst_sock = silc_server_get_client_route(server, packet->dst_id,
3203 packet->dst_id_len, NULL,
3208 /* Relay the packet */
3209 silc_server_relay_packet(server, dst_sock, idata->send_key,
3210 idata->hmac_send, idata->psn_send++,
3214 /* Received connection auth request packet that is used during connection
3215 phase to resolve the mandatory authentication method. This packet can
3216 actually be received at anytime but usually it is used only during
3217 the connection authentication phase. Now, protocol says that this packet
3218 can come from client or server, however, we support only this coming
3219 from client and expect that server always knows what authentication
3222 void silc_server_connection_auth_request(SilcServer server,
3223 SilcSocketConnection sock,
3224 SilcPacketContext *packet)
3226 SilcServerConfigClient *client = NULL;
3227 SilcUInt16 conn_type;
3229 SilcAuthMethod auth_meth = SILC_AUTH_NONE;
3231 if (packet->src_id_type && packet->src_id_type != SILC_ID_CLIENT) {
3232 SILC_LOG_DEBUG(("Request not from client"));
3236 /* Parse the payload */
3237 ret = silc_buffer_unformat(packet->buffer,
3238 SILC_STR_UI_SHORT(&conn_type),
3239 SILC_STR_UI_SHORT(NULL),
3244 if (conn_type != SILC_SOCKET_TYPE_CLIENT)
3247 /* Get the authentication method for the client */
3248 auth_meth = SILC_AUTH_NONE;
3249 client = silc_server_config_find_client(server, sock->ip);
3251 client = silc_server_config_find_client(server, sock->hostname);
3253 if (client->passphrase) {
3254 if (client->publickeys && !server->config->prefer_passphrase_auth)
3255 auth_meth = SILC_AUTH_PUBLIC_KEY;
3257 auth_meth = SILC_AUTH_PASSWORD;
3258 } else if (client->publickeys)
3259 auth_meth = SILC_AUTH_PUBLIC_KEY;
3262 SILC_LOG_DEBUG(("Authentication method is [%s]",
3263 (auth_meth == SILC_AUTH_NONE ? "None" :
3264 auth_meth == SILC_AUTH_PASSWORD ? "Passphrase" :
3265 "Digital signatures")));
3267 /* Send it back to the client */
3268 silc_server_send_connection_auth_request(server, sock, conn_type, auth_meth);
3271 /* Received REKEY packet. The sender of the packet wants to regenerate
3272 its session keys. This starts the REKEY protocol. */
3274 void silc_server_rekey(SilcServer server,
3275 SilcSocketConnection sock,
3276 SilcPacketContext *packet)
3278 SilcProtocol protocol;
3279 SilcServerRekeyInternalContext *proto_ctx;
3280 SilcIDListData idata = (SilcIDListData)sock->user_data;
3282 SILC_LOG_DEBUG(("Start"));
3284 /* Allocate internal protocol context. This is sent as context
3286 proto_ctx = silc_calloc(1, sizeof(*proto_ctx));
3287 proto_ctx->server = (void *)server;
3288 proto_ctx->sock = sock;
3289 proto_ctx->responder = TRUE;
3290 proto_ctx->pfs = idata->rekey->pfs;
3292 /* Perform rekey protocol. Will call the final callback after the
3293 protocol is over. */
3294 silc_protocol_alloc(SILC_PROTOCOL_SERVER_REKEY,
3295 &protocol, proto_ctx, silc_server_rekey_final);
3296 sock->protocol = protocol;
3298 if (proto_ctx->pfs == FALSE)
3299 /* Run the protocol */
3300 silc_protocol_execute(protocol, server->schedule, 0, 0);
3303 /* Received file transger packet. This packet is never for us. It is to
3304 the client in the packet's destination ID. Sending of this sort of packet
3305 equals sending private message, ie. it is sent point to point from
3306 one client to another. */
3308 void silc_server_ftp(SilcServer server,
3309 SilcSocketConnection sock,
3310 SilcPacketContext *packet)
3312 SilcSocketConnection dst_sock;
3313 SilcIDListData idata;
3315 SILC_LOG_DEBUG(("Start"));
3317 if (packet->src_id_type != SILC_ID_CLIENT ||
3318 packet->dst_id_type != SILC_ID_CLIENT)
3321 if (!packet->dst_id)
3324 /* Get the route to the client */
3325 dst_sock = silc_server_get_client_route(server, packet->dst_id,
3326 packet->dst_id_len, NULL,
3331 /* Relay the packet */
3332 silc_server_relay_packet(server, dst_sock, idata->send_key,
3333 idata->hmac_send, idata->psn_send++,
3339 SilcSocketConnection sock;
3340 SilcPacketContext *packet;
3342 } *SilcServerResumeResolve;
3344 SILC_SERVER_CMD_FUNC(resume_resolve)
3346 SilcServerResumeResolve r = (SilcServerResumeResolve)context;
3347 SilcServer server = r->server;
3348 SilcSocketConnection sock = r->sock;
3349 SilcServerCommandReplyContext reply = context2;
3350 SilcClientEntry client;
3352 SILC_LOG_DEBUG(("Start"));
3354 if (!reply || !silc_command_get_status(reply->payload, NULL, NULL)) {
3355 SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
3356 "closing connection", sock->hostname, sock->ip));
3357 silc_server_disconnect_remote(server, sock,
3358 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3359 "Resuming not possible");
3360 if (sock->user_data)
3361 silc_server_free_sock_user_data(server, sock, NULL);
3365 if (reply && silc_command_get(reply->payload) == SILC_COMMAND_WHOIS) {
3366 /* Get entry to the client, and resolve it if we don't have it. */
3367 client = silc_idlist_find_client_by_id(server->local_list,
3368 r->data, TRUE, NULL);
3370 client = silc_idlist_find_client_by_id(server->global_list,
3371 r->data, TRUE, NULL);
3373 SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
3374 "closing connection", sock->hostname, sock->ip));
3375 silc_server_disconnect_remote(server, sock,
3376 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3377 "Resuming not possible");
3378 if (sock->user_data)
3379 silc_server_free_sock_user_data(server, sock, NULL);
3384 if (!(client->mode & SILC_UMODE_DETACHED)) {
3385 SILC_LOG_ERROR(("Client %s (%s) tried to resume un-detached client, "
3386 "closing connection", sock->hostname, sock->ip));
3387 silc_server_disconnect_remote(server, sock,
3388 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3389 "Resuming not possible");
3390 if (sock->user_data)
3391 silc_server_free_sock_user_data(server, sock, NULL);
3395 client->data.status |= SILC_IDLIST_STATUS_RESUME_RES;
3398 /* Reprocess the packet */
3399 silc_server_resume_client(server, sock, r->packet);
3402 silc_socket_free(r->sock);
3403 silc_packet_context_free(r->packet);
3408 /* Received client resuming packet. This is used to resume detached
3409 client session. It can be sent by the client who wishes to resume
3410 but this is also sent by servers and routers to notify other routers
3411 that the client is not detached anymore. */
3413 void silc_server_resume_client(SilcServer server,
3414 SilcSocketConnection sock,
3415 SilcPacketContext *packet)
3417 SilcBuffer buffer = packet->buffer, buf;
3418 SilcIDListData idata;
3419 SilcIDCacheEntry id_cache = NULL;
3420 SilcClientEntry detached_client;
3421 SilcClientID *client_id = NULL;
3422 unsigned char *id_string, *auth = NULL;
3423 SilcUInt16 id_len, auth_len = 0;
3424 int ret, nickfail = 0;
3425 bool resolved, local, nick_change = FALSE, resolve = FALSE;
3426 SilcChannelEntry channel;
3427 SilcHashTableList htl;
3428 SilcChannelClientEntry chl;
3429 SilcServerResumeResolve r;
3432 ret = silc_buffer_unformat(buffer,
3433 SILC_STR_UI16_NSTRING(&id_string, &id_len),
3436 client_id = silc_id_str2id(id_string, id_len, SILC_ID_CLIENT);
3438 if (sock->type == SILC_SOCKET_TYPE_CLIENT) {
3439 /* Client send this and is attempting to resume to old client session */
3440 SilcClientEntry client;
3444 silc_buffer_pull(buffer, 2 + id_len);
3445 auth = buffer->data;
3446 auth_len = buffer->len;
3447 silc_buffer_push(buffer, 2 + id_len);
3450 if (!client_id || auth_len < 128) {
3451 SILC_LOG_ERROR(("Client %s (%s) sent incomplete resume information, "
3452 "closing connection", sock->hostname, sock->ip));
3453 silc_server_disconnect_remote(server, sock,
3454 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3455 "Resuming not possible");
3456 if (sock->user_data)
3457 silc_server_free_sock_user_data(server, sock, NULL);
3458 silc_free(client_id);
3462 /* Take client entry of this connection */
3463 client = (SilcClientEntry)sock->user_data;
3464 idata = (SilcIDListData)client;
3466 /* Get entry to the client, and resolve it if we don't have it. */
3467 detached_client = silc_server_query_client(server, client_id, FALSE,
3469 if (!detached_client) {
3471 /* The client info is being resolved. Reprocess this packet after
3472 receiving the reply to the query. */
3473 SILC_LOG_DEBUG(("Resolving client"));
3474 r = silc_calloc(1, sizeof(*r));
3478 r->sock = silc_socket_dup(sock);
3479 r->packet = silc_packet_context_dup(packet);
3480 r->data = client_id;
3481 silc_server_command_pending(server, SILC_COMMAND_WHOIS,
3483 silc_server_command_resume_resolve, r);
3485 SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
3486 "closing connection", sock->hostname, sock->ip));
3487 silc_server_disconnect_remote(server, sock,
3488 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3489 "Resuming not possible");
3490 if (sock->user_data)
3491 silc_server_free_sock_user_data(server, sock, NULL);
3492 silc_free(client_id);
3497 if (!(detached_client->mode & SILC_UMODE_DETACHED))
3499 if (!silc_hash_table_count(detached_client->channels) &&
3500 detached_client->router)
3502 if (!detached_client->nickname)
3504 if (detached_client->data.status & SILC_IDLIST_STATUS_RESUME_RES)
3508 if (server->server_type == SILC_SERVER && !server->standalone) {
3509 /* The client info is being resolved. Reprocess this packet after
3510 receiving the reply to the query. */
3511 SILC_LOG_DEBUG(("Resolving client info"));
3512 silc_server_query_client(server, client_id, TRUE, NULL);
3513 r = silc_calloc(1, sizeof(*r));
3517 r->sock = silc_socket_dup(sock);
3518 r->packet = silc_packet_context_dup(packet);
3519 r->data = client_id;
3520 silc_server_command_pending(server, SILC_COMMAND_WHOIS,
3522 silc_server_command_resume_resolve, r);
3525 if (server->server_type == SILC_SERVER) {
3526 SILC_LOG_ERROR(("Client %s (%s) tried to resume un-detached client, "
3527 "closing connection", sock->hostname, sock->ip));
3528 silc_server_disconnect_remote(server, sock,
3529 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3530 "Resuming not possible");
3531 if (sock->user_data)
3532 silc_server_free_sock_user_data(server, sock, NULL);
3533 silc_free(client_id);
3538 /* Check that we have the public key of the client, if not then we must
3539 resolve it first. */
3540 if (!detached_client->data.public_key) {
3541 if (server->server_type == SILC_SERVER && server->standalone) {
3542 SILC_LOG_ERROR(("Detached client's public key not present, "
3543 "closing connection"));
3544 silc_server_disconnect_remote(server, sock,
3545 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3546 "Resuming not possible");
3547 if (sock->user_data)
3548 silc_server_free_sock_user_data(server, sock, NULL);
3549 silc_free(client_id);
3551 /* We must retrieve the detached client's public key by sending
3552 GETKEY command. Reprocess this packet after receiving the key */
3553 SilcBuffer idp = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
3554 SilcSocketConnection dest_sock =
3555 silc_server_get_client_route(server, NULL, 0, client_id, NULL, NULL);
3557 SILC_LOG_DEBUG(("Resolving client public key"));
3559 silc_server_send_command(server, dest_sock ? dest_sock :
3560 SILC_PRIMARY_ROUTE(server),
3561 SILC_COMMAND_GETKEY, ++server->cmd_ident,
3562 1, 1, idp->data, idp->len);
3564 r = silc_calloc(1, sizeof(*r));
3566 silc_free(client_id);
3571 r->sock = silc_socket_dup(sock);
3572 r->packet = silc_packet_context_dup(packet);
3573 silc_server_command_pending(server, SILC_COMMAND_GETKEY,
3575 silc_server_command_resume_resolve, r);
3577 silc_buffer_free(idp);
3579 silc_free(client_id);
3581 } else if (!silc_pkcs_public_key_compare(detached_client->data.public_key,
3582 idata->public_key)) {
3583 /* We require that the connection and resuming authentication data
3584 must be using same key pair. */
3585 SILC_LOG_ERROR(("Resuming attempted with wrong public key, "
3586 "closing connection"));
3587 silc_server_disconnect_remote(server, sock,
3588 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3589 "Resuming not possible");
3590 if (sock->user_data)
3591 silc_server_free_sock_user_data(server, sock, NULL);
3592 silc_free(client_id);
3596 /* Verify the authentication payload. This has to be successful in
3597 order to allow the resuming */
3599 !silc_auth_verify_data(auth, auth_len, SILC_AUTH_PUBLIC_KEY,
3600 detached_client->data.public_key, 0,
3601 idata->hash, detached_client->id,
3603 SILC_LOG_ERROR(("Client %s (%s) resume authentication failed, "
3604 "closing connection", sock->hostname, sock->ip));
3605 silc_server_disconnect_remote(server, sock,
3606 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3607 "Resuming not possible");
3608 if (sock->user_data)
3609 silc_server_free_sock_user_data(server, sock, NULL);
3610 silc_free(client_id);
3614 /* Now resume the client to the network */
3616 silc_schedule_task_del_by_context(server->schedule, detached_client);
3617 sock->user_data = detached_client;
3618 detached_client->connection = sock;
3620 /* Take new keys and stuff into use in the old entry */
3621 silc_idlist_del_data(detached_client);
3622 silc_idlist_add_data(detached_client, idata);
3623 detached_client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
3624 detached_client->data.status |= SILC_IDLIST_STATUS_RESUMED;
3625 detached_client->data.status |= SILC_IDLIST_STATUS_LOCAL;
3626 detached_client->data.status &= ~SILC_IDLIST_STATUS_RESUME_RES;
3627 detached_client->mode &= ~SILC_UMODE_DETACHED;
3628 server->stat.my_detached--;
3630 /* Send the RESUME_CLIENT packet to our primary router so that others
3631 know this client isn't detached anymore. */
3632 buf = silc_buffer_alloc_size(2 + id_len);
3633 silc_buffer_format(buf,
3634 SILC_STR_UI_SHORT(id_len),
3635 SILC_STR_UI_XNSTRING(id_string, id_len),
3638 /* Send to primary router */
3639 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3640 SILC_PACKET_RESUME_CLIENT, 0,
3641 buf->data, buf->len, TRUE);
3642 silc_server_backup_send(server, detached_client->router,
3643 SILC_PACKET_RESUME_CLIENT, 0,
3644 buf->data, buf->len, TRUE, TRUE);
3646 /* As router we must deliver this packet directly to the original
3647 server whom this client was earlier. */
3648 if (server->server_type == SILC_ROUTER && detached_client->router &&
3649 detached_client->router->server_type != SILC_ROUTER)
3650 silc_server_packet_send(server, detached_client->router->connection,
3651 SILC_PACKET_RESUME_CLIENT, 0,
3652 buf->data, buf->len, TRUE);
3653 silc_buffer_free(buf);
3655 detached_client->router = NULL;
3657 /* Delete this client entry since we're resuming to old one. */
3658 server->stat.my_clients--;
3659 server->stat.clients--;
3660 if (server->stat.cell_clients)
3661 server->stat.cell_clients--;
3662 silc_server_remove_from_channels(server, NULL, client, FALSE,
3663 NULL, FALSE, FALSE);
3664 silc_server_del_from_watcher_list(server, client);
3665 if (!silc_idlist_del_client(server->local_list, client))
3666 silc_idlist_del_client(server->global_list, client);
3667 client = detached_client;
3668 silc_free(client->servername);
3669 client->servername = strdup(server->server_name);
3671 /* If the ID is not based in our ID then change it */
3672 if (!SILC_ID_COMPARE(client->id, server->id, server->id->ip.data_len)) {
3673 silc_free(client_id);
3674 while (!silc_id_create_client_id(server, server->id, server->rng,
3675 server->md5hash, client->nickname,
3679 silc_server_disconnect_remote(server, sock,
3680 SILC_STATUS_ERR_BAD_NICKNAME, NULL);
3681 if (sock->user_data)
3682 silc_server_free_sock_user_data(server, sock, NULL);
3685 snprintf(&client->nickname[strlen(client->nickname) - 1], 1,
3692 /* Notify about Client ID change, nickname doesn't actually change. */
3693 silc_server_send_notify_nick_change(server, SILC_PRIMARY_ROUTE(server),
3694 SILC_BROADCAST(server),
3695 client->id, client_id,
3699 /* Resolve users on those channels that client has joined but we
3700 haven't resolved user list yet. */
3701 if (server->server_type == SILC_SERVER && !server->standalone) {
3702 silc_hash_table_list(client->channels, &htl);
3703 while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
3704 channel = chl->channel;
3705 SILC_LOG_DEBUG(("Resolving users for %s channel",
3706 channel->channel_name));
3707 if (channel->disabled || !channel->users_resolved) {
3708 silc_server_send_command(server, SILC_PRIMARY_ROUTE(server),
3709 SILC_COMMAND_USERS, ++server->cmd_ident,
3710 1, 2, channel->channel_name,
3711 strlen(channel->channel_name));
3714 silc_hash_table_list_reset(&htl);
3717 /* Send the new client ID to the client. After this client may start
3718 receiving other packets, and may start sending packets too. */
3719 silc_server_send_new_id(server, sock, FALSE, client_id, SILC_ID_CLIENT,
3720 silc_id_get_len(client_id, SILC_ID_CLIENT));
3723 /* Send NICK change notify to channels as well. */
3724 SilcBuffer oidp, nidp;
3725 oidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
3726 nidp = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
3727 silc_server_send_notify_on_channels(server, NULL, client,
3728 SILC_NOTIFY_TYPE_NICK_CHANGE, 3,
3729 oidp->data, oidp->len,
3730 nidp->data, nidp->len,
3732 strlen(client->nickname));
3733 silc_buffer_free(oidp);
3734 silc_buffer_free(nidp);
3737 /* Add the client again to the ID cache to get it to correct list */
3738 if (!silc_idcache_del_by_context(server->local_list->clients, client))
3739 silc_idcache_del_by_context(server->global_list->clients, client);
3740 silc_free(client->id);
3741 client->id = client_id;
3743 silc_idcache_add(server->local_list->clients, client->nickname,
3744 client->id, client, 0, NULL);
3746 /* Send some nice info to the client */
3747 silc_server_send_connect_notifys(server, sock, client);
3749 /* Send all channel keys of channels the client has joined */
3750 silc_hash_table_list(client->channels, &htl);
3751 while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
3752 bool created = FALSE;
3753 channel = chl->channel;
3755 if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY)
3758 /* If we don't have channel key, then create one */
3759 if (!channel->channel_key) {
3760 if (!silc_server_create_channel_key(server, channel, 0))
3765 id_string = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
3766 cipher = silc_cipher_get_name(channel->channel_key);
3768 silc_channel_key_payload_encode(silc_id_get_len(channel->id,
3771 strlen(cipher), cipher,
3772 channel->key_len / 8, channel->key);
3773 silc_free(id_string);
3775 /* Send the channel key to the client */
3776 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
3777 keyp->data, keyp->len, FALSE);
3779 /* Distribute the channel key to channel */
3781 silc_server_send_channel_key(server, NULL, channel,
3782 server->server_type == SILC_ROUTER ?
3783 FALSE : !server->standalone);
3784 silc_server_backup_send(server, NULL, SILC_PACKET_CHANNEL_KEY, 0,
3785 keyp->data, keyp->len, FALSE, TRUE);
3788 silc_buffer_free(keyp);
3790 silc_hash_table_list_reset(&htl);
3792 } else if (sock->type != SILC_SOCKET_TYPE_CLIENT) {
3793 /* Server or router sent this to us to notify that that a client has
3795 SilcServerEntry server_entry;
3796 SilcServerID *server_id;
3799 SILC_LOG_DEBUG(("Malformed resuming packet"));
3803 /* Get entry to the client, and resolve it if we don't have it. */
3804 detached_client = silc_idlist_find_client_by_id(server->local_list,
3807 if (!detached_client) {
3808 detached_client = silc_idlist_find_client_by_id(server->global_list,
3811 if (!detached_client) {
3812 SILC_LOG_DEBUG(("Resuming client is unknown"));
3813 silc_free(client_id);
3818 /* Check that the client has not been resumed already because it is
3819 protocol error to attempt to resume more than once. The client
3820 will be killed if this protocol error occurs. */
3821 if (detached_client->data.status & SILC_IDLIST_STATUS_RESUMED &&
3822 !(detached_client->mode & SILC_UMODE_DETACHED)) {
3823 /* The client is clearly attempting to resume more than once and
3824 perhaps playing around by resuming from several different places
3825 at the same time. */
3826 SILC_LOG_DEBUG(("Attempting to re-resume client, killing both"));
3827 silc_server_kill_client(server, detached_client, NULL,
3828 server->id, SILC_ID_SERVER);
3829 silc_free(client_id);
3833 /* Check whether client is detached at all */
3834 if (!(detached_client->mode & SILC_UMODE_DETACHED)) {
3835 SILC_LOG_DEBUG(("Client is not detached"));
3836 silc_free(client_id);
3840 SILC_LOG_DEBUG(("Resuming detached client"));
3842 /* If the sender of this packet is server and we are router we need to
3843 broadcast this packet to other routers in the network. */
3844 if (server->server_type == SILC_ROUTER &&
3845 sock->type == SILC_SOCKET_TYPE_SERVER &&
3846 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
3847 SILC_LOG_DEBUG(("Broadcasting received Resume Client packet"));
3848 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3850 packet->flags | SILC_PACKET_FLAG_BROADCAST,
3851 buffer->data, buffer->len, FALSE);
3852 silc_server_backup_send(server, sock->user_data,
3853 packet->type, packet->flags,
3854 packet->buffer->data, packet->buffer->len,
3858 /* Client is detached, and now it is resumed. Remove the detached
3859 mode and mark that it is resumed. */
3860 silc_idlist_del_data(detached_client);
3861 detached_client->mode &= ~SILC_UMODE_DETACHED;
3862 detached_client->data.status |= SILC_IDLIST_STATUS_RESUMED;
3863 detached_client->data.status &= ~SILC_IDLIST_STATUS_LOCAL;
3864 id_cache->expire = 0;
3866 silc_schedule_task_del_by_context(server->schedule, detached_client);
3868 /* Get the new owner of the resumed client */
3869 server_id = silc_id_str2id(packet->src_id, packet->src_id_len,
3870 packet->src_id_type);
3872 silc_free(client_id);
3876 /* Get server entry */
3877 server_entry = silc_idlist_find_server_by_id(server->global_list,
3878 server_id, TRUE, NULL);
3880 if (!server_entry) {
3881 server_entry = silc_idlist_find_server_by_id(server->local_list,
3882 server_id, TRUE, NULL);
3884 if (!server_entry) {
3885 silc_free(server_id);
3886 silc_free(client_id);
3891 if (server->server_type == SILC_ROUTER &&
3892 sock->type == SILC_SOCKET_TYPE_ROUTER &&
3893 server_entry->server_type == SILC_ROUTER)
3896 /* Change the client to correct list. */
3897 if (!silc_idcache_del_by_context(server->local_list->clients,
3899 silc_idcache_del_by_context(server->global_list->clients,
3901 silc_idcache_add(local && server->server_type == SILC_ROUTER ?
3902 server->local_list->clients :
3903 server->global_list->clients,
3904 detached_client->nickname,
3905 detached_client->id, detached_client, FALSE, NULL);
3907 /* Change the owner of the client */
3908 detached_client->router = server_entry;
3910 /* Update channel information regarding global clients on channel. */
3911 if (server->server_type != SILC_ROUTER) {
3912 silc_hash_table_list(detached_client->channels, &htl);
3913 while (silc_hash_table_get(&htl, NULL, (void **)&chl))
3914 chl->channel->global_users =
3915 silc_server_channel_has_global(chl->channel);
3916 silc_hash_table_list_reset(&htl);
3919 silc_free(server_id);
3922 silc_free(client_id);
3923 silc_idlist_del_data(detached_client);