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, tmp, FALSE);
367 /* Check if anyone is watching this nickname */
368 if (server->server_type == SILC_ROUTER)
369 silc_server_check_watcher_list(server, client, NULL,
370 SILC_NOTIFY_TYPE_SIGNOFF);
372 /* Remove this client from watcher list if it is */
373 silc_server_del_from_watcher_list(server, client);
375 client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
376 cache->expire = SILC_ID_CACHE_EXPIRE_DEF;
379 case SILC_NOTIFY_TYPE_TOPIC_SET:
381 * Distribute the notify to local clients on the channel
384 SILC_LOG_DEBUG(("TOPIC SET notify"));
387 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
390 client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
394 /* Get client entry */
395 if (id_type == SILC_ID_CLIENT) {
396 client = silc_idlist_find_client_by_id(server->global_list,
397 client_id, TRUE, &cache);
399 client = silc_idlist_find_client_by_id(server->local_list,
400 client_id, TRUE, &cache);
402 silc_free(client_id);
406 silc_free(client_id);
410 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
412 silc_free(channel_id);
417 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
418 packet->dst_id_type);
423 /* Get channel entry */
424 channel = silc_idlist_find_channel_by_id(server->global_list,
427 channel = silc_idlist_find_channel_by_id(server->local_list,
430 SILC_LOG_DEBUG(("Notify for unknown channel"));
431 silc_free(channel_id);
435 silc_free(channel_id);
437 if (channel->topic && !strcmp(channel->topic, tmp)) {
438 SILC_LOG_DEBUG(("Topic is already set and same"));
443 /* Get user's channel entry and check that topic set is allowed. */
444 if (!silc_server_client_on_channel(client, channel, &chl))
446 if (channel->mode & SILC_CHANNEL_MODE_TOPIC &&
447 !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
448 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
449 SILC_LOG_DEBUG(("Topic change is not allowed"));
454 /* Change the topic */
455 silc_free(channel->topic);
456 channel->topic = strdup(tmp);
458 /* Send the same notify to the channel */
459 silc_server_packet_send_to_channel(server, NULL, channel, packet->type,
460 FALSE, packet->buffer->data,
461 packet->buffer->len, FALSE);
464 case SILC_NOTIFY_TYPE_NICK_CHANGE:
467 * Distribute the notify to local clients on the channel
469 unsigned char *id, *id2;
471 SilcUInt32 nickname_len;
473 SILC_LOG_DEBUG(("NICK CHANGE notify"));
475 /* Get old client ID */
476 id = silc_argument_get_arg_type(args, 1, &tmp_len);
479 client_id = silc_id_payload_parse_id(id, tmp_len, NULL);
483 /* Get new client ID */
484 id2 = silc_argument_get_arg_type(args, 2, &tmp_len);
487 client_id2 = silc_id_payload_parse_id(id2, tmp_len, NULL);
489 silc_free(client_id);
493 SILC_LOG_DEBUG(("Old Client ID id(%s)",
494 silc_id_render(client_id, SILC_ID_CLIENT)));
495 SILC_LOG_DEBUG(("New Client ID id(%s)",
496 silc_id_render(client_id2, SILC_ID_CLIENT)));
498 /* From protocol version 1.1 we also get the new nickname */
499 nickname = silc_argument_get_arg_type(args, 3, &nickname_len);;
501 /* Replace the Client ID */
502 client = silc_idlist_replace_client_id(server,
503 server->global_list, client_id,
504 client_id2, nickname);
506 client = silc_idlist_replace_client_id(server,
507 server->local_list, client_id,
508 client_id2, nickname);
511 /* Send the NICK_CHANGE notify type to local clients on the channels
512 this client is joined to. */
513 silc_server_send_notify_on_channels(server, client, client,
514 SILC_NOTIFY_TYPE_NICK_CHANGE, 3,
515 id, tmp_len, id2, tmp_len,
520 silc_free(client_id);
522 silc_free(client_id2);
526 case SILC_NOTIFY_TYPE_CMODE_CHANGE:
528 * Distribute the notify to local clients on the channel
531 SILC_LOG_DEBUG(("CMODE CHANGE notify"));
534 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
537 client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
541 /* Get client entry */
542 if (id_type == SILC_ID_CLIENT) {
543 client = silc_idlist_find_client_by_id(server->global_list,
544 client_id, TRUE, &cache);
546 client = silc_idlist_find_client_by_id(server->local_list,
547 client_id, TRUE, &cache);
549 silc_free(client_id);
554 silc_free(client_id);
557 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
558 packet->dst_id_type);
563 /* Get channel entry */
564 channel = silc_idlist_find_channel_by_id(server->global_list,
567 channel = silc_idlist_find_channel_by_id(server->local_list,
570 SILC_LOG_DEBUG(("Notify for unknown channel"));
571 silc_free(channel_id);
575 silc_free(channel_id);
578 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
581 SILC_GET32_MSB(mode, tmp);
583 /* Check if mode changed */
584 if (channel->mode == mode) {
585 SILC_LOG_DEBUG(("Mode is changed already"));
587 /* If this mode change has founder mode then we'll enforce the
588 change so that the server gets the real founder public key */
589 if (server->server_type != SILC_SERVER &&
590 sock != SILC_PRIMARY_ROUTE(server) &&
591 mode & SILC_CHANNEL_MODE_FOUNDER_AUTH && channel->founder_key) {
592 SILC_LOG_DEBUG(("Sending founder public key to server"));
593 silc_server_send_notify_cmode(server, sock, FALSE, channel,
594 channel->mode, server->id,
595 SILC_ID_SERVER, channel->cipher,
598 channel->founder_key);
601 /* If we received same mode from our primary check whether founder
602 mode and key in the notify is set. We update the founder key
603 here since we may have wrong one */
604 if (server->server_type == SILC_SERVER &&
605 sock == SILC_PRIMARY_ROUTE(server) &&
606 mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
607 SILC_LOG_DEBUG(("Founder public key received from router"));
608 tmp = silc_argument_get_arg_type(args, 6, &tmp_len);
612 if (channel->founder_key)
613 silc_pkcs_public_key_free(channel->founder_key);
614 channel->founder_key = NULL;
615 silc_pkcs_public_key_decode(tmp, tmp_len, &channel->founder_key);
621 /* Get user's channel entry and check that mode change is allowed */
623 if (!silc_server_client_on_channel(client, channel, &chl))
625 if (!silc_server_check_cmode_rights(server, channel, chl, mode)) {
626 SILC_LOG_DEBUG(("CMODE change is not allowed"));
627 silc_server_send_notify_cmode(server, sock, FALSE, channel,
628 channel->mode, server->id,
629 SILC_ID_SERVER, channel->cipher,
632 channel->founder_key);
636 /* Assure that server is not removing founder mode from us */
637 if (server->server_type == SILC_ROUTER &&
638 sock != SILC_PRIMARY_ROUTE(server) &&
639 channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH &&
640 !(mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
641 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
642 silc_server_send_notify_cmode(server, sock, FALSE, channel,
643 channel->mode, server->id,
644 SILC_ID_SERVER, channel->cipher,
647 channel->founder_key);
651 /* If server is adding founder mode, check whether there is founder
652 on channel already and is not from this server */
653 if (server->server_type == SILC_ROUTER &&
654 sock != SILC_PRIMARY_ROUTE(server) &&
655 mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
656 silc_hash_table_list(channel->user_list, &htl);
657 while (silc_hash_table_get(&htl, NULL, (void *)&chl))
658 if (chl->mode & SILC_CHANNEL_UMODE_CHANFO &&
659 chl->client->router != sock->user_data) {
660 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
661 silc_server_send_notify_cmode(server, sock, FALSE, channel,
662 channel->mode, server->id,
663 SILC_ID_SERVER, channel->cipher,
666 channel->founder_key);
667 silc_hash_table_list_reset(&htl);
670 silc_hash_table_list_reset(&htl);
674 /* If the channel had private keys set and the mode was removed then
675 we must re-generate and re-distribute a new channel key */
676 if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY &&
677 !(mode & SILC_CHANNEL_MODE_PRIVKEY)) {
678 /* Re-generate channel key */
679 if (!silc_server_create_channel_key(server, channel, 0))
682 /* Send the channel key. This sends it to our local clients and if
683 we are normal server to our router as well. */
684 silc_server_send_channel_key(server, NULL, channel,
685 server->server_type == SILC_ROUTER ?
686 FALSE : !server->standalone);
690 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
692 unsigned char hash[32];
695 silc_hmac_free(channel->hmac);
696 if (!silc_hmac_alloc(tmp, NULL, &channel->hmac))
699 /* Set the HMAC key out of current channel key. The client must do
701 silc_hash_make(silc_hmac_get_hash(channel->hmac), channel->key,
702 channel->key_len / 8, hash);
703 silc_hmac_set_key(channel->hmac, hash,
704 silc_hash_len(silc_hmac_get_hash(channel->hmac)));
705 memset(hash, 0, sizeof(hash));
708 /* Get the passphrase */
709 tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
711 silc_free(channel->passphrase);
712 channel->passphrase = silc_memdup(tmp, tmp_len);
715 /* Get founder public key */
716 tmp = silc_argument_get_arg_type(args, 6, &tmp_len);
717 if (tmp && mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
718 if (channel->founder_key)
719 silc_pkcs_public_key_free(channel->founder_key);
720 channel->founder_key = NULL;
721 silc_pkcs_public_key_decode(tmp, tmp_len, &channel->founder_key);
723 if (!channel->founder_key ||
724 (client && client->data.public_key &&
725 server->server_type == SILC_ROUTER &&
726 !silc_pkcs_public_key_compare(channel->founder_key,
727 client->data.public_key))) {
728 /* A really buggy server isn't checking public keys correctly.
729 It's not possible that the mode setter and founder wouldn't
730 have same public key. */
731 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
733 mode &= ~SILC_CHANNEL_MODE_FOUNDER_AUTH;
734 silc_server_send_notify_cmode(server, sock, FALSE, channel,
735 mode, server->id, SILC_ID_SERVER,
738 channel->passphrase, NULL);
739 if (channel->founder_key)
740 silc_pkcs_public_key_free(channel->founder_key);
741 channel->founder_key = NULL;
742 } else if (client && !client->data.public_key) {
743 client->data.public_key =
744 silc_pkcs_public_key_copy(channel->founder_key);
748 if (mode & SILC_CHANNEL_MODE_FOUNDER_AUTH && !channel->founder_key &&
749 server->server_type == SILC_ROUTER) {
750 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
751 mode &= ~SILC_CHANNEL_MODE_FOUNDER_AUTH;
752 silc_server_send_notify_cmode(server, sock, FALSE, channel,
753 mode, server->id, SILC_ID_SERVER,
756 channel->passphrase, NULL);
759 /* Send the same notify to the channel */
760 silc_server_packet_send_to_channel(server, NULL, channel, packet->type,
761 FALSE, packet->buffer->data,
762 packet->buffer->len, FALSE);
765 channel->mode = mode;
767 if (!(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) &&
768 channel->founder_key) {
769 silc_pkcs_public_key_free(channel->founder_key);
770 channel->founder_key = NULL;
775 case SILC_NOTIFY_TYPE_CUMODE_CHANGE:
778 * Distribute the notify to local clients on the channel
780 SilcChannelClientEntry chl2 = NULL;
781 bool notify_sent = FALSE;
783 SILC_LOG_DEBUG(("CUMODE CHANGE notify"));
786 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
789 client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
793 /* Get client entry */
794 if (id_type == SILC_ID_CLIENT) {
795 client = silc_idlist_find_client_by_id(server->global_list,
796 client_id, TRUE, &cache);
798 client = silc_idlist_find_client_by_id(server->local_list,
799 client_id, TRUE, &cache);
801 silc_free(client_id);
806 silc_free(client_id);
809 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
810 packet->dst_id_type);
815 /* Get channel entry */
816 channel = silc_idlist_find_channel_by_id(server->global_list,
819 channel = silc_idlist_find_channel_by_id(server->local_list,
822 SILC_LOG_DEBUG(("Notify for unknown channel"));
823 silc_free(channel_id);
829 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
831 silc_free(channel_id);
835 SILC_GET32_MSB(mode, tmp);
837 /* Get target client */
838 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
841 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
845 /* Get client entry */
846 client2 = silc_idlist_find_client_by_id(server->global_list,
847 client_id, TRUE, NULL);
849 client2 = silc_idlist_find_client_by_id(server->local_list,
850 client_id, TRUE, NULL);
852 silc_free(client_id);
856 silc_free(client_id);
859 /* Check that sender is on channel */
860 if (!silc_server_client_on_channel(client, channel, &chl))
863 if (client != client2 && server->server_type == SILC_ROUTER) {
864 /* Sender must be operator */
865 if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
866 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
867 SILC_LOG_DEBUG(("CUMODE change is not allowed"));
871 if (!silc_server_client_on_channel(client2, channel, &chl))
874 /* If target is founder mode change is not allowed. */
875 if (chl->mode & SILC_CHANNEL_UMODE_CHANFO) {
876 SILC_LOG_DEBUG(("CUMODE change is not allowed"));
882 /* Get target channel user entry */
883 if (!silc_server_client_on_channel(client2, channel, &chl))
886 if (server->server_type == SILC_SERVER && chl->mode == mode) {
887 SILC_LOG_DEBUG(("Mode is changed already"));
891 if (mode & SILC_CHANNEL_UMODE_CHANFO &&
892 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO) &&
893 server->server_type == SILC_ROUTER &&
894 sock != SILC_PRIMARY_ROUTE(server)) {
895 SilcPublicKey founder_key = NULL;
897 /* If channel doesn't have founder auth mode then it's impossible
898 that someone would be getting founder rights with CUMODE command.
899 In that case there already either is founder or there isn't
900 founder at all on the channel. */
901 if (client && !(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
902 /* Force the mode to not have founder mode */
903 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
904 silc_server_force_cumode_change(server, sock, channel, chl, mode);
909 /* Get the founder of the channel and if found then this client
910 cannot be the founder since there already is one. */
911 silc_hash_table_list(channel->user_list, &htl);
912 while (silc_hash_table_get(&htl, NULL, (void *)&chl2))
913 if (chl2->mode & SILC_CHANNEL_UMODE_CHANFO) {
914 /* If the founder on the channel is not the one whom has set
915 the founder mode, then it's possible that this CUMODE_CHANGE
916 is correct. Due to netsplits it's possible that this
917 situation happens. */
918 if (!(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) ||
919 (channel->founder_key && chl2->client->data.public_key &&
920 silc_pkcs_public_key_compare(
921 channel->founder_key,
922 chl2->client->data.public_key))) {
923 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
924 silc_server_force_cumode_change(server, sock, channel,
930 silc_hash_table_list_reset(&htl);
931 if (!(mode & SILC_CHANNEL_UMODE_CHANFO))
934 /* Founder not found of the channel. Since the founder auth mode
935 is set on the channel now check whether this is the client that
936 originally set the mode. */
938 if (channel->founder_key) {
939 /* Get public key that must be present in notify */
940 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
941 if (!tmp || !silc_pkcs_public_key_decode(tmp, tmp_len,
943 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
944 silc_server_force_cumode_change(server, sock, channel, chl, mode);
949 /* Now match the public key we have cached and public key sent.
951 if (client && client->data.public_key &&
952 !silc_pkcs_public_key_compare(channel->founder_key,
953 client->data.public_key)) {
954 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
955 silc_server_force_cumode_change(server, sock, channel, chl, mode);
959 if (!silc_pkcs_public_key_compare(channel->founder_key,
961 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
962 silc_server_force_cumode_change(server, sock, channel, chl, mode);
968 /* There cannot be anyone else as founder on the channel now. This
969 client is definitely the founder due to this authentication */
970 silc_hash_table_list(channel->user_list, &htl);
971 while (silc_hash_table_get(&htl, NULL, (void *)&chl2))
972 if (chl2->mode & SILC_CHANNEL_UMODE_CHANFO) {
973 chl2->mode &= ~SILC_CHANNEL_UMODE_CHANFO;
974 silc_server_force_cumode_change(server, NULL, channel, chl2,
978 silc_hash_table_list_reset(&htl);
981 silc_pkcs_public_key_free(founder_key);
984 if (server->server_type != SILC_SERVER && chl->mode == mode) {
985 SILC_LOG_DEBUG(("Mode is changed already"));
989 SILC_LOG_DEBUG(("Changing %s channel user mode",
990 chl->client->nickname ? chl->client->nickname :
991 (unsigned char *)""));
993 /* Change the mode */
996 /* Send the same notify to the channel */
998 silc_server_packet_send_to_channel(server, NULL, channel,
1000 FALSE, packet->buffer->data,
1001 packet->buffer->len, FALSE);
1003 silc_free(channel_id);
1007 case SILC_NOTIFY_TYPE_INVITE:
1009 if (packet->dst_id_type == SILC_ID_CLIENT)
1012 SILC_LOG_DEBUG(("INVITE notify"));
1014 /* Get Channel ID */
1015 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1018 channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1022 /* Get channel entry */
1023 channel = silc_idlist_find_channel_by_id(server->global_list,
1026 channel = silc_idlist_find_channel_by_id(server->local_list,
1029 SILC_LOG_DEBUG(("Notify for unknown channel"));
1030 silc_free(channel_id);
1034 silc_free(channel_id);
1037 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1040 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1044 /* Get client entry */
1045 client = silc_idlist_find_client_by_id(server->global_list,
1046 client_id, TRUE, &cache);
1048 client = silc_idlist_find_client_by_id(server->local_list,
1049 client_id, TRUE, &cache);
1051 silc_free(client_id);
1055 silc_free(client_id);
1057 /* Get user's channel entry and check that inviting is allowed. */
1058 if (!silc_server_client_on_channel(client, channel, &chl))
1060 if (channel->mode & SILC_CHANNEL_MODE_INVITE &&
1061 !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
1062 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
1063 SILC_LOG_DEBUG(("Inviting is not allowed"));
1067 /* Get the added invite */
1068 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
1070 if (!channel->invite_list)
1071 channel->invite_list = silc_calloc(tmp_len + 2,
1072 sizeof(*channel->invite_list));
1074 channel->invite_list = silc_realloc(channel->invite_list,
1075 sizeof(*channel->invite_list) *
1077 strlen(channel->invite_list) +
1079 if (tmp[tmp_len - 1] == ',')
1080 tmp[tmp_len - 1] = '\0';
1082 strncat(channel->invite_list, tmp, tmp_len);
1083 strncat(channel->invite_list, ",", 1);
1086 /* Get the deleted invite */
1087 tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
1088 if (tmp && channel->invite_list) {
1089 char *start, *end, *n;
1091 if (!strncmp(channel->invite_list, tmp,
1092 strlen(channel->invite_list) - 1)) {
1093 silc_free(channel->invite_list);
1094 channel->invite_list = NULL;
1096 start = strstr(channel->invite_list, tmp);
1097 if (start && strlen(start) >= tmp_len) {
1098 end = start + tmp_len;
1099 n = silc_calloc(strlen(channel->invite_list) - tmp_len, sizeof(*n));
1100 strncat(n, channel->invite_list, start - channel->invite_list);
1101 strncat(n, end + 1, ((channel->invite_list +
1102 strlen(channel->invite_list)) - end) - 1);
1103 silc_free(channel->invite_list);
1104 channel->invite_list = n;
1111 case SILC_NOTIFY_TYPE_CHANNEL_CHANGE:
1113 * Distribute to the local clients on the channel and change the
1117 SILC_LOG_DEBUG(("CHANNEL CHANGE"));
1119 if (sock->type != SILC_SOCKET_TYPE_ROUTER)
1122 /* Get the old Channel ID */
1123 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1126 channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1130 /* Get the channel entry */
1131 channel = silc_idlist_find_channel_by_id(server->local_list,
1134 channel = silc_idlist_find_channel_by_id(server->global_list,
1137 SILC_LOG_DEBUG(("Notify for unknown channel"));
1138 silc_free(channel_id);
1143 /* Send the notify to the channel */
1144 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
1145 FALSE, packet->buffer->data,
1146 packet->buffer->len, FALSE);
1148 /* Get the new Channel ID */
1149 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1152 channel_id2 = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1156 SILC_LOG_DEBUG(("Old Channel ID id(%s)",
1157 silc_id_render(channel_id, SILC_ID_CHANNEL)));
1158 SILC_LOG_DEBUG(("New Channel ID id(%s)",
1159 silc_id_render(channel_id2, SILC_ID_CHANNEL)));
1161 /* Replace the Channel ID */
1162 if (!silc_idlist_replace_channel_id(server->local_list, channel_id,
1164 if (!silc_idlist_replace_channel_id(server->global_list, channel_id,
1166 silc_free(channel_id2);
1171 SilcBuffer modes = NULL, users = NULL, users_modes = NULL;
1173 /* Re-announce this channel which ID was changed. */
1174 silc_server_send_new_channel(server, sock, FALSE, channel->channel_name,
1176 silc_id_get_len(channel->id,
1180 /* Re-announce our clients on the channel as the ID has changed now */
1181 silc_server_announce_get_channel_users(server, channel, &modes, &users,
1184 silc_buffer_push(users, users->data - users->head);
1185 silc_server_packet_send(server, sock,
1186 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1187 users->data, users->len, FALSE);
1188 silc_buffer_free(users);
1191 silc_buffer_push(modes, modes->data - modes->head);
1192 silc_server_packet_send_dest(server, sock,
1193 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1194 channel->id, SILC_ID_CHANNEL,
1195 modes->data, modes->len, FALSE);
1196 silc_buffer_free(modes);
1199 silc_buffer_push(users_modes, users_modes->data - users_modes->head);
1200 silc_server_packet_send_dest(server, sock,
1201 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1202 channel->id, SILC_ID_CHANNEL,
1204 users_modes->len, FALSE);
1205 silc_buffer_free(users_modes);
1208 /* Re-announce channel's topic */
1209 if (channel->topic) {
1210 silc_server_send_notify_topic_set(server, sock,
1211 server->server_type == SILC_ROUTER ?
1212 TRUE : FALSE, channel,
1213 server->id, SILC_ID_SERVER,
1218 silc_free(channel_id);
1222 case SILC_NOTIFY_TYPE_SERVER_SIGNOFF:
1224 * Remove the server entry and all clients that this server owns.
1227 SILC_LOG_DEBUG(("SERVER SIGNOFF notify"));
1230 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1233 server_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1237 /* If the ID is mine, this notify is not allowed. */
1238 if (SILC_ID_SERVER_COMPARE(server_id, server->id)) {
1239 SILC_LOG_DEBUG(("Ignoring my own ID for SERVER_SIGNOFF"));
1243 /* Get server entry */
1244 server_entry = silc_idlist_find_server_by_id(server->global_list,
1245 server_id, TRUE, NULL);
1247 if (!server_entry) {
1248 server_entry = silc_idlist_find_server_by_id(server->local_list,
1249 server_id, TRUE, NULL);
1251 if (!server_entry) {
1252 /* If we are normal server then we might not have the server. Check
1253 whether router was kind enough to send the list of all clients
1254 that actually was to be removed. Remove them if the list is
1256 if (server->server_type != SILC_ROUTER &&
1257 silc_argument_get_arg_num(args) > 1) {
1260 for (i = 1; i < silc_argument_get_arg_num(args); i++) {
1262 tmp = silc_argument_get_arg_type(args, i + 1, &tmp_len);
1265 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1269 /* Get client entry */
1270 client = silc_idlist_find_client_by_id(server->global_list,
1271 client_id, TRUE, &cache);
1274 client = silc_idlist_find_client_by_id(server->local_list,
1275 client_id, TRUE, &cache);
1278 silc_free(client_id);
1282 silc_free(client_id);
1284 /* Update statistics */
1285 server->stat.clients--;
1286 if (server->stat.cell_clients)
1287 server->stat.cell_clients--;
1288 SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
1289 SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
1291 /* Remove the client from all channels. */
1292 silc_server_remove_from_channels(server, NULL, client,
1295 /* Check if anyone is watching this nickname */
1296 if (server->server_type == SILC_ROUTER)
1297 silc_server_check_watcher_list(server, client, NULL,
1298 SILC_NOTIFY_TYPE_SERVER_SIGNOFF);
1300 /* Remove this client from watcher list if it is */
1302 silc_server_del_from_watcher_list(server, client);
1304 /* Remove the client */
1305 silc_idlist_del_data(client);
1306 silc_idlist_del_client(local ? server->local_list :
1307 server->global_list, client);
1311 silc_free(server_id);
1315 silc_free(server_id);
1317 /* Sending SERVER_SIGNOFF is not right way to signoff local connection */
1318 if (SILC_IS_LOCAL(server_entry))
1321 /* Remove all servers that are originated from this server, and
1322 remove the clients of those servers too. */
1323 silc_server_remove_servers_by_server(server, server_entry, TRUE);
1325 /* Remove the clients that this server owns as they will become
1327 silc_server_remove_clients_by_server(server, server_entry->router,
1328 server_entry, TRUE);
1329 silc_server_backup_del(server, server_entry);
1331 /* Remove the server entry */
1332 silc_idlist_del_server(local ? server->local_list :
1333 server->global_list, server_entry);
1335 /* Update statistics */
1336 if (server->server_type == SILC_ROUTER)
1337 server->stat.servers--;
1341 case SILC_NOTIFY_TYPE_KICKED:
1343 * Distribute the notify to local clients on the channel
1346 SILC_LOG_DEBUG(("KICKED notify"));
1349 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
1350 packet->dst_id_type);
1355 /* Get channel entry */
1356 channel = silc_idlist_find_channel_by_id(server->global_list,
1359 channel = silc_idlist_find_channel_by_id(server->local_list,
1362 SILC_LOG_DEBUG(("Notify for unknown channel"));
1363 silc_free(channel_id);
1367 silc_free(channel_id);
1370 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1373 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1377 /* If the the client is not in local list we check global list */
1378 client = silc_idlist_find_client_by_id(server->global_list,
1379 client_id, TRUE, NULL);
1381 client = silc_idlist_find_client_by_id(server->local_list,
1382 client_id, TRUE, NULL);
1384 silc_free(client_id);
1388 silc_free(client_id);
1390 /* If target is founder they cannot be kicked */
1391 if (!silc_server_client_on_channel(client, channel, &chl))
1393 if (chl->mode & SILC_CHANNEL_UMODE_CHANFO)
1396 /* From protocol version 1.1 we get the kicker's ID as well. */
1397 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1399 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1403 /* If the the client is not in local list we check global list */
1404 client2 = silc_idlist_find_client_by_id(server->global_list,
1405 client_id, TRUE, NULL);
1407 client2 = silc_idlist_find_client_by_id(server->local_list,
1408 client_id, TRUE, NULL);
1410 silc_free(client_id);
1414 silc_free(client_id);
1416 /* Kicker must be operator on channel */
1417 if (!silc_server_client_on_channel(client2, channel, &chl))
1419 if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
1420 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
1421 SILC_LOG_DEBUG(("Kicking is not allowed"));
1426 /* Send to channel */
1427 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
1428 FALSE, packet->buffer->data,
1429 packet->buffer->len, FALSE);
1431 /* Remove the client from channel */
1432 silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
1436 case SILC_NOTIFY_TYPE_KILLED:
1439 * Distribute the notify to local clients on channels
1441 unsigned char *id, *comment;
1442 SilcUInt32 id_len, comment_len;
1444 SILC_LOG_DEBUG(("KILLED notify"));
1447 id = silc_argument_get_arg_type(args, 1, &id_len);
1450 client_id = silc_id_payload_parse_id(id, id_len, NULL);
1454 /* If the the client is not in local list we check global list */
1455 client = silc_idlist_find_client_by_id(server->global_list,
1456 client_id, TRUE, &cache);
1458 client = silc_idlist_find_client_by_id(server->local_list,
1459 client_id, TRUE, &cache);
1461 silc_free(client_id);
1465 silc_free(client_id);
1467 /* If the client is one of ours, then close the connection to the
1468 client now. This removes the client from all channels as well. */
1469 if (packet->dst_id_type == SILC_ID_CLIENT && client->connection) {
1470 sock = client->connection;
1471 silc_server_free_client_data(server, NULL, client, FALSE, NULL);
1472 silc_server_close_connection(server, sock);
1477 comment = silc_argument_get_arg_type(args, 2, &comment_len);
1478 if (comment_len > 128)
1481 /* From protocol version 1.1 we get the killer's ID as well. */
1482 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1484 client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
1488 if (id_type == SILC_ID_CLIENT) {
1489 /* If the the client is not in local list we check global list */
1490 client2 = silc_idlist_find_client_by_id(server->global_list,
1491 client_id, TRUE, NULL);
1493 client2 = silc_idlist_find_client_by_id(server->local_list,
1494 client_id, TRUE, NULL);
1496 silc_free(client_id);
1500 silc_free(client_id);
1502 /* Killer must be router operator */
1503 if (server->server_type != SILC_SERVER &&
1504 !(client2->mode & SILC_UMODE_ROUTER_OPERATOR)) {
1505 SILC_LOG_DEBUG(("Killing is not allowed"));
1511 /* Send the notify to local clients on the channels except to the
1512 client who is killed. */
1513 silc_server_send_notify_on_channels(server, client, client,
1514 SILC_NOTIFY_TYPE_KILLED, 3,
1515 id, id_len, comment, comment_len,
1518 /* Remove the client from all channels */
1519 silc_server_remove_from_channels(server, NULL, client, FALSE, NULL,
1522 /* Check if anyone is watching this nickname */
1523 silc_server_check_watcher_list(server, client, NULL,
1524 SILC_NOTIFY_TYPE_KILLED);
1526 /* Update statistics */
1527 server->stat.clients--;
1528 if (server->stat.cell_clients)
1529 server->stat.cell_clients--;
1530 SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
1531 SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
1533 if (SILC_IS_LOCAL(client)) {
1534 server->stat.my_clients--;
1535 silc_schedule_task_del_by_context(server->schedule, client);
1536 silc_idlist_del_data(client);
1540 client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
1541 cache->expire = SILC_ID_CACHE_EXPIRE_DEF;
1545 case SILC_NOTIFY_TYPE_UMODE_CHANGE:
1547 * Save the mode of the client.
1550 SILC_LOG_DEBUG(("UMODE_CHANGE notify"));
1553 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1556 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1560 /* Get client entry */
1561 client = silc_idlist_find_client_by_id(server->global_list,
1562 client_id, TRUE, NULL);
1564 client = silc_idlist_find_client_by_id(server->local_list,
1565 client_id, TRUE, NULL);
1567 silc_free(client_id);
1571 silc_free(client_id);
1574 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1577 SILC_GET32_MSB(mode, tmp);
1579 /* Remove internal resumed flag if client is marked detached now */
1580 if (mode & SILC_UMODE_DETACHED)
1581 client->data.status &= ~SILC_IDLIST_STATUS_RESUMED;
1583 /* Update statistics */
1584 if (server->server_type == SILC_ROUTER) {
1585 if (mode & SILC_UMODE_GONE) {
1586 if (!(client->mode & SILC_UMODE_GONE))
1587 server->stat.aways++;
1589 if (client->mode & SILC_UMODE_GONE)
1590 server->stat.aways--;
1592 if (mode & SILC_UMODE_DETACHED) {
1593 if (!(client->mode & SILC_UMODE_DETACHED))
1594 server->stat.detached++;
1596 if (client->mode & SILC_UMODE_DETACHED)
1597 server->stat.detached--;
1600 SILC_UMODE_STATS_UPDATE(server, SILC_UMODE_SERVER_OPERATOR);
1601 SILC_UMODE_STATS_UPDATE(router, SILC_UMODE_ROUTER_OPERATOR);
1603 /* Change the mode */
1604 client->mode = mode;
1606 /* Check if anyone is watching this nickname */
1607 if (server->server_type == SILC_ROUTER)
1608 silc_server_check_watcher_list(server, client, NULL,
1609 SILC_NOTIFY_TYPE_UMODE_CHANGE);
1613 case SILC_NOTIFY_TYPE_BAN:
1618 SILC_LOG_DEBUG(("BAN notify"));
1620 /* Get Channel ID */
1621 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1624 channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1628 /* Get channel entry */
1629 channel = silc_idlist_find_channel_by_id(server->global_list,
1632 channel = silc_idlist_find_channel_by_id(server->local_list,
1635 SILC_LOG_DEBUG(("Notify for unknown channel"));
1636 silc_free(channel_id);
1640 silc_free(channel_id);
1642 /* Get the new ban and add it to the ban list */
1643 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1645 if (!channel->ban_list)
1646 channel->ban_list = silc_calloc(tmp_len + 2,
1647 sizeof(*channel->ban_list));
1649 channel->ban_list = silc_realloc(channel->ban_list,
1650 sizeof(*channel->ban_list) *
1652 strlen(channel->ban_list) + 2));
1653 strncat(channel->ban_list, tmp, tmp_len);
1654 strncat(channel->ban_list, ",", 1);
1657 /* Get the ban to be removed and remove it from the list */
1658 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1659 if (tmp && channel->ban_list) {
1660 char *start, *end, *n;
1662 if (!strncmp(channel->ban_list, tmp, strlen(channel->ban_list) - 1)) {
1663 silc_free(channel->ban_list);
1664 channel->ban_list = NULL;
1666 start = strstr(channel->ban_list, tmp);
1667 if (start && strlen(start) >= tmp_len) {
1668 end = start + tmp_len;
1669 n = silc_calloc(strlen(channel->ban_list) - tmp_len, sizeof(*n));
1670 strncat(n, channel->ban_list, start - channel->ban_list);
1671 strncat(n, end + 1, ((channel->ban_list +
1672 strlen(channel->ban_list)) - end) - 1);
1673 silc_free(channel->ban_list);
1674 channel->ban_list = n;
1680 case SILC_NOTIFY_TYPE_ERROR:
1687 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1688 if (!tmp && tmp_len != 1)
1690 error = (SilcStatus)tmp[0];
1692 SILC_LOG_DEBUG(("ERROR notify (%d)", error));
1694 if (error == SILC_STATUS_ERR_NO_SUCH_CLIENT_ID &&
1695 sock->type == SILC_SOCKET_TYPE_ROUTER) {
1696 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1698 SILC_LOG_DEBUG(("Received invalid client ID notification, deleting "
1699 "the entry from cache"));
1700 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1703 client = silc_idlist_find_client_by_id(server->global_list,
1704 client_id, FALSE, NULL);
1706 silc_server_remove_from_channels(server, NULL, client, TRUE,
1708 silc_idlist_del_data(client);
1709 silc_idlist_del_client(server->global_list, client);
1711 silc_free(client_id);
1717 /* Ignore rest of the notify types for now */
1718 case SILC_NOTIFY_TYPE_NONE:
1719 case SILC_NOTIFY_TYPE_MOTD:
1726 silc_notify_payload_free(payload);
1729 void silc_server_notify_list(SilcServer server,
1730 SilcSocketConnection sock,
1731 SilcPacketContext *packet)
1733 SilcPacketContext *new;
1737 SILC_LOG_DEBUG(("Processing Notify List"));
1739 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
1740 packet->src_id_type != SILC_ID_SERVER)
1743 /* Make copy of the original packet context, except for the actual
1744 data buffer, which we will here now fetch from the original buffer. */
1745 new = silc_packet_context_alloc();
1746 new->type = SILC_PACKET_NOTIFY;
1747 new->flags = packet->flags;
1748 new->src_id = packet->src_id;
1749 new->src_id_len = packet->src_id_len;
1750 new->src_id_type = packet->src_id_type;
1751 new->dst_id = packet->dst_id;
1752 new->dst_id_len = packet->dst_id_len;
1753 new->dst_id_type = packet->dst_id_type;
1755 buffer = silc_buffer_alloc(1024);
1756 new->buffer = buffer;
1758 while (packet->buffer->len) {
1759 SILC_GET16_MSB(len, packet->buffer->data + 2);
1760 if (len > packet->buffer->len)
1763 if (len > buffer->truelen) {
1764 silc_buffer_free(buffer);
1765 buffer = silc_buffer_alloc(1024 + len);
1768 silc_buffer_pull_tail(buffer, len);
1769 silc_buffer_put(buffer, packet->buffer->data, len);
1771 /* Process the Notify */
1772 silc_server_notify(server, sock, new);
1774 silc_buffer_push_tail(buffer, len);
1775 silc_buffer_pull(packet->buffer, len);
1778 silc_buffer_free(buffer);
1782 /* Received private message. This resolves the destination of the message
1783 and sends the packet. This is used by both server and router. If the
1784 destination is our locally connected client this sends the packet to
1785 the client. This may also send the message for further routing if
1786 the destination is not in our server (or router). */
1788 void silc_server_private_message(SilcServer server,
1789 SilcSocketConnection sock,
1790 SilcPacketContext *packet)
1792 SilcSocketConnection dst_sock;
1793 SilcIDListData idata;
1794 SilcClientEntry client;
1796 SILC_LOG_DEBUG(("Start"));
1798 if (packet->src_id_type != SILC_ID_CLIENT ||
1799 packet->dst_id_type != SILC_ID_CLIENT || !packet->dst_id)
1802 /* Get the route to the client */
1803 dst_sock = silc_server_get_client_route(server, packet->dst_id,
1804 packet->dst_id_len, NULL,
1808 unsigned char error;
1810 if (client && client->mode & SILC_UMODE_DETACHED) {
1811 SILC_LOG_DEBUG(("Client is detached, discarding packet"));
1815 /* Send SILC_NOTIFY_TYPE_ERROR to indicate that such destination ID
1816 does not exist or is invalid. */
1817 idp = silc_id_payload_encode_data(packet->dst_id,
1819 packet->dst_id_type);
1823 error = SILC_STATUS_ERR_NO_SUCH_CLIENT_ID;
1824 if (packet->src_id_type == SILC_ID_CLIENT) {
1825 SilcClientID *client_id = silc_id_str2id(packet->src_id,
1827 packet->src_id_type);
1828 silc_server_send_notify_dest(server, sock, FALSE,
1829 client_id, SILC_ID_CLIENT,
1830 SILC_NOTIFY_TYPE_ERROR, 2,
1832 idp->data, idp->len);
1833 silc_free(client_id);
1835 silc_server_send_notify(server, sock, FALSE,
1836 SILC_NOTIFY_TYPE_ERROR, 2,
1838 idp->data, idp->len);
1841 silc_buffer_free(idp);
1845 /* Check whether destination client wishes to receive private messages */
1846 if (client && !(packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY) &&
1847 client->mode & SILC_UMODE_BLOCK_PRIVMSG) {
1848 SILC_LOG_DEBUG(("Client blocks private messages, discarding packet"));
1852 /* Send the private message */
1853 silc_server_send_private_message(server, dst_sock, idata->send_key,
1854 idata->hmac_send, idata->psn_send++,
1858 /* Received private message key packet.. This packet is never for us. It is to
1859 the client in the packet's destination ID. Sending of this sort of packet
1860 equals sending private message, ie. it is sent point to point from
1861 one client to another. */
1863 void silc_server_private_message_key(SilcServer server,
1864 SilcSocketConnection sock,
1865 SilcPacketContext *packet)
1867 SilcSocketConnection dst_sock;
1868 SilcIDListData idata;
1870 SILC_LOG_DEBUG(("Start"));
1872 if (packet->src_id_type != SILC_ID_CLIENT ||
1873 packet->dst_id_type != SILC_ID_CLIENT)
1876 if (!packet->dst_id)
1879 /* Get the route to the client */
1880 dst_sock = silc_server_get_client_route(server, packet->dst_id,
1881 packet->dst_id_len, NULL,
1886 /* Relay the packet */
1887 silc_server_relay_packet(server, dst_sock, idata->send_key,
1888 idata->hmac_send, idata->psn_send++, packet, FALSE);
1891 /* Processes incoming command reply packet. The command reply packet may
1892 be destined to one of our clients or it may directly for us. We will
1893 call the command reply routine after processing the packet. */
1895 void silc_server_command_reply(SilcServer server,
1896 SilcSocketConnection sock,
1897 SilcPacketContext *packet)
1899 SilcBuffer buffer = packet->buffer;
1900 SilcClientEntry client = NULL;
1901 SilcSocketConnection dst_sock;
1902 SilcIDListData idata;
1903 SilcClientID *id = NULL;
1905 SILC_LOG_DEBUG(("Start"));
1907 if (packet->dst_id_type == SILC_ID_CHANNEL)
1910 if (packet->dst_id_type == SILC_ID_CLIENT) {
1911 /* Destination must be one of ours */
1912 id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CLIENT);
1915 client = silc_idlist_find_client_by_id(server->local_list, id, TRUE, NULL);
1917 SILC_LOG_ERROR(("Cannot process command reply to unknown client"));
1923 if (packet->dst_id_type == SILC_ID_SERVER) {
1924 /* For now this must be for us */
1925 if (memcmp(packet->dst_id, server->id_string, server->id_string_len)) {
1926 SILC_LOG_ERROR(("Cannot process command reply to unknown server"));
1931 /* Execute command reply locally for the command */
1932 silc_server_command_reply_process(server, sock, buffer);
1934 if (packet->dst_id_type == SILC_ID_CLIENT && client && id) {
1935 /* Relay the packet to the client */
1936 const SilcBufferStruct p;
1938 dst_sock = (SilcSocketConnection)client->connection;
1939 idata = (SilcIDListData)client;
1941 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1942 + packet->dst_id_len + packet->padlen);
1943 if (!silc_packet_send_prepare(dst_sock, 0, 0, buffer->len,
1944 idata->hmac_send, (const SilcBuffer)&p)) {
1945 SILC_LOG_ERROR(("Cannot send packet"));
1948 silc_buffer_put((SilcBuffer)&p, buffer->data, buffer->len);
1950 /* Encrypt packet */
1951 silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
1952 (SilcBuffer)&p, buffer->len);
1954 /* Send the packet */
1955 silc_server_packet_send_real(server, dst_sock, TRUE);
1961 /* Process received channel message. The message can be originated from
1962 client or server. */
1964 void silc_server_channel_message(SilcServer server,
1965 SilcSocketConnection sock,
1966 SilcPacketContext *packet)
1968 SilcChannelEntry channel = NULL;
1969 SilcChannelID *id = NULL;
1970 void *sender_id = NULL;
1971 SilcClientEntry sender_entry = NULL;
1972 SilcChannelClientEntry chl;
1975 SILC_LOG_DEBUG(("Processing channel message"));
1978 if (packet->dst_id_type != SILC_ID_CHANNEL) {
1979 SILC_LOG_DEBUG(("Received bad message for channel, dropped"));
1983 /* Find channel entry */
1984 id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CHANNEL);
1987 channel = silc_idlist_find_channel_by_id(server->local_list, id, NULL);
1989 channel = silc_idlist_find_channel_by_id(server->global_list, id, NULL);
1992 unsigned char error;
1994 /* Send SILC_NOTIFY_TYPE_ERROR to indicate that such destination ID
1995 does not exist or is invalid. */
1996 idp = silc_id_payload_encode_data(packet->dst_id,
1998 packet->dst_id_type);
2002 error = SILC_STATUS_ERR_NO_SUCH_CHANNEL_ID;
2003 if (packet->src_id_type == SILC_ID_CLIENT) {
2004 SilcClientID *client_id = silc_id_str2id(packet->src_id,
2006 packet->src_id_type);
2007 silc_server_send_notify_dest(server, sock, FALSE,
2008 client_id, SILC_ID_CLIENT,
2009 SILC_NOTIFY_TYPE_ERROR, 2,
2010 &error, 1, idp->data, idp->len);
2011 silc_free(client_id);
2013 silc_server_send_notify(server, sock, FALSE,
2014 SILC_NOTIFY_TYPE_ERROR, 2,
2015 &error, 1, idp->data, idp->len);
2018 silc_buffer_free(idp);
2023 /* See that this client is on the channel. If the original sender is
2024 not client (as it can be server as well) we don't do the check. */
2025 sender_id = silc_id_str2id(packet->src_id, packet->src_id_len,
2026 packet->src_id_type);
2029 if (packet->src_id_type == SILC_ID_CLIENT) {
2030 sender_entry = silc_idlist_find_client_by_id(server->local_list,
2031 sender_id, TRUE, NULL);
2032 if (!sender_entry) {
2034 sender_entry = silc_idlist_find_client_by_id(server->global_list,
2035 sender_id, TRUE, NULL);
2037 if (!sender_entry || !silc_server_client_on_channel(sender_entry,
2039 SILC_LOG_DEBUG(("Client not on channel"));
2043 /* If channel is moderated check that client is allowed to send
2045 if (channel->mode & SILC_CHANNEL_MODE_SILENCE_USERS &&
2046 !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
2047 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
2048 SILC_LOG_DEBUG(("Channel is silenced from normal users"));
2051 if (channel->mode & SILC_CHANNEL_MODE_SILENCE_OPERS &&
2052 chl->mode & SILC_CHANNEL_UMODE_CHANOP &&
2053 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
2054 SILC_LOG_DEBUG(("Channel is silenced from operators"));
2057 if (chl->mode & SILC_CHANNEL_UMODE_QUIET) {
2058 SILC_LOG_DEBUG(("Sender is quieted on the channel"));
2062 /* If the packet is coming from router, but the client entry is local
2063 entry to us then some router is rerouting this to us and it is not
2064 allowed. When the client is local to us it means that we've routed
2065 this packet to network, and now someone is routing it back to us. */
2066 if (server->server_type == SILC_ROUTER &&
2067 sock->type == SILC_SOCKET_TYPE_ROUTER && local) {
2068 SILC_LOG_DEBUG(("Channel message rerouted to the sender, drop it"));
2073 /* Distribute the packet to our local clients. This will send the
2074 packet for further routing as well, if needed. */
2075 silc_server_packet_relay_to_channel(server, sock, channel, sender_id,
2076 packet->src_id_type, sender_entry,
2077 packet->buffer->data,
2078 packet->buffer->len, FALSE);
2081 silc_free(sender_id);
2085 /* Received channel key packet. We distribute the key to all of our locally
2086 connected clients on the channel. */
2088 void silc_server_channel_key(SilcServer server,
2089 SilcSocketConnection sock,
2090 SilcPacketContext *packet)
2092 SilcBuffer buffer = packet->buffer;
2093 SilcChannelEntry channel;
2095 if (packet->src_id_type != SILC_ID_SERVER ||
2096 (server->server_type == SILC_ROUTER && !server->backup_router &&
2097 sock->type == SILC_SOCKET_TYPE_ROUTER))
2100 /* Save the channel key */
2101 channel = silc_server_save_channel_key(server, buffer, NULL);
2105 /* Distribute the key to everybody who is on the channel. If we are router
2106 we will also send it to locally connected servers. */
2107 silc_server_send_channel_key(server, sock, channel, FALSE);
2109 if (server->server_type != SILC_BACKUP_ROUTER) {
2110 /* Distribute to local cell backup routers. */
2111 silc_server_backup_send(server, sock->user_data,
2112 SILC_PACKET_CHANNEL_KEY, 0,
2113 buffer->data, buffer->len, FALSE, TRUE);
2117 /* Received New Client packet and processes it. Creates Client ID for the
2118 client. Client becomes registered after calling this functions. */
2120 SilcClientEntry silc_server_new_client(SilcServer server,
2121 SilcSocketConnection sock,
2122 SilcPacketContext *packet)
2124 SilcBuffer buffer = packet->buffer;
2125 SilcClientEntry client;
2126 SilcClientID *client_id;
2127 SilcIDListData idata;
2128 char *username = NULL, *realname = NULL;
2129 SilcUInt16 username_len;
2132 char *hostname, *nickname;
2135 SILC_LOG_DEBUG(("Creating new client"));
2137 if (sock->type != SILC_SOCKET_TYPE_CLIENT)
2140 /* Take client entry */
2141 client = (SilcClientEntry)sock->user_data;
2142 idata = (SilcIDListData)client;
2144 /* Remove the old cache entry. */
2145 if (!silc_idcache_del_by_context(server->local_list->clients, client)) {
2146 SILC_LOG_INFO(("Unauthenticated client attempted to register to network"));
2147 silc_server_disconnect_remote(server, sock,
2148 SILC_STATUS_ERR_NOT_AUTHENTICATED, NULL);
2149 if (sock->user_data)
2150 silc_server_free_sock_user_data(server, sock, NULL);
2154 /* Parse incoming packet */
2155 ret = silc_buffer_unformat(buffer,
2156 SILC_STR_UI16_NSTRING_ALLOC(&username,
2158 SILC_STR_UI16_STRING_ALLOC(&realname),
2161 silc_free(username);
2162 silc_free(realname);
2163 SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
2164 "connection", sock->hostname, sock->ip));
2165 silc_server_disconnect_remote(server, sock,
2166 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2168 if (sock->user_data)
2169 silc_server_free_sock_user_data(server, sock, NULL);
2174 silc_free(username);
2175 silc_free(realname);
2176 SILC_LOG_ERROR(("Client %s (%s) did not send its username, closing "
2177 "connection", sock->hostname, sock->ip));
2178 silc_server_disconnect_remote(server, sock,
2179 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2181 if (sock->user_data)
2182 silc_server_free_sock_user_data(server, sock, NULL);
2186 if (username_len > 128)
2187 username[128] = '\0';
2189 /* Check for bad characters for nickname, and modify the nickname if
2190 it includes those. */
2191 if (silc_server_name_bad_chars(username, username_len)) {
2192 nickname = silc_server_name_modify_bad(username, username_len);
2194 nickname = strdup(username);
2197 /* Make sanity checks for the hostname of the client. If the hostname
2198 is provided in the `username' check that it is the same than the
2199 resolved hostname, or if not resolved the hostname that appears in
2200 the client's public key. If the hostname is not present then put
2201 it from the resolved name or from the public key. */
2202 if (strchr(username, '@')) {
2203 SilcPublicKeyIdentifier pident;
2204 int tlen = strcspn(username, "@");
2205 char *phostname = NULL;
2207 hostname = silc_memdup(username + tlen + 1, strlen(username) - tlen - 1);
2209 if (strcmp(sock->hostname, sock->ip) &&
2210 strcmp(sock->hostname, hostname)) {
2211 silc_free(username);
2212 silc_free(hostname);
2213 silc_free(realname);
2214 SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
2215 "connection", sock->hostname, sock->ip));
2216 silc_server_disconnect_remote(server, sock,
2217 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2219 if (sock->user_data)
2220 silc_server_free_sock_user_data(server, sock, NULL);
2224 pident = silc_pkcs_decode_identifier(client->data.public_key->identifier);
2226 phostname = strdup(pident->host);
2227 silc_pkcs_free_identifier(pident);
2230 if (!strcmp(sock->hostname, sock->ip) &&
2231 phostname && strcmp(phostname, hostname)) {
2232 silc_free(username);
2233 silc_free(hostname);
2234 silc_free(phostname);
2235 silc_free(realname);
2236 SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
2237 "connection", sock->hostname, sock->ip));
2238 silc_server_disconnect_remote(server, sock,
2239 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2241 if (sock->user_data)
2242 silc_server_free_sock_user_data(server, sock, NULL);
2246 silc_free(phostname);
2248 /* The hostname is not present, add it. */
2250 /* XXX For now we cannot take the host name from the public key since
2251 they are not trusted or we cannot verify them as trusted. Just take
2252 what the resolved name or address is. */
2254 if (strcmp(sock->hostname, sock->ip)) {
2256 newusername = silc_calloc(strlen(username) +
2257 strlen(sock->hostname) + 2,
2258 sizeof(*newusername));
2259 strncat(newusername, username, strlen(username));
2260 strncat(newusername, "@", 1);
2261 strncat(newusername, sock->hostname, strlen(sock->hostname));
2262 silc_free(username);
2263 username = newusername;
2266 SilcPublicKeyIdentifier pident =
2267 silc_pkcs_decode_identifier(client->data.public_key->identifier);
2270 newusername = silc_calloc(strlen(username) +
2271 strlen(pident->host) + 2,
2272 sizeof(*newusername));
2273 strncat(newusername, username, strlen(username));
2274 strncat(newusername, "@", 1);
2275 strncat(newusername, pident->host, strlen(pident->host));
2276 silc_free(username);
2277 username = newusername;
2278 silc_pkcs_free_identifier(pident);
2284 /* Create Client ID */
2285 while (!silc_id_create_client_id(server, server->id, server->rng,
2286 server->md5hash, nickname, &client_id)) {
2289 silc_server_disconnect_remote(server, sock,
2290 SILC_STATUS_ERR_BAD_NICKNAME, NULL);
2291 if (sock->user_data)
2292 silc_server_free_sock_user_data(server, sock, NULL);
2295 snprintf(&nickname[strlen(nickname) - 1], 1, "%d", nickfail);
2298 /* If client marked as anonymous, scramble the username and hostname */
2299 if (client->mode & SILC_UMODE_ANONYMOUS) {
2302 if (strlen(username) >= 2) {
2303 username[0] = silc_rng_get_byte_fast(server->rng);
2304 username[1] = silc_rng_get_byte_fast(server->rng);
2307 scramble = silc_hash_babbleprint(server->sha1hash, username,
2311 memcpy(&scramble[16], ".silc", 5);
2312 scramble[21] = '\0';
2313 silc_free(username);
2314 username = scramble;
2317 /* Update client entry */
2318 idata->status |= SILC_IDLIST_STATUS_REGISTERED;
2319 client->nickname = nickname;
2320 client->username = username;
2321 client->userinfo = realname ? realname : strdup(username);
2322 client->id = client_id;
2323 id_len = silc_id_get_len(client_id, SILC_ID_CLIENT);
2325 /* Add the client again to the ID cache */
2326 silc_idcache_add(server->local_list->clients, client->nickname,
2327 client_id, client, 0, NULL);
2329 /* Notify our router about new client on the SILC network */
2330 silc_server_send_new_id(server, SILC_PRIMARY_ROUTE(server),
2331 SILC_BROADCAST(server), client->id,
2332 SILC_ID_CLIENT, id_len);
2334 /* Distribute to backup routers */
2335 if (server->server_type == SILC_ROUTER) {
2336 SilcBuffer idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
2337 silc_server_backup_send(server, sock->user_data, SILC_PACKET_NEW_ID, 0,
2338 idp->data, idp->len, FALSE, TRUE);
2339 silc_buffer_free(idp);
2342 /* Send the new client ID to the client. */
2343 silc_server_send_new_id(server, sock, FALSE, client->id, SILC_ID_CLIENT,
2344 silc_id_get_len(client->id, SILC_ID_CLIENT));
2346 /* Send some nice info to the client */
2347 silc_server_send_connect_notifys(server, sock, client);
2349 /* Check if anyone is watching this nickname */
2350 if (server->server_type == SILC_ROUTER)
2351 silc_server_check_watcher_list(server, client, NULL, 0);
2356 /* Create new server. This processes received New Server packet and
2357 saves the received Server ID. The server is our locally connected
2358 server thus we save all the information and save it to local list.
2359 This funtion can be used by both normal server and router server.
2360 If normal server uses this it means that its router has connected
2361 to the server. If router uses this it means that one of the cell's
2362 servers is connected to the router. */
2364 SilcServerEntry silc_server_new_server(SilcServer server,
2365 SilcSocketConnection sock,
2366 SilcPacketContext *packet)
2368 SilcBuffer buffer = packet->buffer;
2369 SilcServerEntry new_server, server_entry;
2370 SilcServerID *server_id;
2371 SilcIDListData idata;
2372 unsigned char *server_name, *id_string;
2373 SilcUInt16 id_len, name_len;
2377 SILC_LOG_DEBUG(("Creating new server"));
2379 if (sock->type != SILC_SOCKET_TYPE_SERVER &&
2380 sock->type != SILC_SOCKET_TYPE_ROUTER)
2383 /* Take server entry */
2384 new_server = (SilcServerEntry)sock->user_data;
2385 idata = (SilcIDListData)new_server;
2387 /* Remove the old cache entry */
2388 if (!silc_idcache_del_by_context(server->local_list->servers, new_server)) {
2389 if (!silc_idcache_del_by_context(server->global_list->servers,
2391 SILC_LOG_INFO(("Unauthenticated %s attempted to register to "
2392 "network", (sock->type == SILC_SOCKET_TYPE_SERVER ?
2393 "server" : "router")));
2394 silc_server_disconnect_remote(server, sock,
2395 SILC_STATUS_ERR_NOT_AUTHENTICATED, NULL);
2396 if (sock->user_data)
2397 silc_server_free_sock_user_data(server, sock, NULL);
2403 /* Parse the incoming packet */
2404 ret = silc_buffer_unformat(buffer,
2405 SILC_STR_UI16_NSTRING_ALLOC(&id_string, &id_len),
2406 SILC_STR_UI16_NSTRING_ALLOC(&server_name,
2410 silc_free(id_string);
2411 silc_free(server_name);
2412 silc_server_disconnect_remote(server, sock,
2413 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2415 if (sock->user_data)
2416 silc_server_free_sock_user_data(server, sock, NULL);
2420 if (id_len > buffer->len) {
2421 silc_free(id_string);
2422 silc_free(server_name);
2423 silc_server_disconnect_remote(server, sock,
2424 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2426 if (sock->user_data)
2427 silc_server_free_sock_user_data(server, sock, NULL);
2432 server_name[255] = '\0';
2435 server_id = silc_id_str2id(id_string, id_len, SILC_ID_SERVER);
2437 silc_free(id_string);
2438 silc_free(server_name);
2439 silc_server_disconnect_remote(server, sock,
2440 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2442 if (sock->user_data)
2443 silc_server_free_sock_user_data(server, sock, NULL);
2446 silc_free(id_string);
2448 /* Check for valid server ID */
2449 if (!silc_id_is_valid_server_id(server, server_id, sock)) {
2450 SILC_LOG_INFO(("Invalid server ID sent by %s (%s)",
2451 sock->ip, sock->hostname));
2452 silc_server_disconnect_remote(server, sock,
2453 SILC_STATUS_ERR_BAD_SERVER_ID, NULL);
2454 if (sock->user_data)
2455 silc_server_free_sock_user_data(server, sock, NULL);
2456 silc_free(server_name);
2460 /* Check that we do not have this ID already */
2461 server_entry = silc_idlist_find_server_by_id(server->local_list,
2462 server_id, TRUE, NULL);
2464 silc_idcache_del_by_context(server->local_list->servers, server_entry);
2466 server_entry = silc_idlist_find_server_by_id(server->global_list,
2467 server_id, TRUE, NULL);
2469 silc_idcache_del_by_context(server->global_list->servers, server_entry);
2472 /* Update server entry */
2473 idata->status |= SILC_IDLIST_STATUS_REGISTERED;
2474 new_server->server_name = server_name;
2475 new_server->id = server_id;
2477 SILC_LOG_DEBUG(("New server id(%s)",
2478 silc_id_render(server_id, SILC_ID_SERVER)));
2480 /* Add again the entry to the ID cache. */
2481 silc_idcache_add(local ? server->local_list->servers :
2482 server->global_list->servers, server_name, server_id,
2483 new_server, 0, NULL);
2485 /* Distribute the information about new server in the SILC network
2486 to our router. If we are normal server we won't send anything
2487 since this connection must be our router connection. */
2488 if (server->server_type == SILC_ROUTER && !server->standalone &&
2489 SILC_PRIMARY_ROUTE(server) != sock)
2490 silc_server_send_new_id(server, SILC_PRIMARY_ROUTE(server),
2491 TRUE, new_server->id, SILC_ID_SERVER,
2492 silc_id_get_len(server_id, SILC_ID_SERVER));
2494 if (server->server_type == SILC_ROUTER) {
2495 /* Distribute to backup routers */
2496 SilcBuffer idp = silc_id_payload_encode(new_server->id, SILC_ID_SERVER);
2497 silc_server_backup_send(server, sock->user_data, SILC_PACKET_NEW_ID, 0,
2498 idp->data, idp->len, FALSE, TRUE);
2499 silc_buffer_free(idp);
2502 server->stat.cell_servers++;
2505 /* Check whether this router connection has been replaced by an
2506 backup router. If it has been then we'll disable the server and will
2507 ignore everything it will send until the backup router resuming
2508 protocol has been completed. */
2509 if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
2510 silc_server_backup_replaced_get(server, server_id, NULL)) {
2511 /* Send packet to the server indicating that it cannot use this
2512 connection as it has been replaced by backup router. */
2513 SilcBuffer packet = silc_buffer_alloc(2);
2514 silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
2515 silc_buffer_format(packet,
2516 SILC_STR_UI_CHAR(SILC_SERVER_BACKUP_REPLACED),
2517 SILC_STR_UI_CHAR(0),
2519 silc_server_packet_send(server, sock,
2520 SILC_PACKET_RESUME_ROUTER, 0,
2521 packet->data, packet->len, TRUE);
2522 silc_buffer_free(packet);
2524 /* Mark the router disabled. The data sent earlier will go but nothing
2525 after this does not go to this connection. */
2526 idata->status |= SILC_IDLIST_STATUS_DISABLED;
2528 /* If it is router announce our stuff to it. */
2529 if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
2530 server->server_type == SILC_ROUTER) {
2531 silc_server_announce_servers(server, FALSE, 0, sock);
2532 silc_server_announce_clients(server, 0, sock);
2533 silc_server_announce_channels(server, 0, sock);
2536 /* Announce our information to backup router */
2537 if (new_server->server_type == SILC_BACKUP_ROUTER &&
2538 sock->type == SILC_SOCKET_TYPE_SERVER &&
2539 server->server_type == SILC_ROUTER) {
2540 silc_server_announce_servers(server, TRUE, 0, sock);
2541 silc_server_announce_clients(server, 0, sock);
2542 silc_server_announce_channels(server, 0, sock);
2545 /* If backup router, mark it as one of ours. This server is considered
2546 to be backup router after this setting. */
2547 if (new_server->server_type == SILC_BACKUP_ROUTER) {
2548 SilcServerConfigRouter *backup;
2549 backup = silc_server_config_find_backup_conn(server, sock->ip);
2551 backup = silc_server_config_find_backup_conn(server, sock->hostname);
2553 /* Add as our backup router */
2554 silc_server_backup_add(server, new_server, backup->backup_replace_ip,
2555 backup->backup_replace_port,
2556 backup->backup_local);
2560 /* By default the servers connected to backup router are disabled
2561 until backup router has become the primary */
2562 if (server->server_type == SILC_BACKUP_ROUTER &&
2563 sock->type == SILC_SOCKET_TYPE_SERVER)
2564 idata->status |= SILC_IDLIST_STATUS_DISABLED;
2570 /* Processes incoming New ID packet. New ID Payload is used to distribute
2571 information about newly registered clients and servers. */
2573 static void silc_server_new_id_real(SilcServer server,
2574 SilcSocketConnection sock,
2575 SilcPacketContext *packet,
2578 SilcBuffer buffer = packet->buffer;
2580 SilcServerEntry router, server_entry;
2581 SilcSocketConnection router_sock;
2586 SILC_LOG_DEBUG(("Processing new ID"));
2588 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2589 server->server_type == SILC_SERVER ||
2590 packet->src_id_type != SILC_ID_SERVER)
2593 idp = silc_id_payload_parse(buffer->data, buffer->len);
2597 id_type = silc_id_payload_get_type(idp);
2599 /* Normal server cannot have other normal server connections */
2600 server_entry = (SilcServerEntry)sock->user_data;
2601 if (id_type == SILC_ID_SERVER && sock->type == SILC_SOCKET_TYPE_SERVER &&
2602 server_entry->server_type == SILC_SERVER)
2605 id = silc_id_payload_get_id(idp);
2609 /* If the packet is coming from server then use the sender as the
2610 origin of the the packet. If it came from router then check the real
2611 sender of the packet and use that as the origin. */
2612 if (sock->type == SILC_SOCKET_TYPE_SERVER) {
2613 id_list = server->local_list;
2615 router = sock->user_data;
2617 /* If the sender is backup router and ID is server (and we are not
2618 backup router) then switch the entry to global list. */
2619 if (server_entry->server_type == SILC_BACKUP_ROUTER &&
2620 id_type == SILC_ID_SERVER &&
2621 server->id_entry->server_type != SILC_BACKUP_ROUTER) {
2622 id_list = server->global_list;
2623 router_sock = server->router ? SILC_PRIMARY_ROUTE(server) : sock;
2626 void *sender_id = silc_id_str2id(packet->src_id, packet->src_id_len,
2627 packet->src_id_type);
2628 router = silc_idlist_find_server_by_id(server->global_list,
2629 sender_id, TRUE, NULL);
2631 router = silc_idlist_find_server_by_id(server->local_list,
2632 sender_id, TRUE, NULL);
2633 silc_free(sender_id);
2635 id_list = server->global_list;
2642 case SILC_ID_CLIENT:
2644 SilcClientEntry entry;
2646 /* Check that we do not have this client already */
2647 entry = silc_idlist_find_client_by_id(server->global_list,
2648 id, server->server_type,
2651 entry = silc_idlist_find_client_by_id(server->local_list,
2652 id, server->server_type,
2655 SILC_LOG_DEBUG(("Ignoring client that we already have"));
2659 SILC_LOG_DEBUG(("New client id(%s) from [%s] %s",
2660 silc_id_render(id, SILC_ID_CLIENT),
2661 sock->type == SILC_SOCKET_TYPE_SERVER ?
2662 "Server" : "Router", sock->hostname));
2664 /* As a router we keep information of all global information in our
2665 global list. Cell wide information however is kept in the local
2667 entry = silc_idlist_add_client(id_list, NULL, NULL, NULL,
2668 id, router, NULL, 0);
2670 SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
2672 /* Inform the sender that the ID is not usable */
2673 silc_server_send_notify_signoff(server, sock, FALSE, id, NULL);
2676 entry->nickname = NULL;
2677 entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
2679 if (sock->type == SILC_SOCKET_TYPE_SERVER)
2680 server->stat.cell_clients++;
2681 server->stat.clients++;
2683 /* Check if anyone is watching this nickname */
2684 if (server->server_type == SILC_ROUTER && id_list == server->local_list)
2685 silc_server_check_watcher_list(server, entry, NULL, 0);
2689 case SILC_ID_SERVER:
2691 SilcServerEntry entry;
2693 /* If the ID is mine, ignore it. */
2694 if (SILC_ID_SERVER_COMPARE(id, server->id)) {
2695 SILC_LOG_DEBUG(("Ignoring my own ID as new ID"));
2699 /* If the ID is the sender's ID, ignore it (we have it already) */
2700 if (SILC_ID_SERVER_COMPARE(id, router->id)) {
2701 SILC_LOG_DEBUG(("Ignoring sender's own ID"));
2705 /* Check that we do not have this server already */
2706 entry = silc_idlist_find_server_by_id(server->global_list,
2707 id, server->server_type,
2710 entry = silc_idlist_find_server_by_id(server->local_list,
2711 id, server->server_type,
2714 SILC_LOG_DEBUG(("Ignoring server that we already have"));
2718 SILC_LOG_DEBUG(("New server id(%s) from [%s] %s",
2719 silc_id_render(id, SILC_ID_SERVER),
2720 sock->type == SILC_SOCKET_TYPE_SERVER ?
2721 "Server" : "Router", sock->hostname));
2723 /* As a router we keep information of all global information in our
2724 global list. Cell wide information however is kept in the local
2726 entry = silc_idlist_add_server(id_list, NULL, 0, id, router,
2729 SILC_LOG_ERROR(("Could not add new server to the ID Cache"));
2732 entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
2734 if (sock->type == SILC_SOCKET_TYPE_SERVER)
2735 server->stat.cell_servers++;
2736 server->stat.servers++;
2740 case SILC_ID_CHANNEL:
2741 SILC_LOG_ERROR(("Channel cannot be registered with NEW_ID packet"));
2750 /* If the sender of this packet is server and we are router we need to
2751 broadcast this packet to other routers in the network. */
2752 if (broadcast && server->server_type == SILC_ROUTER &&
2753 sock->type == SILC_SOCKET_TYPE_SERVER &&
2754 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2755 SILC_LOG_DEBUG(("Broadcasting received New ID packet"));
2756 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
2758 packet->flags | SILC_PACKET_FLAG_BROADCAST,
2759 buffer->data, buffer->len, FALSE);
2760 silc_server_backup_send(server, sock->user_data,
2761 packet->type, packet->flags,
2762 packet->buffer->data, packet->buffer->len,
2767 silc_id_payload_free(idp);
2771 /* Processes incoming New ID packet. New ID Payload is used to distribute
2772 information about newly registered clients and servers. */
2774 void silc_server_new_id(SilcServer server, SilcSocketConnection sock,
2775 SilcPacketContext *packet)
2777 silc_server_new_id_real(server, sock, packet, TRUE);
2780 /* Receoved New Id List packet, list of New ID payloads inside one
2781 packet. Process the New ID payloads one by one. */
2783 void silc_server_new_id_list(SilcServer server, SilcSocketConnection sock,
2784 SilcPacketContext *packet)
2786 SilcPacketContext *new_id;
2790 SILC_LOG_DEBUG(("Processing New ID List"));
2792 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2793 packet->src_id_type != SILC_ID_SERVER)
2796 /* If the sender of this packet is server and we are router we need to
2797 broadcast this packet to other routers in the network. Broadcast
2798 this list packet instead of multiple New ID packets. */
2799 if (server->server_type == SILC_ROUTER &&
2800 sock->type == SILC_SOCKET_TYPE_SERVER &&
2801 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2802 SILC_LOG_DEBUG(("Broadcasting received New ID List packet"));
2803 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
2805 packet->flags | SILC_PACKET_FLAG_BROADCAST,
2806 packet->buffer->data,
2807 packet->buffer->len, FALSE);
2808 silc_server_backup_send(server, sock->user_data,
2809 packet->type, packet->flags,
2810 packet->buffer->data, packet->buffer->len,
2814 /* Make copy of the original packet context, except for the actual
2815 data buffer, which we will here now fetch from the original buffer. */
2816 new_id = silc_packet_context_alloc();
2817 new_id->type = SILC_PACKET_NEW_ID;
2818 new_id->flags = packet->flags & (~SILC_PACKET_FLAG_LIST);
2819 new_id->src_id = packet->src_id;
2820 new_id->src_id_len = packet->src_id_len;
2821 new_id->src_id_type = packet->src_id_type;
2822 new_id->dst_id = packet->dst_id;
2823 new_id->dst_id_len = packet->dst_id_len;
2824 new_id->dst_id_type = packet->dst_id_type;
2826 idp = silc_buffer_alloc(256);
2827 new_id->buffer = idp;
2829 while (packet->buffer->len) {
2830 SILC_GET16_MSB(id_len, packet->buffer->data + 2);
2831 if ((id_len > packet->buffer->len) ||
2832 (id_len > idp->truelen))
2835 silc_buffer_pull_tail(idp, 4 + id_len);
2836 silc_buffer_put(idp, packet->buffer->data, 4 + id_len);
2838 /* Process the New ID */
2839 silc_server_new_id_real(server, sock, new_id, FALSE);
2841 silc_buffer_push_tail(idp, 4 + id_len);
2842 silc_buffer_pull(packet->buffer, 4 + id_len);
2845 silc_buffer_free(idp);
2849 /* Received New Channel packet. Information about new channels in the
2850 network are distributed using this packet. Save the information about
2851 the new channel. This usually comes from router but also normal server
2852 can send this to notify channels it has when it connects to us. */
2854 void silc_server_new_channel(SilcServer server,
2855 SilcSocketConnection sock,
2856 SilcPacketContext *packet)
2858 SilcChannelPayload payload;
2859 SilcChannelID *channel_id;
2861 SilcUInt32 name_len;
2863 SilcUInt32 id_len, cipher_len;
2864 SilcServerEntry server_entry;
2865 SilcChannelEntry channel;
2868 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2869 packet->src_id_type != SILC_ID_SERVER ||
2870 server->server_type == SILC_SERVER)
2873 /* Parse the channel payload */
2874 payload = silc_channel_payload_parse(packet->buffer->data,
2875 packet->buffer->len);
2879 /* Get the channel ID */
2880 channel_id = silc_channel_get_id_parse(payload);
2882 silc_channel_payload_free(payload);
2886 channel_name = silc_channel_get_name(payload, &name_len);
2888 channel_name[255] = '\0';
2890 id = silc_channel_get_id(payload, &id_len);
2892 server_entry = (SilcServerEntry)sock->user_data;
2894 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
2895 /* Add the channel to global list as it is coming from router. It
2896 cannot be our own channel as it is coming from router. */
2898 /* Check that we don't already have this channel */
2899 channel = silc_idlist_find_channel_by_name(server->local_list,
2900 channel_name, NULL);
2902 channel = silc_idlist_find_channel_by_name(server->global_list,
2903 channel_name, NULL);
2905 SILC_LOG_DEBUG(("New channel id(%s) from [Router] %s",
2906 silc_id_render(channel_id, SILC_ID_CHANNEL),
2910 silc_idlist_add_channel(server->global_list, strdup(channel_name),
2911 0, channel_id, sock->user_data, NULL, NULL, 0);
2913 silc_channel_payload_free(payload);
2914 silc_free(channel_id);
2917 channel->disabled = TRUE; /* Disabled until someone JOINs */
2919 server->stat.channels++;
2920 if (server->server_type == SILC_ROUTER)
2921 channel->users_resolved = TRUE;
2924 /* The channel is coming from our server, thus it is in our cell
2925 we will add it to our local list. */
2928 SILC_LOG_DEBUG(("Channel id(%s) from [Server] %s",
2929 silc_id_render(channel_id, SILC_ID_CHANNEL),
2932 /* Check that we don't already have this channel */
2933 channel = silc_idlist_find_channel_by_name(server->local_list,
2934 channel_name, NULL);
2936 channel = silc_idlist_find_channel_by_name(server->global_list,
2937 channel_name, NULL);
2939 /* If the channel does not exist, then create it. This creates a new
2940 key to the channel as well that we will send to the server. */
2942 SILC_LOG_DEBUG(("Channel is new to us"));
2944 /* The protocol says that the Channel ID's IP address must be based
2945 on the router's IP address. Check whether the ID is based in our
2946 IP and if it is not then create a new ID and enforce the server
2947 to switch the ID. */
2948 if (server_entry->server_type != SILC_BACKUP_ROUTER &&
2949 !SILC_ID_COMPARE(channel_id, server->id, server->id->ip.data_len)) {
2951 SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
2952 if (silc_id_create_channel_id(server, server->id, server->rng, &tmp)) {
2953 silc_server_send_notify_channel_change(server, sock, FALSE,
2955 silc_channel_payload_free(payload);
2956 silc_free(channel_id);
2960 /* Wait that server re-announces this channel */
2964 /* Create the channel with the provided Channel ID */
2965 channel = silc_server_create_new_channel_with_id(server, NULL, NULL,
2969 silc_channel_payload_free(payload);
2970 silc_free(channel_id);
2973 channel->disabled = TRUE; /* Disabled until someone JOINs */
2975 #if 0 /* We assume that CMODE_CHANGE notify is sent to us after this. */
2977 /* XXX Dunno if this is supposed to be set in any server type. If set
2978 here the CMODE_CHANGE that may follow sets mode that we already
2979 have, and we may loose data from the CMODE_CHANGE notify. */
2980 if (server_entry->server_type != SILC_BACKUP_ROUTER)
2981 channel->mode = silc_channel_get_mode(payload);
2984 /* Send the new channel key to the server */
2985 id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
2986 id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
2987 cipher = silc_cipher_get_name(channel->channel_key);
2988 cipher_len = strlen(cipher);
2989 chk = silc_channel_key_payload_encode(id_len, id,
2991 channel->key_len / 8,
2993 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
2994 chk->data, chk->len, FALSE);
2995 silc_buffer_free(chk);
2998 /* The channel exist by that name, check whether the ID's match.
2999 If they don't then we'll force the server to use the ID we have.
3000 We also create a new key for the channel. */
3001 SilcBuffer modes = NULL, users = NULL, users_modes = NULL;
3003 SILC_LOG_DEBUG(("Channel already exists"));
3005 if (!SILC_ID_CHANNEL_COMPARE(channel_id, channel->id)) {
3006 /* They don't match, send CHANNEL_CHANGE notify to the server to
3007 force the ID change. */
3008 SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
3009 silc_server_send_notify_channel_change(server, sock, FALSE,
3010 channel_id, channel->id);
3011 silc_channel_payload_free(payload);
3012 silc_free(channel_id);
3014 /* Wait that server re-announces this channel */
3018 #if 0 /* We will announce our CMODE anyway for this channel, so no need
3019 to check it (implicit enforce). */
3021 /* If the mode is different from what we have then enforce the
3023 mode = silc_channel_get_mode(payload);
3024 if (channel->mode != mode) {
3025 SILC_LOG_DEBUG(("Forcing the server to change channel mode"));
3026 silc_server_send_notify_cmode(server, sock, FALSE, channel,
3027 channel->mode, server->id,
3028 SILC_ID_SERVER, channel->cipher,
3030 channel->passphrase,
3031 channel->founder_key);
3035 /* Create new key for the channel and send it to the server and
3036 everybody else possibly on the channel. */
3037 if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
3039 if (silc_hash_table_count(channel->user_list)) {
3040 if (!silc_server_create_channel_key(server, channel, 0)) {
3041 silc_channel_payload_free(payload);
3042 silc_free(channel_id);
3046 /* Send to the channel */
3047 silc_server_send_channel_key(server, sock, channel, FALSE);
3050 /* Send to the server */
3051 id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
3052 id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
3053 cipher = silc_cipher_get_name(channel->channel_key);
3054 cipher_len = strlen(cipher);
3055 chk = silc_channel_key_payload_encode(id_len, id,
3057 channel->key_len / 8,
3059 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
3060 chk->data, chk->len, FALSE);
3061 silc_buffer_free(chk);
3065 silc_free(channel_id);
3067 /* Since the channel is coming from server and we also know about it
3068 then send the JOIN notify to the server so that it see's our
3069 users on the channel "joining" the channel. */
3070 silc_server_announce_get_channel_users(server, channel, &modes, &users,
3073 silc_buffer_push(users, users->data - users->head);
3074 silc_server_packet_send(server, sock,
3075 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
3076 users->data, users->len, FALSE);
3077 silc_buffer_free(users);
3080 silc_buffer_push(modes, modes->data - modes->head);
3081 silc_server_packet_send_dest(server, sock,
3082 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
3083 channel->id, SILC_ID_CHANNEL,
3084 modes->data, modes->len, FALSE);
3085 silc_buffer_free(modes);
3088 silc_buffer_push(users_modes, users_modes->data - users_modes->head);
3089 silc_server_packet_send_dest(server, sock,
3090 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
3091 channel->id, SILC_ID_CHANNEL,
3093 users_modes->len, FALSE);
3094 silc_buffer_free(users_modes);
3096 if (channel->topic) {
3097 silc_server_send_notify_topic_set(server, sock,
3098 server->server_type == SILC_ROUTER ?
3099 TRUE : FALSE, channel,
3100 server->id, SILC_ID_SERVER,
3106 /* If the sender of this packet is server and we are router we need to
3107 broadcast this packet to other routers in the network. Broadcast
3108 this list packet instead of multiple New Channel packets. */
3109 if (server->server_type == SILC_ROUTER &&
3110 sock->type == SILC_SOCKET_TYPE_SERVER &&
3111 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
3112 SILC_LOG_DEBUG(("Broadcasting received New Channel packet"));
3113 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3115 packet->flags | SILC_PACKET_FLAG_BROADCAST,
3116 packet->buffer->data,
3117 packet->buffer->len, FALSE);
3118 silc_server_backup_send(server, sock->user_data,
3119 packet->type, packet->flags,
3120 packet->buffer->data, packet->buffer->len,
3124 silc_channel_payload_free(payload);
3127 /* Received New Channel List packet, list of New Channel List payloads inside
3128 one packet. Process the New Channel payloads one by one. */
3130 void silc_server_new_channel_list(SilcServer server,
3131 SilcSocketConnection sock,
3132 SilcPacketContext *packet)
3134 SilcPacketContext *new;
3136 SilcUInt16 len1, len2;
3138 SILC_LOG_DEBUG(("Processing New Channel List"));
3140 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
3141 packet->src_id_type != SILC_ID_SERVER ||
3142 server->server_type == SILC_SERVER)
3145 /* Make copy of the original packet context, except for the actual
3146 data buffer, which we will here now fetch from the original buffer. */
3147 new = silc_packet_context_alloc();
3148 new->type = SILC_PACKET_NEW_CHANNEL;
3149 new->flags = packet->flags & (~SILC_PACKET_FLAG_LIST);
3150 new->src_id = packet->src_id;
3151 new->src_id_len = packet->src_id_len;
3152 new->src_id_type = packet->src_id_type;
3153 new->dst_id = packet->dst_id;
3154 new->dst_id_len = packet->dst_id_len;
3155 new->dst_id_type = packet->dst_id_type;
3157 buffer = silc_buffer_alloc(512);
3158 new->buffer = buffer;
3160 while (packet->buffer->len) {
3161 SILC_GET16_MSB(len1, packet->buffer->data);
3162 if ((len1 > packet->buffer->len) ||
3163 (len1 > buffer->truelen))
3166 SILC_GET16_MSB(len2, packet->buffer->data + 2 + len1);
3167 if ((len2 > packet->buffer->len) ||
3168 (len2 > buffer->truelen))
3171 silc_buffer_pull_tail(buffer, 8 + len1 + len2);
3172 silc_buffer_put(buffer, packet->buffer->data, 8 + len1 + len2);
3174 /* Process the New Channel */
3175 silc_server_new_channel(server, sock, new);
3177 silc_buffer_push_tail(buffer, 8 + len1 + len2);
3178 silc_buffer_pull(packet->buffer, 8 + len1 + len2);
3181 silc_buffer_free(buffer);
3185 /* Received key agreement packet. This packet is never for us. It is to
3186 the client in the packet's destination ID. Sending of this sort of packet
3187 equals sending private message, ie. it is sent point to point from
3188 one client to another. */
3190 void silc_server_key_agreement(SilcServer server,
3191 SilcSocketConnection sock,
3192 SilcPacketContext *packet)
3194 SilcSocketConnection dst_sock;
3195 SilcIDListData idata;
3197 SILC_LOG_DEBUG(("Start"));
3199 if (packet->src_id_type != SILC_ID_CLIENT ||
3200 packet->dst_id_type != SILC_ID_CLIENT)
3203 if (!packet->dst_id)
3206 /* Get the route to the client */
3207 dst_sock = silc_server_get_client_route(server, packet->dst_id,
3208 packet->dst_id_len, NULL,
3213 /* Relay the packet */
3214 silc_server_relay_packet(server, dst_sock, idata->send_key,
3215 idata->hmac_send, idata->psn_send++,
3219 /* Received connection auth request packet that is used during connection
3220 phase to resolve the mandatory authentication method. This packet can
3221 actually be received at anytime but usually it is used only during
3222 the connection authentication phase. Now, protocol says that this packet
3223 can come from client or server, however, we support only this coming
3224 from client and expect that server always knows what authentication
3227 void silc_server_connection_auth_request(SilcServer server,
3228 SilcSocketConnection sock,
3229 SilcPacketContext *packet)
3231 SilcServerConfigClient *client = NULL;
3232 SilcUInt16 conn_type;
3234 SilcAuthMethod auth_meth = SILC_AUTH_NONE;
3236 if (packet->src_id_type && packet->src_id_type != SILC_ID_CLIENT) {
3237 SILC_LOG_DEBUG(("Request not from client"));
3241 /* Parse the payload */
3242 ret = silc_buffer_unformat(packet->buffer,
3243 SILC_STR_UI_SHORT(&conn_type),
3244 SILC_STR_UI_SHORT(NULL),
3249 if (conn_type != SILC_SOCKET_TYPE_CLIENT)
3252 /* Get the authentication method for the client */
3253 auth_meth = SILC_AUTH_NONE;
3254 client = silc_server_config_find_client(server, sock->ip);
3256 client = silc_server_config_find_client(server, sock->hostname);
3258 if (client->passphrase) {
3259 if (client->publickeys && !server->config->prefer_passphrase_auth)
3260 auth_meth = SILC_AUTH_PUBLIC_KEY;
3262 auth_meth = SILC_AUTH_PASSWORD;
3263 } else if (client->publickeys)
3264 auth_meth = SILC_AUTH_PUBLIC_KEY;
3267 SILC_LOG_DEBUG(("Authentication method is [%s]",
3268 (auth_meth == SILC_AUTH_NONE ? "None" :
3269 auth_meth == SILC_AUTH_PASSWORD ? "Passphrase" :
3270 "Digital signatures")));
3272 /* Send it back to the client */
3273 silc_server_send_connection_auth_request(server, sock, conn_type, auth_meth);
3276 /* Received REKEY packet. The sender of the packet wants to regenerate
3277 its session keys. This starts the REKEY protocol. */
3279 void silc_server_rekey(SilcServer server,
3280 SilcSocketConnection sock,
3281 SilcPacketContext *packet)
3283 SilcProtocol protocol;
3284 SilcServerRekeyInternalContext *proto_ctx;
3285 SilcIDListData idata = (SilcIDListData)sock->user_data;
3287 SILC_LOG_DEBUG(("Start"));
3289 /* Allocate internal protocol context. This is sent as context
3291 proto_ctx = silc_calloc(1, sizeof(*proto_ctx));
3292 proto_ctx->server = (void *)server;
3293 proto_ctx->sock = sock;
3294 proto_ctx->responder = TRUE;
3295 proto_ctx->pfs = idata->rekey->pfs;
3297 /* Perform rekey protocol. Will call the final callback after the
3298 protocol is over. */
3299 silc_protocol_alloc(SILC_PROTOCOL_SERVER_REKEY,
3300 &protocol, proto_ctx, silc_server_rekey_final);
3301 sock->protocol = protocol;
3303 if (proto_ctx->pfs == FALSE)
3304 /* Run the protocol */
3305 silc_protocol_execute(protocol, server->schedule, 0, 0);
3308 /* Received file transger packet. This packet is never for us. It is to
3309 the client in the packet's destination ID. Sending of this sort of packet
3310 equals sending private message, ie. it is sent point to point from
3311 one client to another. */
3313 void silc_server_ftp(SilcServer server,
3314 SilcSocketConnection sock,
3315 SilcPacketContext *packet)
3317 SilcSocketConnection dst_sock;
3318 SilcIDListData idata;
3320 SILC_LOG_DEBUG(("Start"));
3322 if (packet->src_id_type != SILC_ID_CLIENT ||
3323 packet->dst_id_type != SILC_ID_CLIENT)
3326 if (!packet->dst_id)
3329 /* Get the route to the client */
3330 dst_sock = silc_server_get_client_route(server, packet->dst_id,
3331 packet->dst_id_len, NULL,
3336 /* Relay the packet */
3337 silc_server_relay_packet(server, dst_sock, idata->send_key,
3338 idata->hmac_send, idata->psn_send++,
3344 SilcSocketConnection sock;
3345 SilcPacketContext *packet;
3347 } *SilcServerResumeResolve;
3349 SILC_SERVER_CMD_FUNC(resume_resolve)
3351 SilcServerResumeResolve r = (SilcServerResumeResolve)context;
3352 SilcServer server = r->server;
3353 SilcSocketConnection sock = r->sock;
3354 SilcServerCommandReplyContext reply = context2;
3355 SilcClientEntry client;
3357 SILC_LOG_DEBUG(("Start"));
3359 if (!reply || !silc_command_get_status(reply->payload, NULL, NULL)) {
3360 SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
3361 "closing connection", sock->hostname, sock->ip));
3362 silc_server_disconnect_remote(server, sock,
3363 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3364 "Resuming not possible");
3365 if (sock->user_data)
3366 silc_server_free_sock_user_data(server, sock, NULL);
3370 if (reply && silc_command_get(reply->payload) == SILC_COMMAND_WHOIS) {
3371 /* Get entry to the client, and resolve it if we don't have it. */
3372 client = silc_idlist_find_client_by_id(server->local_list,
3373 r->data, TRUE, NULL);
3375 client = silc_idlist_find_client_by_id(server->global_list,
3376 r->data, TRUE, NULL);
3378 SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
3379 "closing connection", sock->hostname, sock->ip));
3380 silc_server_disconnect_remote(server, sock,
3381 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3382 "Resuming not possible");
3383 if (sock->user_data)
3384 silc_server_free_sock_user_data(server, sock, NULL);
3389 if (!(client->mode & SILC_UMODE_DETACHED)) {
3390 SILC_LOG_ERROR(("Client %s (%s) tried to resume un-detached client, "
3391 "closing connection", sock->hostname, sock->ip));
3392 silc_server_disconnect_remote(server, sock,
3393 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3394 "Resuming not possible");
3395 if (sock->user_data)
3396 silc_server_free_sock_user_data(server, sock, NULL);
3400 client->data.status |= SILC_IDLIST_STATUS_RESUME_RES;
3403 /* Reprocess the packet */
3404 silc_server_resume_client(server, sock, r->packet);
3407 silc_socket_free(r->sock);
3408 silc_packet_context_free(r->packet);
3413 /* Received client resuming packet. This is used to resume detached
3414 client session. It can be sent by the client who wishes to resume
3415 but this is also sent by servers and routers to notify other routers
3416 that the client is not detached anymore. */
3418 void silc_server_resume_client(SilcServer server,
3419 SilcSocketConnection sock,
3420 SilcPacketContext *packet)
3422 SilcBuffer buffer = packet->buffer, buf;
3423 SilcIDListData idata;
3424 SilcIDCacheEntry id_cache = NULL;
3425 SilcClientEntry detached_client;
3426 SilcClientID *client_id = NULL;
3427 unsigned char *id_string, *auth = NULL;
3428 SilcUInt16 id_len, auth_len = 0;
3429 int ret, nickfail = 0;
3430 bool resolved, local, nick_change = FALSE, resolve = FALSE;
3431 SilcChannelEntry channel;
3432 SilcHashTableList htl;
3433 SilcChannelClientEntry chl;
3434 SilcServerResumeResolve r;
3437 ret = silc_buffer_unformat(buffer,
3438 SILC_STR_UI16_NSTRING(&id_string, &id_len),
3441 client_id = silc_id_str2id(id_string, id_len, SILC_ID_CLIENT);
3443 if (sock->type == SILC_SOCKET_TYPE_CLIENT) {
3444 /* Client send this and is attempting to resume to old client session */
3445 SilcClientEntry client;
3449 silc_buffer_pull(buffer, 2 + id_len);
3450 auth = buffer->data;
3451 auth_len = buffer->len;
3452 silc_buffer_push(buffer, 2 + id_len);
3455 if (!client_id || auth_len < 128) {
3456 SILC_LOG_ERROR(("Client %s (%s) sent incomplete resume information, "
3457 "closing connection", sock->hostname, sock->ip));
3458 silc_server_disconnect_remote(server, sock,
3459 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3460 "Resuming not possible");
3461 if (sock->user_data)
3462 silc_server_free_sock_user_data(server, sock, NULL);
3463 silc_free(client_id);
3467 /* Take client entry of this connection */
3468 client = (SilcClientEntry)sock->user_data;
3469 idata = (SilcIDListData)client;
3471 /* Get entry to the client, and resolve it if we don't have it. */
3472 detached_client = silc_server_query_client(server, client_id, FALSE,
3474 if (!detached_client) {
3476 /* The client info is being resolved. Reprocess this packet after
3477 receiving the reply to the query. */
3478 SILC_LOG_DEBUG(("Resolving client"));
3479 r = silc_calloc(1, sizeof(*r));
3483 r->sock = silc_socket_dup(sock);
3484 r->packet = silc_packet_context_dup(packet);
3485 r->data = client_id;
3486 silc_server_command_pending(server, SILC_COMMAND_WHOIS,
3488 silc_server_command_resume_resolve, r);
3490 SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
3491 "closing connection", sock->hostname, sock->ip));
3492 silc_server_disconnect_remote(server, sock,
3493 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3494 "Resuming not possible");
3495 if (sock->user_data)
3496 silc_server_free_sock_user_data(server, sock, NULL);
3497 silc_free(client_id);
3502 if (!(detached_client->mode & SILC_UMODE_DETACHED))
3504 if (!silc_hash_table_count(detached_client->channels) &&
3505 detached_client->router)
3507 if (!detached_client->nickname)
3509 if (detached_client->data.status & SILC_IDLIST_STATUS_RESUME_RES)
3513 if (server->server_type == SILC_SERVER && !server->standalone) {
3514 /* The client info is being resolved. Reprocess this packet after
3515 receiving the reply to the query. */
3516 SILC_LOG_DEBUG(("Resolving client info"));
3517 silc_server_query_client(server, client_id, TRUE, NULL);
3518 r = silc_calloc(1, sizeof(*r));
3522 r->sock = silc_socket_dup(sock);
3523 r->packet = silc_packet_context_dup(packet);
3524 r->data = client_id;
3525 silc_server_command_pending(server, SILC_COMMAND_WHOIS,
3527 silc_server_command_resume_resolve, r);
3530 if (server->server_type == SILC_SERVER) {
3531 SILC_LOG_ERROR(("Client %s (%s) tried to resume un-detached client, "
3532 "closing connection", sock->hostname, sock->ip));
3533 silc_server_disconnect_remote(server, sock,
3534 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3535 "Resuming not possible");
3536 if (sock->user_data)
3537 silc_server_free_sock_user_data(server, sock, NULL);
3538 silc_free(client_id);
3543 /* Check that we have the public key of the client, if not then we must
3544 resolve it first. */
3545 if (!detached_client->data.public_key) {
3546 if (server->server_type == SILC_SERVER && server->standalone) {
3547 SILC_LOG_ERROR(("Detached client's public key not present, "
3548 "closing connection"));
3549 silc_server_disconnect_remote(server, sock,
3550 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3551 "Resuming not possible");
3552 if (sock->user_data)
3553 silc_server_free_sock_user_data(server, sock, NULL);
3554 silc_free(client_id);
3556 /* We must retrieve the detached client's public key by sending
3557 GETKEY command. Reprocess this packet after receiving the key */
3558 SilcBuffer idp = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
3559 SilcSocketConnection dest_sock =
3560 silc_server_get_client_route(server, NULL, 0, client_id, NULL, NULL);
3562 SILC_LOG_DEBUG(("Resolving client public key"));
3564 silc_server_send_command(server, dest_sock ? dest_sock :
3565 SILC_PRIMARY_ROUTE(server),
3566 SILC_COMMAND_GETKEY, ++server->cmd_ident,
3567 1, 1, idp->data, idp->len);
3569 r = silc_calloc(1, sizeof(*r));
3571 silc_free(client_id);
3576 r->sock = silc_socket_dup(sock);
3577 r->packet = silc_packet_context_dup(packet);
3578 silc_server_command_pending(server, SILC_COMMAND_GETKEY,
3580 silc_server_command_resume_resolve, r);
3582 silc_buffer_free(idp);
3584 silc_free(client_id);
3586 } else if (!silc_pkcs_public_key_compare(detached_client->data.public_key,
3587 idata->public_key)) {
3588 /* We require that the connection and resuming authentication data
3589 must be using same key pair. */
3590 SILC_LOG_ERROR(("Resuming attempted with wrong public key, "
3591 "closing connection"));
3592 silc_server_disconnect_remote(server, sock,
3593 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3594 "Resuming not possible");
3595 if (sock->user_data)
3596 silc_server_free_sock_user_data(server, sock, NULL);
3597 silc_free(client_id);
3601 /* Verify the authentication payload. This has to be successful in
3602 order to allow the resuming */
3604 !silc_auth_verify_data(auth, auth_len, SILC_AUTH_PUBLIC_KEY,
3605 detached_client->data.public_key, 0,
3606 idata->hash, detached_client->id,
3608 SILC_LOG_ERROR(("Client %s (%s) resume authentication failed, "
3609 "closing connection", sock->hostname, sock->ip));
3610 silc_server_disconnect_remote(server, sock,
3611 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3612 "Resuming not possible");
3613 if (sock->user_data)
3614 silc_server_free_sock_user_data(server, sock, NULL);
3615 silc_free(client_id);
3619 /* Now resume the client to the network */
3621 silc_schedule_task_del_by_context(server->schedule, detached_client);
3622 sock->user_data = detached_client;
3623 detached_client->connection = sock;
3625 /* Take new keys and stuff into use in the old entry */
3626 silc_idlist_del_data(detached_client);
3627 silc_idlist_add_data(detached_client, idata);
3628 detached_client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
3629 detached_client->data.status |= SILC_IDLIST_STATUS_RESUMED;
3630 detached_client->data.status &= ~SILC_IDLIST_STATUS_RESUME_RES;
3631 detached_client->mode &= ~SILC_UMODE_DETACHED;
3632 server->stat.my_detached--;
3634 /* Send the RESUME_CLIENT packet to our primary router so that others
3635 know this client isn't detached anymore. */
3636 buf = silc_buffer_alloc_size(2 + id_len);
3637 silc_buffer_format(buf,
3638 SILC_STR_UI_SHORT(id_len),
3639 SILC_STR_UI_XNSTRING(id_string, id_len),
3642 /* Send to primary router */
3643 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3644 SILC_PACKET_RESUME_CLIENT, 0,
3645 buf->data, buf->len, TRUE);
3646 silc_server_backup_send(server, NULL, SILC_PACKET_RESUME_CLIENT, 0,
3647 buf->data, buf->len, TRUE, TRUE);
3649 /* As router we must deliver this packet directly to the original
3650 server whom this client was earlier. */
3651 if (server->server_type == SILC_ROUTER && detached_client->router &&
3652 detached_client->router->server_type != SILC_ROUTER)
3653 silc_server_packet_send(server, detached_client->router->connection,
3654 SILC_PACKET_RESUME_CLIENT, 0,
3655 buf->data, buf->len, TRUE);
3656 silc_buffer_free(buf);
3658 detached_client->router = NULL;
3660 /* Delete this client entry since we're resuming to old one. */
3661 server->stat.my_clients--;
3662 server->stat.clients--;
3663 if (server->stat.cell_clients)
3664 server->stat.cell_clients--;
3665 silc_server_remove_from_channels(server, NULL, client, FALSE, NULL, FALSE);
3666 silc_server_del_from_watcher_list(server, client);
3667 if (!silc_idlist_del_client(server->local_list, client))
3668 silc_idlist_del_client(server->global_list, client);
3669 client = detached_client;
3670 silc_free(client->servername);
3671 client->servername = strdup(server->server_name);
3673 /* If the ID is not based in our ID then change it */
3674 if (!SILC_ID_COMPARE(client->id, server->id, server->id->ip.data_len)) {
3675 silc_free(client_id);
3676 while (!silc_id_create_client_id(server, server->id, server->rng,
3677 server->md5hash, client->nickname,
3681 silc_server_disconnect_remote(server, sock,
3682 SILC_STATUS_ERR_BAD_NICKNAME, NULL);
3683 if (sock->user_data)
3684 silc_server_free_sock_user_data(server, sock, NULL);
3687 snprintf(&client->nickname[strlen(client->nickname) - 1], 1,
3694 /* Notify about Client ID change, nickname doesn't actually change. */
3695 silc_server_send_notify_nick_change(server, SILC_PRIMARY_ROUTE(server),
3696 SILC_BROADCAST(server),
3697 client->id, client_id,
3701 /* Resolve users on those channels that client has joined but we
3702 haven't resolved user list yet. */
3703 if (server->server_type == SILC_SERVER && !server->standalone) {
3704 silc_hash_table_list(client->channels, &htl);
3705 while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
3706 channel = chl->channel;
3707 SILC_LOG_DEBUG(("Resolving users for %s channel",
3708 channel->channel_name));
3709 if (channel->disabled || !channel->users_resolved) {
3710 silc_server_send_command(server, SILC_PRIMARY_ROUTE(server),
3711 SILC_COMMAND_USERS, ++server->cmd_ident,
3712 1, 2, channel->channel_name,
3713 strlen(channel->channel_name));
3716 silc_hash_table_list_reset(&htl);
3719 /* Send the new client ID to the client. After this client may start
3720 receiving other packets, and may start sending packets too. */
3721 silc_server_send_new_id(server, sock, FALSE, client_id, SILC_ID_CLIENT,
3722 silc_id_get_len(client_id, SILC_ID_CLIENT));
3725 /* Send NICK change notify to channels as well. */
3726 SilcBuffer oidp, nidp;
3727 oidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
3728 nidp = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
3729 silc_server_send_notify_on_channels(server, NULL, client,
3730 SILC_NOTIFY_TYPE_NICK_CHANGE, 3,
3731 oidp->data, oidp->len,
3732 nidp->data, nidp->len,
3734 strlen(client->nickname));
3735 silc_buffer_free(oidp);
3736 silc_buffer_free(nidp);
3739 /* Add the client again to the ID cache to get it to correct list */
3740 if (!silc_idcache_del_by_context(server->local_list->clients, client))
3741 silc_idcache_del_by_context(server->global_list->clients, client);
3742 silc_free(client->id);
3743 client->id = client_id;
3745 silc_idcache_add(server->local_list->clients, client->nickname,
3746 client->id, client, 0, NULL);
3748 /* Send some nice info to the client */
3749 silc_server_send_connect_notifys(server, sock, client);
3751 /* Send all channel keys of channels the client has joined */
3752 silc_hash_table_list(client->channels, &htl);
3753 while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
3754 bool created = FALSE;
3755 channel = chl->channel;
3757 if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY)
3760 /* If we don't have channel key, then create one */
3761 if (!channel->channel_key) {
3762 if (!silc_server_create_channel_key(server, channel, 0))
3767 id_string = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
3768 cipher = silc_cipher_get_name(channel->channel_key);
3770 silc_channel_key_payload_encode(silc_id_get_len(channel->id,
3773 strlen(cipher), cipher,
3774 channel->key_len / 8, channel->key);
3775 silc_free(id_string);
3777 /* Send the key packet to client */
3778 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
3779 keyp->data, keyp->len, FALSE);
3781 if (created && server->server_type == SILC_SERVER)
3782 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3783 SILC_PACKET_CHANNEL_KEY, 0,
3784 keyp->data, keyp->len, FALSE);
3786 silc_buffer_free(keyp);
3788 silc_hash_table_list_reset(&htl);
3790 } else if (sock->type != SILC_SOCKET_TYPE_CLIENT) {
3791 /* Server or router sent this to us to notify that that a client has
3793 SilcServerEntry server_entry;
3794 SilcServerID *server_id;
3797 SILC_LOG_DEBUG(("Malformed resuming packet"));
3801 /* Get entry to the client, and resolve it if we don't have it. */
3802 detached_client = silc_idlist_find_client_by_id(server->local_list,
3805 if (!detached_client) {
3806 detached_client = silc_idlist_find_client_by_id(server->global_list,
3809 if (!detached_client) {
3810 SILC_LOG_DEBUG(("Resuming client is unknown"));
3811 silc_free(client_id);
3816 /* Check that the client has not been resumed already because it is
3817 protocol error to attempt to resume more than once. The client
3818 will be killed if this protocol error occurs. */
3819 if (detached_client->data.status & SILC_IDLIST_STATUS_RESUMED &&
3820 !(detached_client->mode & SILC_UMODE_DETACHED)) {
3821 /* The client is clearly attempting to resume more than once and
3822 perhaps playing around by resuming from several different places
3823 at the same time. */
3824 SILC_LOG_DEBUG(("Attempting to re-resume client, killing both"));
3825 silc_server_kill_client(server, detached_client, NULL,
3826 server->id, SILC_ID_SERVER);
3827 silc_free(client_id);
3831 /* Check whether client is detached at all */
3832 if (!(detached_client->mode & SILC_UMODE_DETACHED)) {
3833 SILC_LOG_DEBUG(("Client is not detached"));
3834 silc_free(client_id);
3838 SILC_LOG_DEBUG(("Resuming detached client"));
3840 /* If the sender of this packet is server and we are router we need to
3841 broadcast this packet to other routers in the network. */
3842 if (server->server_type == SILC_ROUTER &&
3843 sock->type == SILC_SOCKET_TYPE_SERVER &&
3844 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
3845 SILC_LOG_DEBUG(("Broadcasting received Resume Client packet"));
3846 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3848 packet->flags | SILC_PACKET_FLAG_BROADCAST,
3849 buffer->data, buffer->len, FALSE);
3850 silc_server_backup_send(server, sock->user_data,
3851 packet->type, packet->flags,
3852 packet->buffer->data, packet->buffer->len,
3856 /* Client is detached, and now it is resumed. Remove the detached
3857 mode and mark that it is resumed. */
3858 detached_client->mode &= ~SILC_UMODE_DETACHED;
3859 detached_client->data.status |= SILC_IDLIST_STATUS_RESUMED;
3860 detached_client->data.status &= ~SILC_IDLIST_STATUS_LOCAL;
3861 id_cache->expire = 0;
3863 /* Update channel information regarding global clients on channel. */
3864 if (server->server_type == SILC_SERVER) {
3865 silc_hash_table_list(detached_client->channels, &htl);
3866 while (silc_hash_table_get(&htl, NULL, (void **)&chl))
3867 chl->channel->global_users =
3868 silc_server_channel_has_global(chl->channel);
3869 silc_hash_table_list_reset(&htl);
3872 silc_schedule_task_del_by_context(server->schedule, detached_client);
3874 /* Get the new owner of the resumed client */
3875 server_id = silc_id_str2id(packet->src_id, packet->src_id_len,
3876 packet->src_id_type);
3878 silc_free(client_id);
3882 /* Get server entry */
3883 server_entry = silc_idlist_find_server_by_id(server->global_list,
3884 server_id, TRUE, NULL);
3886 if (!server_entry) {
3887 server_entry = silc_idlist_find_server_by_id(server->local_list,
3888 server_id, TRUE, NULL);
3890 if (!server_entry) {
3891 silc_free(server_id);
3892 silc_free(client_id);
3897 if (server->server_type == SILC_ROUTER &&
3898 sock->type == SILC_SOCKET_TYPE_ROUTER &&
3899 server_entry->server_type == SILC_ROUTER)
3902 /* Change the client to correct list. */
3903 if (!silc_idcache_del_by_context(server->local_list->clients,
3905 silc_idcache_del_by_context(server->global_list->clients,
3907 silc_idcache_add(local && server->server_type == SILC_ROUTER ?
3908 server->local_list->clients :
3909 server->global_list->clients,
3910 detached_client->nickname,
3911 detached_client->id, detached_client, FALSE, NULL);
3913 /* Change the owner of the client */
3914 detached_client->router = server_entry;
3916 silc_free(server_id);
3919 silc_free(client_id);