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 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
138 channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
142 /* Get channel entry */
143 channel = silc_idlist_find_channel_by_id(server->global_list,
146 channel = silc_idlist_find_channel_by_id(server->local_list,
149 SILC_LOG_DEBUG(("Notify for unknown channel"));
150 silc_free(channel_id);
154 silc_free(channel_id);
157 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
160 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
164 /* If the the client is not in local list we check global list (ie. the
165 channel will be global channel) and if it does not exist then create
166 entry for the client. */
167 client = silc_idlist_find_client_by_id(server->global_list,
168 client_id, server->server_type,
171 client = silc_idlist_find_client_by_id(server->local_list,
172 client_id, server->server_type,
175 /* If router did not find the client the it is bogus */
176 if (server->server_type != SILC_SERVER) {
177 silc_free(client_id);
182 silc_idlist_add_client(server->global_list, NULL, NULL, NULL,
183 silc_id_dup(client_id, SILC_ID_CLIENT),
184 sock->user_data, NULL, 0);
186 SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
187 silc_free(client_id);
191 client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
194 silc_free(client_id);
196 /* Do not process the notify if the client is not registered */
197 if (!(client->data.status & SILC_IDLIST_STATUS_REGISTERED))
200 /* Do not add client to channel if it is there already */
201 if (silc_server_client_on_channel(client, channel, NULL)) {
202 SILC_LOG_DEBUG(("Client already on channel %s",
203 channel->channel_name));
207 /* Send to channel */
208 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
209 FALSE, packet->buffer->data,
210 packet->buffer->len, FALSE);
212 if (server->server_type != SILC_ROUTER &&
213 sock->type == SILC_SOCKET_TYPE_ROUTER)
214 /* The channel is global now */
215 channel->global_users = TRUE;
217 SILC_LOG_DEBUG(("Joining to channel %s", channel->channel_name));
219 /* JOIN the global client to the channel (local clients (if router
220 created the channel) is joined in the pending JOIN command). */
221 chl = silc_calloc(1, sizeof(*chl));
222 chl->client = client;
223 chl->channel = channel;
225 if (server->server_type != SILC_ROUTER ||
226 sock->type == SILC_SOCKET_TYPE_ROUTER) {
227 /* If this is the first one on the channel then it is the founder of
228 the channel. This is done on normal server and on router if this
229 notify is coming from router */
230 if (!silc_hash_table_count(channel->user_list)) {
231 SILC_LOG_DEBUG(("Client %s is founder on channel",
232 silc_id_render(chl->client->id, SILC_ID_CLIENT)));
233 chl->mode = (SILC_CHANNEL_UMODE_CHANOP | SILC_CHANNEL_UMODE_CHANFO);
237 silc_hash_table_add(channel->user_list, client, chl);
238 silc_hash_table_add(client->channels, channel, chl);
239 channel->user_count++;
240 channel->disabled = FALSE;
242 /* Make sure we don't expire clients that are on channel */
246 /* Update statistics */
247 if (server->server_type == SILC_ROUTER) {
248 if (sock->type != SILC_SOCKET_TYPE_ROUTER)
249 server->stat.cell_chanclients++;
250 server->stat.chanclients++;
255 case SILC_NOTIFY_TYPE_LEAVE:
257 * Distribute the notify to local clients on the channel
259 SILC_LOG_DEBUG(("LEAVE notify"));
262 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
263 packet->dst_id_type);
268 /* Get channel entry */
269 channel = silc_idlist_find_channel_by_id(server->global_list,
272 channel = silc_idlist_find_channel_by_id(server->local_list,
275 SILC_LOG_DEBUG(("Notify for unknown channel"));
276 silc_free(channel_id);
282 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
284 silc_free(channel_id);
287 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
289 silc_free(channel_id);
293 /* Get client entry */
294 client = silc_idlist_find_client_by_id(server->global_list,
295 client_id, TRUE, NULL);
297 client = silc_idlist_find_client_by_id(server->local_list,
298 client_id, TRUE, NULL);
300 silc_free(client_id);
301 silc_free(channel_id);
305 silc_free(client_id);
307 /* Check if on channel */
308 if (!silc_server_client_on_channel(client, channel, NULL))
311 /* Send the leave notify to channel */
312 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
313 FALSE, packet->buffer->data,
314 packet->buffer->len, FALSE);
316 /* Remove the user from channel */
317 silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
320 case SILC_NOTIFY_TYPE_SIGNOFF:
322 * Distribute the notify to local clients on the channel
324 SILC_LOG_DEBUG(("SIGNOFF notify"));
327 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
330 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
334 /* Get client entry */
335 client = silc_idlist_find_client_by_id(server->global_list,
336 client_id, TRUE, &cache);
338 client = silc_idlist_find_client_by_id(server->local_list,
339 client_id, TRUE, &cache);
341 silc_free(client_id);
345 silc_free(client_id);
347 /* Get signoff message */
348 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
352 /* Update statistics */
353 server->stat.clients--;
354 if (server->stat.cell_clients)
355 server->stat.cell_clients--;
356 SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
357 SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
358 silc_schedule_task_del_by_context(server->schedule, client);
360 /* Remove the client from all channels. */
361 silc_server_remove_from_channels(server, NULL, client, TRUE, tmp, FALSE);
363 /* Check if anyone is watching this nickname */
364 if (server->server_type == SILC_ROUTER)
365 silc_server_check_watcher_list(server, client, NULL,
366 SILC_NOTIFY_TYPE_SIGNOFF);
368 /* Remove this client from watcher list if it is */
369 silc_server_del_from_watcher_list(server, client);
371 client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
372 cache->expire = SILC_ID_CACHE_EXPIRE_DEF;
375 case SILC_NOTIFY_TYPE_TOPIC_SET:
377 * Distribute the notify to local clients on the channel
380 SILC_LOG_DEBUG(("TOPIC SET notify"));
383 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
386 client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
390 /* Get client entry */
391 if (id_type == SILC_ID_CLIENT) {
392 client = silc_idlist_find_client_by_id(server->global_list,
393 client_id, TRUE, &cache);
395 client = silc_idlist_find_client_by_id(server->local_list,
396 client_id, TRUE, &cache);
398 silc_free(client_id);
402 silc_free(client_id);
406 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
408 silc_free(channel_id);
413 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
414 packet->dst_id_type);
419 /* Get channel entry */
420 channel = silc_idlist_find_channel_by_id(server->global_list,
423 channel = silc_idlist_find_channel_by_id(server->local_list,
426 SILC_LOG_DEBUG(("Notify for unknown channel"));
427 silc_free(channel_id);
431 silc_free(channel_id);
433 if (channel->topic && !strcmp(channel->topic, tmp)) {
434 SILC_LOG_DEBUG(("Topic is already set and same"));
439 /* Get user's channel entry and check that topic set is allowed. */
440 if (!silc_server_client_on_channel(client, channel, &chl))
442 if (channel->mode & SILC_CHANNEL_MODE_TOPIC &&
443 !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
444 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
445 SILC_LOG_DEBUG(("Topic change is not allowed"));
450 /* Change the topic */
451 silc_free(channel->topic);
452 channel->topic = strdup(tmp);
454 /* Send the same notify to the channel */
455 silc_server_packet_send_to_channel(server, NULL, channel, packet->type,
456 FALSE, packet->buffer->data,
457 packet->buffer->len, FALSE);
460 case SILC_NOTIFY_TYPE_NICK_CHANGE:
463 * Distribute the notify to local clients on the channel
465 unsigned char *id, *id2;
467 SilcUInt32 nickname_len;
469 SILC_LOG_DEBUG(("NICK CHANGE notify"));
471 /* Get old client ID */
472 id = silc_argument_get_arg_type(args, 1, &tmp_len);
475 client_id = silc_id_payload_parse_id(id, tmp_len, NULL);
479 /* Get new client ID */
480 id2 = silc_argument_get_arg_type(args, 2, &tmp_len);
483 client_id2 = silc_id_payload_parse_id(id2, tmp_len, NULL);
485 silc_free(client_id);
489 SILC_LOG_DEBUG(("Old Client ID id(%s)",
490 silc_id_render(client_id, SILC_ID_CLIENT)));
491 SILC_LOG_DEBUG(("New Client ID id(%s)",
492 silc_id_render(client_id2, SILC_ID_CLIENT)));
494 /* From protocol version 1.1 we also get the new nickname */
495 nickname = silc_argument_get_arg_type(args, 3, &nickname_len);;
497 /* Replace the Client ID */
498 client = silc_idlist_replace_client_id(server,
499 server->global_list, client_id,
500 client_id2, nickname);
502 client = silc_idlist_replace_client_id(server,
503 server->local_list, client_id,
504 client_id2, nickname);
507 /* Send the NICK_CHANGE notify type to local clients on the channels
508 this client is joined to. */
509 silc_server_send_notify_on_channels(server, client, client,
510 SILC_NOTIFY_TYPE_NICK_CHANGE, 3,
511 id, tmp_len, id2, tmp_len,
516 silc_free(client_id);
518 silc_free(client_id2);
522 case SILC_NOTIFY_TYPE_CMODE_CHANGE:
524 * Distribute the notify to local clients on the channel
527 SILC_LOG_DEBUG(("CMODE CHANGE notify"));
530 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
533 client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
537 /* Get client entry */
538 if (id_type == SILC_ID_CLIENT) {
539 client = silc_idlist_find_client_by_id(server->global_list,
540 client_id, TRUE, &cache);
542 client = silc_idlist_find_client_by_id(server->local_list,
543 client_id, TRUE, &cache);
545 silc_free(client_id);
549 silc_free(client_id);
553 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
554 packet->dst_id_type);
559 /* Get channel entry */
560 channel = silc_idlist_find_channel_by_id(server->global_list,
563 channel = silc_idlist_find_channel_by_id(server->local_list,
566 SILC_LOG_DEBUG(("Notify for unknown channel"));
567 silc_free(channel_id);
571 silc_free(channel_id);
574 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
577 SILC_GET32_MSB(mode, tmp);
579 /* Check if mode changed */
580 if (channel->mode == mode) {
581 SILC_LOG_DEBUG(("Mode is changed already"));
583 /* If this mode change has founder mode then we'll enforce the
584 change so that the server gets the real founder public key */
585 if (server->server_type != SILC_SERVER &&
586 sock != SILC_PRIMARY_ROUTE(server) &&
587 mode & SILC_CHANNEL_MODE_FOUNDER_AUTH && channel->founder_key) {
588 SILC_LOG_DEBUG(("Sending founder public key to server"));
589 silc_server_send_notify_cmode(server, sock, FALSE, channel,
590 channel->mode, server->id,
591 SILC_ID_SERVER, channel->cipher,
594 channel->founder_key);
597 /* If we received same mode from our primary check whether founder
598 mode and key in the notify is set. We update the founder key
599 here since we may have wrong one */
600 if (server->server_type == SILC_SERVER &&
601 sock == SILC_PRIMARY_ROUTE(server) &&
602 mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
603 SILC_LOG_DEBUG(("Founder public key received from router"));
604 tmp = silc_argument_get_arg_type(args, 6, &tmp_len);
608 if (channel->founder_key)
609 silc_pkcs_public_key_free(channel->founder_key);
610 channel->founder_key = NULL;
611 silc_pkcs_public_key_decode(tmp, tmp_len, &channel->founder_key);
617 /* Get user's channel entry and check that mode change is allowed */
619 if (!silc_server_client_on_channel(client, channel, &chl))
621 if (!silc_server_check_cmode_rights(server, channel, chl, mode)) {
622 SILC_LOG_DEBUG(("CMODE change is not allowed"));
623 silc_server_send_notify_cmode(server, sock, FALSE, channel,
624 channel->mode, server->id,
625 SILC_ID_SERVER, channel->cipher,
628 channel->founder_key);
632 /* Assure that server is not removing founder mode from us */
633 if (server->server_type == SILC_ROUTER &&
634 sock != SILC_PRIMARY_ROUTE(server) &&
635 channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH &&
636 !(mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
637 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
638 silc_server_send_notify_cmode(server, sock, FALSE, channel,
639 channel->mode, server->id,
640 SILC_ID_SERVER, channel->cipher,
643 channel->founder_key);
647 /* If server is adding founder mode, check whether there is founder
648 on channel already and is not from this server */
649 if (server->server_type == SILC_ROUTER &&
650 sock != SILC_PRIMARY_ROUTE(server) &&
651 mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
652 silc_hash_table_list(channel->user_list, &htl);
653 while (silc_hash_table_get(&htl, NULL, (void *)&chl))
654 if (chl->mode & SILC_CHANNEL_UMODE_CHANFO &&
655 chl->client->router != sock->user_data) {
656 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
657 silc_server_send_notify_cmode(server, sock, FALSE, channel,
658 channel->mode, server->id,
659 SILC_ID_SERVER, channel->cipher,
662 channel->founder_key);
663 silc_hash_table_list_reset(&htl);
666 silc_hash_table_list_reset(&htl);
670 /* If the channel had private keys set and the mode was removed then
671 we must re-generate and re-distribute a new channel key */
672 if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY &&
673 !(mode & SILC_CHANNEL_MODE_PRIVKEY)) {
674 /* Re-generate channel key */
675 if (!silc_server_create_channel_key(server, channel, 0))
678 /* Send the channel key. This sends it to our local clients and if
679 we are normal server to our router as well. */
680 silc_server_send_channel_key(server, NULL, channel,
681 server->server_type == SILC_ROUTER ?
682 FALSE : !server->standalone);
686 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
688 unsigned char hash[32];
691 silc_hmac_free(channel->hmac);
692 if (!silc_hmac_alloc(tmp, NULL, &channel->hmac))
695 /* Set the HMAC key out of current channel key. The client must do
697 silc_hash_make(silc_hmac_get_hash(channel->hmac), channel->key,
698 channel->key_len / 8, hash);
699 silc_hmac_set_key(channel->hmac, hash,
700 silc_hash_len(silc_hmac_get_hash(channel->hmac)));
701 memset(hash, 0, sizeof(hash));
704 /* Get the passphrase */
705 tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
707 silc_free(channel->passphrase);
708 channel->passphrase = silc_memdup(tmp, tmp_len);
711 /* Get founder public key */
712 tmp = silc_argument_get_arg_type(args, 6, &tmp_len);
713 if (tmp && mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
714 if (channel->founder_key)
715 silc_pkcs_public_key_free(channel->founder_key);
716 channel->founder_key = NULL;
717 silc_pkcs_public_key_decode(tmp, tmp_len, &channel->founder_key);
719 if (!channel->founder_key ||
720 (client && client->data.public_key &&
721 server->server_type == SILC_ROUTER &&
722 !silc_pkcs_public_key_compare(channel->founder_key,
723 client->data.public_key))) {
724 /* A really buggy server isn't checking public keys correctly.
725 It's not possible that the mode setter and founder wouldn't
726 have same public key. */
727 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
729 mode &= ~SILC_CHANNEL_MODE_FOUNDER_AUTH;
730 silc_server_send_notify_cmode(server, sock, FALSE, channel,
731 mode, server->id, SILC_ID_SERVER,
734 channel->passphrase, NULL);
735 if (channel->founder_key)
736 silc_pkcs_public_key_free(channel->founder_key);
737 channel->founder_key = NULL;
738 } else if (client && !client->data.public_key) {
739 client->data.public_key =
740 silc_pkcs_public_key_copy(channel->founder_key);
744 if (mode & SILC_CHANNEL_MODE_FOUNDER_AUTH && !channel->founder_key &&
745 server->server_type == SILC_ROUTER) {
746 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
747 mode &= ~SILC_CHANNEL_MODE_FOUNDER_AUTH;
748 silc_server_send_notify_cmode(server, sock, FALSE, channel,
749 mode, server->id, SILC_ID_SERVER,
752 channel->passphrase, NULL);
755 /* Send the same notify to the channel */
756 silc_server_packet_send_to_channel(server, NULL, channel, packet->type,
757 FALSE, packet->buffer->data,
758 packet->buffer->len, FALSE);
761 channel->mode = mode;
763 if (!(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) &&
764 channel->founder_key) {
765 silc_pkcs_public_key_free(channel->founder_key);
766 channel->founder_key = NULL;
771 case SILC_NOTIFY_TYPE_CUMODE_CHANGE:
774 * Distribute the notify to local clients on the channel
776 SilcChannelClientEntry chl2 = NULL;
777 bool notify_sent = FALSE;
779 SILC_LOG_DEBUG(("CUMODE CHANGE notify"));
782 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
785 client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
789 /* Get client entry */
790 if (id_type == SILC_ID_CLIENT) {
791 client = silc_idlist_find_client_by_id(server->global_list,
792 client_id, TRUE, &cache);
794 client = silc_idlist_find_client_by_id(server->local_list,
795 client_id, TRUE, &cache);
797 silc_free(client_id);
801 silc_free(client_id);
805 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
806 packet->dst_id_type);
811 /* Get channel entry */
812 channel = silc_idlist_find_channel_by_id(server->global_list,
815 channel = silc_idlist_find_channel_by_id(server->local_list,
818 SILC_LOG_DEBUG(("Notify for unknown channel"));
819 silc_free(channel_id);
825 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
827 silc_free(channel_id);
831 SILC_GET32_MSB(mode, tmp);
833 /* Get target client */
834 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
837 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
841 /* Get client entry */
842 client2 = silc_idlist_find_client_by_id(server->global_list,
843 client_id, TRUE, NULL);
845 client2 = silc_idlist_find_client_by_id(server->local_list,
846 client_id, TRUE, NULL);
848 silc_free(client_id);
852 silc_free(client_id);
855 /* Check that sender is on channel */
856 if (!silc_server_client_on_channel(client, channel, &chl))
859 if (client != client2 && server->server_type == SILC_ROUTER) {
860 /* Sender must be operator */
861 if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
862 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
863 SILC_LOG_DEBUG(("CUMODE change is not allowed"));
867 if (!silc_server_client_on_channel(client2, channel, &chl))
870 /* If target is founder mode change is not allowed. */
871 if (chl->mode & SILC_CHANNEL_UMODE_CHANFO) {
872 SILC_LOG_DEBUG(("CUMODE change is not allowed"));
878 /* Get target channel user entry */
879 if (!silc_server_client_on_channel(client2, channel, &chl))
882 if (server->server_type == SILC_SERVER && chl->mode == mode) {
883 SILC_LOG_DEBUG(("Mode is changed already"));
887 if (mode & SILC_CHANNEL_UMODE_CHANFO &&
888 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO) &&
889 server->server_type == SILC_ROUTER &&
890 sock != SILC_PRIMARY_ROUTE(server)) {
891 SilcPublicKey founder_key = NULL;
893 /* If channel doesn't have founder auth mode then it's impossible
894 that someone would be getting founder rights with CUMODE command.
895 In that case there already either is founder or there isn't
896 founder at all on the channel. */
897 if (client && !(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
898 /* Force the mode to not have founder mode */
899 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
900 silc_server_force_cumode_change(server, sock, channel, chl, mode);
905 /* Get the founder of the channel and if found then this client
906 cannot be the founder since there already is one. */
907 silc_hash_table_list(channel->user_list, &htl);
908 while (silc_hash_table_get(&htl, NULL, (void *)&chl2))
909 if (chl2->mode & SILC_CHANNEL_UMODE_CHANFO) {
910 /* If the founder on the channel is not the one whom has set
911 the founder mode, then it's possible that this CUMODE_CHANGE
912 is correct. Due to netsplits it's possible that this
913 situation happens. */
914 if (!(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) ||
915 (channel->founder_key && chl2->client->data.public_key &&
916 silc_pkcs_public_key_compare(
917 channel->founder_key,
918 chl2->client->data.public_key))) {
919 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
920 silc_server_force_cumode_change(server, sock, channel,
926 silc_hash_table_list_reset(&htl);
927 if (!(mode & SILC_CHANNEL_UMODE_CHANFO))
930 /* Founder not found of the channel. Since the founder auth mode
931 is set on the channel now check whether this is the client that
932 originally set the mode. */
934 if (channel->founder_key) {
935 /* Get public key that must be present in notify */
936 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
937 if (!tmp || !silc_pkcs_public_key_decode(tmp, tmp_len,
939 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
940 silc_server_force_cumode_change(server, sock, channel, chl, mode);
945 /* Now match the public key we have cached and public key sent.
947 if (client && client->data.public_key &&
948 !silc_pkcs_public_key_compare(channel->founder_key,
949 client->data.public_key)) {
950 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
951 silc_server_force_cumode_change(server, sock, channel, chl, mode);
955 if (!silc_pkcs_public_key_compare(channel->founder_key,
957 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
958 silc_server_force_cumode_change(server, sock, channel, chl, mode);
964 /* There cannot be anyone else as founder on the channel now. This
965 client is definitely the founder due to this authentication */
966 silc_hash_table_list(channel->user_list, &htl);
967 while (silc_hash_table_get(&htl, NULL, (void *)&chl2))
968 if (chl2->mode & SILC_CHANNEL_UMODE_CHANFO) {
969 chl2->mode &= ~SILC_CHANNEL_UMODE_CHANFO;
970 silc_server_force_cumode_change(server, NULL, channel, chl2,
974 silc_hash_table_list_reset(&htl);
977 silc_pkcs_public_key_free(founder_key);
980 if (server->server_type != SILC_SERVER && chl->mode == mode) {
981 SILC_LOG_DEBUG(("Mode is changed already"));
985 SILC_LOG_DEBUG(("Changing %s channel user mode",
986 chl->client->nickname ? chl->client->nickname :
987 (unsigned char *)""));
989 /* Change the mode */
992 /* Send the same notify to the channel */
994 silc_server_packet_send_to_channel(server, NULL, channel,
996 FALSE, packet->buffer->data,
997 packet->buffer->len, FALSE);
999 silc_free(channel_id);
1003 case SILC_NOTIFY_TYPE_INVITE:
1005 if (packet->dst_id_type == SILC_ID_CLIENT)
1008 SILC_LOG_DEBUG(("INVITE notify"));
1010 /* Get Channel ID */
1011 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1014 channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1018 /* Get channel entry */
1019 channel = silc_idlist_find_channel_by_id(server->global_list,
1022 channel = silc_idlist_find_channel_by_id(server->local_list,
1025 SILC_LOG_DEBUG(("Notify for unknown channel"));
1026 silc_free(channel_id);
1030 silc_free(channel_id);
1033 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1036 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1040 /* Get client entry */
1041 client = silc_idlist_find_client_by_id(server->global_list,
1042 client_id, TRUE, &cache);
1044 client = silc_idlist_find_client_by_id(server->local_list,
1045 client_id, TRUE, &cache);
1047 silc_free(client_id);
1051 silc_free(client_id);
1053 /* Get user's channel entry and check that inviting is allowed. */
1054 if (!silc_server_client_on_channel(client, channel, &chl))
1056 if (channel->mode & SILC_CHANNEL_MODE_INVITE &&
1057 !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
1058 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
1059 SILC_LOG_DEBUG(("Inviting is not allowed"));
1063 /* Get the added invite */
1064 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
1066 if (!channel->invite_list)
1067 channel->invite_list = silc_calloc(tmp_len + 2,
1068 sizeof(*channel->invite_list));
1070 channel->invite_list = silc_realloc(channel->invite_list,
1071 sizeof(*channel->invite_list) *
1073 strlen(channel->invite_list) +
1075 if (tmp[tmp_len - 1] == ',')
1076 tmp[tmp_len - 1] = '\0';
1078 strncat(channel->invite_list, tmp, tmp_len);
1079 strncat(channel->invite_list, ",", 1);
1082 /* Get the deleted invite */
1083 tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
1084 if (tmp && channel->invite_list) {
1085 char *start, *end, *n;
1087 if (!strncmp(channel->invite_list, tmp,
1088 strlen(channel->invite_list) - 1)) {
1089 silc_free(channel->invite_list);
1090 channel->invite_list = NULL;
1092 start = strstr(channel->invite_list, tmp);
1093 if (start && strlen(start) >= tmp_len) {
1094 end = start + tmp_len;
1095 n = silc_calloc(strlen(channel->invite_list) - tmp_len, sizeof(*n));
1096 strncat(n, channel->invite_list, start - channel->invite_list);
1097 strncat(n, end + 1, ((channel->invite_list +
1098 strlen(channel->invite_list)) - end) - 1);
1099 silc_free(channel->invite_list);
1100 channel->invite_list = n;
1107 case SILC_NOTIFY_TYPE_CHANNEL_CHANGE:
1109 * Distribute to the local clients on the channel and change the
1113 SILC_LOG_DEBUG(("CHANNEL CHANGE"));
1115 if (sock->type != SILC_SOCKET_TYPE_ROUTER)
1118 /* Get the old Channel ID */
1119 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1122 channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1126 /* Get the channel entry */
1127 channel = silc_idlist_find_channel_by_id(server->local_list,
1130 channel = silc_idlist_find_channel_by_id(server->global_list,
1133 SILC_LOG_DEBUG(("Notify for unknown channel"));
1134 silc_free(channel_id);
1139 /* Send the notify to the channel */
1140 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
1141 FALSE, packet->buffer->data,
1142 packet->buffer->len, FALSE);
1144 /* Get the new Channel ID */
1145 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1148 channel_id2 = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1152 SILC_LOG_DEBUG(("Old Channel ID id(%s)",
1153 silc_id_render(channel_id, SILC_ID_CHANNEL)));
1154 SILC_LOG_DEBUG(("New Channel ID id(%s)",
1155 silc_id_render(channel_id2, SILC_ID_CHANNEL)));
1157 /* Replace the Channel ID */
1158 if (!silc_idlist_replace_channel_id(server->local_list, channel_id,
1160 if (!silc_idlist_replace_channel_id(server->global_list, channel_id,
1162 silc_free(channel_id2);
1167 SilcBuffer modes = NULL, users = NULL, users_modes = NULL;
1169 /* Re-announce this channel which ID was changed. */
1170 silc_server_send_new_channel(server, sock, FALSE, channel->channel_name,
1172 silc_id_get_len(channel->id,
1176 /* Re-announce our clients on the channel as the ID has changed now */
1177 silc_server_announce_get_channel_users(server, channel, &modes, &users,
1180 silc_buffer_push(users, users->data - users->head);
1181 silc_server_packet_send(server, sock,
1182 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1183 users->data, users->len, FALSE);
1184 silc_buffer_free(users);
1187 silc_buffer_push(modes, modes->data - modes->head);
1188 silc_server_packet_send_dest(server, sock,
1189 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1190 channel->id, SILC_ID_CHANNEL,
1191 modes->data, modes->len, FALSE);
1192 silc_buffer_free(modes);
1195 silc_buffer_push(users_modes, users_modes->data - users_modes->head);
1196 silc_server_packet_send_dest(server, sock,
1197 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1198 channel->id, SILC_ID_CHANNEL,
1200 users_modes->len, FALSE);
1201 silc_buffer_free(users_modes);
1204 /* Re-announce channel's topic */
1205 if (channel->topic) {
1206 silc_server_send_notify_topic_set(server, sock,
1207 server->server_type == SILC_ROUTER ?
1208 TRUE : FALSE, channel,
1209 server->id, SILC_ID_SERVER,
1214 silc_free(channel_id);
1218 case SILC_NOTIFY_TYPE_SERVER_SIGNOFF:
1220 * Remove the server entry and all clients that this server owns.
1223 SILC_LOG_DEBUG(("SERVER SIGNOFF notify"));
1226 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1229 server_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1233 /* Get server entry */
1234 server_entry = silc_idlist_find_server_by_id(server->global_list,
1235 server_id, TRUE, NULL);
1237 if (!server_entry) {
1238 server_entry = silc_idlist_find_server_by_id(server->local_list,
1239 server_id, TRUE, NULL);
1241 if (!server_entry) {
1242 /* If we are normal server then we might not have the server. Check
1243 whether router was kind enough to send the list of all clients
1244 that actually was to be removed. Remove them if the list is
1246 if (server->server_type != SILC_ROUTER &&
1247 silc_argument_get_arg_num(args) > 1) {
1250 for (i = 1; i < silc_argument_get_arg_num(args); i++) {
1252 tmp = silc_argument_get_arg_type(args, i + 1, &tmp_len);
1255 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1259 /* Get client entry */
1260 client = silc_idlist_find_client_by_id(server->global_list,
1261 client_id, TRUE, &cache);
1264 client = silc_idlist_find_client_by_id(server->local_list,
1265 client_id, TRUE, &cache);
1268 silc_free(client_id);
1272 silc_free(client_id);
1274 /* Update statistics */
1275 server->stat.clients--;
1276 if (server->stat.cell_clients)
1277 server->stat.cell_clients--;
1278 SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
1279 SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
1281 /* Remove the client from all channels. */
1282 silc_server_remove_from_channels(server, NULL, client,
1285 /* Check if anyone is watching this nickname */
1286 if (server->server_type == SILC_ROUTER)
1287 silc_server_check_watcher_list(server, client, NULL,
1288 SILC_NOTIFY_TYPE_SERVER_SIGNOFF);
1290 /* Remove this client from watcher list if it is */
1292 silc_server_del_from_watcher_list(server, client);
1294 /* Remove the client */
1295 silc_idlist_del_data(client);
1296 silc_idlist_del_client(local ? server->local_list :
1297 server->global_list, client);
1301 silc_free(server_id);
1305 silc_free(server_id);
1307 /* Sending SERVER_SIGNOFF is not right way to signoff local connection */
1308 if (SILC_IS_LOCAL(server_entry))
1311 /* Remove all servers that are originated from this server, and
1312 remove the clients of those servers too. */
1313 silc_server_remove_servers_by_server(server, server_entry, TRUE);
1315 /* Remove the clients that this server owns as they will become
1317 silc_server_remove_clients_by_server(server, server_entry->router,
1318 server_entry, TRUE);
1319 silc_server_backup_del(server, server_entry);
1321 /* Remove the server entry */
1322 silc_idlist_del_server(local ? server->local_list :
1323 server->global_list, server_entry);
1325 /* Update statistics */
1326 if (server->server_type == SILC_ROUTER)
1327 server->stat.servers--;
1331 case SILC_NOTIFY_TYPE_KICKED:
1333 * Distribute the notify to local clients on the channel
1336 SILC_LOG_DEBUG(("KICKED notify"));
1339 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
1340 packet->dst_id_type);
1345 /* Get channel entry */
1346 channel = silc_idlist_find_channel_by_id(server->global_list,
1349 channel = silc_idlist_find_channel_by_id(server->local_list,
1352 SILC_LOG_DEBUG(("Notify for unknown channel"));
1353 silc_free(channel_id);
1357 silc_free(channel_id);
1360 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1363 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1367 /* If the the client is not in local list we check global list */
1368 client = silc_idlist_find_client_by_id(server->global_list,
1369 client_id, TRUE, NULL);
1371 client = silc_idlist_find_client_by_id(server->local_list,
1372 client_id, TRUE, NULL);
1374 silc_free(client_id);
1378 silc_free(client_id);
1380 /* If target is founder they cannot be kicked */
1381 if (!silc_server_client_on_channel(client, channel, &chl))
1383 if (chl->mode & SILC_CHANNEL_UMODE_CHANFO)
1386 /* From protocol version 1.1 we get the kicker's ID as well. */
1387 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1389 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1393 /* If the the client is not in local list we check global list */
1394 client2 = silc_idlist_find_client_by_id(server->global_list,
1395 client_id, TRUE, NULL);
1397 client2 = silc_idlist_find_client_by_id(server->local_list,
1398 client_id, TRUE, NULL);
1400 silc_free(client_id);
1404 silc_free(client_id);
1406 /* Kicker must be operator on channel */
1407 if (!silc_server_client_on_channel(client2, channel, &chl))
1409 if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
1410 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
1411 SILC_LOG_DEBUG(("Kicking is not allowed"));
1416 /* Send to channel */
1417 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
1418 FALSE, packet->buffer->data,
1419 packet->buffer->len, FALSE);
1421 /* Remove the client from channel */
1422 silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
1426 case SILC_NOTIFY_TYPE_KILLED:
1429 * Distribute the notify to local clients on channels
1431 unsigned char *id, *comment;
1432 SilcUInt32 id_len, comment_len;
1434 SILC_LOG_DEBUG(("KILLED notify"));
1437 id = silc_argument_get_arg_type(args, 1, &id_len);
1440 client_id = silc_id_payload_parse_id(id, id_len, NULL);
1444 /* If the the client is not in local list we check global list */
1445 client = silc_idlist_find_client_by_id(server->global_list,
1446 client_id, TRUE, &cache);
1448 client = silc_idlist_find_client_by_id(server->local_list,
1449 client_id, TRUE, &cache);
1451 silc_free(client_id);
1455 silc_free(client_id);
1457 /* If the client is one of ours, then close the connection to the
1458 client now. This removes the client from all channels as well. */
1459 if (packet->dst_id_type == SILC_ID_CLIENT && client->connection) {
1460 sock = client->connection;
1461 silc_server_free_client_data(server, NULL, client, FALSE, NULL);
1462 silc_server_close_connection(server, sock);
1467 comment = silc_argument_get_arg_type(args, 2, &comment_len);
1468 if (comment_len > 128)
1471 /* From protocol version 1.1 we get the killer's ID as well. */
1472 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1474 client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
1478 if (id_type == SILC_ID_CLIENT) {
1479 /* If the the client is not in local list we check global list */
1480 client2 = silc_idlist_find_client_by_id(server->global_list,
1481 client_id, TRUE, NULL);
1483 client2 = silc_idlist_find_client_by_id(server->local_list,
1484 client_id, TRUE, NULL);
1486 silc_free(client_id);
1490 silc_free(client_id);
1492 /* Killer must be router operator */
1493 if (server->server_type != SILC_SERVER &&
1494 !(client2->mode & SILC_UMODE_ROUTER_OPERATOR)) {
1495 SILC_LOG_DEBUG(("Killing is not allowed"));
1501 /* Send the notify to local clients on the channels except to the
1502 client who is killed. */
1503 silc_server_send_notify_on_channels(server, client, client,
1504 SILC_NOTIFY_TYPE_KILLED, 3,
1505 id, id_len, comment, comment_len,
1508 /* Remove the client from all channels */
1509 silc_server_remove_from_channels(server, NULL, client, FALSE, NULL,
1512 /* Check if anyone is watching this nickname */
1513 silc_server_check_watcher_list(server, client, NULL,
1514 SILC_NOTIFY_TYPE_KILLED);
1516 /* Update statistics */
1517 server->stat.clients--;
1518 if (server->stat.cell_clients)
1519 server->stat.cell_clients--;
1520 SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
1521 SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
1523 if (SILC_IS_LOCAL(client)) {
1524 server->stat.my_clients--;
1525 silc_schedule_task_del_by_context(server->schedule, client);
1526 silc_idlist_del_data(client);
1530 client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
1531 cache->expire = SILC_ID_CACHE_EXPIRE_DEF;
1535 case SILC_NOTIFY_TYPE_UMODE_CHANGE:
1537 * Save the mode of the client.
1540 SILC_LOG_DEBUG(("UMODE_CHANGE notify"));
1543 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1546 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1550 /* Get client entry */
1551 client = silc_idlist_find_client_by_id(server->global_list,
1552 client_id, TRUE, NULL);
1554 client = silc_idlist_find_client_by_id(server->local_list,
1555 client_id, TRUE, NULL);
1557 silc_free(client_id);
1561 silc_free(client_id);
1564 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1567 SILC_GET32_MSB(mode, tmp);
1569 /* Remove internal resumed flag if client is marked detached now */
1570 if (mode & SILC_UMODE_DETACHED)
1571 client->data.status &= ~SILC_IDLIST_STATUS_RESUMED;
1573 /* Update statistics */
1574 if (server->server_type == SILC_ROUTER) {
1575 if (mode & SILC_UMODE_GONE) {
1576 if (!(client->mode & SILC_UMODE_GONE))
1577 server->stat.aways++;
1579 if (client->mode & SILC_UMODE_GONE)
1580 server->stat.aways--;
1582 if (mode & SILC_UMODE_DETACHED) {
1583 if (!(client->mode & SILC_UMODE_DETACHED))
1584 server->stat.detached++;
1586 if (client->mode & SILC_UMODE_DETACHED)
1587 server->stat.detached--;
1590 SILC_UMODE_STATS_UPDATE(server, SILC_UMODE_SERVER_OPERATOR);
1591 SILC_UMODE_STATS_UPDATE(router, SILC_UMODE_ROUTER_OPERATOR);
1593 /* Change the mode */
1594 client->mode = mode;
1596 /* Check if anyone is watching this nickname */
1597 if (server->server_type == SILC_ROUTER)
1598 silc_server_check_watcher_list(server, client, NULL,
1599 SILC_NOTIFY_TYPE_UMODE_CHANGE);
1603 case SILC_NOTIFY_TYPE_BAN:
1608 SILC_LOG_DEBUG(("BAN notify"));
1610 /* Get Channel ID */
1611 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1614 channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1618 /* Get channel entry */
1619 channel = silc_idlist_find_channel_by_id(server->global_list,
1622 channel = silc_idlist_find_channel_by_id(server->local_list,
1625 SILC_LOG_DEBUG(("Notify for unknown channel"));
1626 silc_free(channel_id);
1630 silc_free(channel_id);
1632 /* Get the new ban and add it to the ban list */
1633 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1635 if (!channel->ban_list)
1636 channel->ban_list = silc_calloc(tmp_len + 2,
1637 sizeof(*channel->ban_list));
1639 channel->ban_list = silc_realloc(channel->ban_list,
1640 sizeof(*channel->ban_list) *
1642 strlen(channel->ban_list) + 2));
1643 strncat(channel->ban_list, tmp, tmp_len);
1644 strncat(channel->ban_list, ",", 1);
1647 /* Get the ban to be removed and remove it from the list */
1648 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1649 if (tmp && channel->ban_list) {
1650 char *start, *end, *n;
1652 if (!strncmp(channel->ban_list, tmp, strlen(channel->ban_list) - 1)) {
1653 silc_free(channel->ban_list);
1654 channel->ban_list = NULL;
1656 start = strstr(channel->ban_list, tmp);
1657 if (start && strlen(start) >= tmp_len) {
1658 end = start + tmp_len;
1659 n = silc_calloc(strlen(channel->ban_list) - tmp_len, sizeof(*n));
1660 strncat(n, channel->ban_list, start - channel->ban_list);
1661 strncat(n, end + 1, ((channel->ban_list +
1662 strlen(channel->ban_list)) - end) - 1);
1663 silc_free(channel->ban_list);
1664 channel->ban_list = n;
1670 case SILC_NOTIFY_TYPE_ERROR:
1677 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1678 if (!tmp && tmp_len != 1)
1680 error = (SilcStatus)tmp[0];
1682 SILC_LOG_DEBUG(("ERROR notify (%d)", error));
1684 if (error == SILC_STATUS_ERR_NO_SUCH_CLIENT_ID &&
1685 sock->type == SILC_SOCKET_TYPE_ROUTER) {
1686 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1688 SILC_LOG_DEBUG(("Received invalid client ID notification, deleting "
1689 "the entry from cache"));
1690 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1693 client = silc_idlist_find_client_by_id(server->global_list,
1694 client_id, FALSE, NULL);
1696 silc_server_remove_from_channels(server, NULL, client, TRUE,
1698 silc_idlist_del_data(client);
1699 silc_idlist_del_client(server->global_list, client);
1701 silc_free(client_id);
1707 /* Ignore rest of the notify types for now */
1708 case SILC_NOTIFY_TYPE_NONE:
1709 case SILC_NOTIFY_TYPE_MOTD:
1716 silc_notify_payload_free(payload);
1719 void silc_server_notify_list(SilcServer server,
1720 SilcSocketConnection sock,
1721 SilcPacketContext *packet)
1723 SilcPacketContext *new;
1727 SILC_LOG_DEBUG(("Processing Notify List"));
1729 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
1730 packet->src_id_type != SILC_ID_SERVER)
1733 /* Make copy of the original packet context, except for the actual
1734 data buffer, which we will here now fetch from the original buffer. */
1735 new = silc_packet_context_alloc();
1736 new->type = SILC_PACKET_NOTIFY;
1737 new->flags = packet->flags;
1738 new->src_id = packet->src_id;
1739 new->src_id_len = packet->src_id_len;
1740 new->src_id_type = packet->src_id_type;
1741 new->dst_id = packet->dst_id;
1742 new->dst_id_len = packet->dst_id_len;
1743 new->dst_id_type = packet->dst_id_type;
1745 buffer = silc_buffer_alloc(1024);
1746 new->buffer = buffer;
1748 while (packet->buffer->len) {
1749 SILC_GET16_MSB(len, packet->buffer->data + 2);
1750 if (len > packet->buffer->len)
1753 if (len > buffer->truelen) {
1754 silc_buffer_free(buffer);
1755 buffer = silc_buffer_alloc(1024 + len);
1758 silc_buffer_pull_tail(buffer, len);
1759 silc_buffer_put(buffer, packet->buffer->data, len);
1761 /* Process the Notify */
1762 silc_server_notify(server, sock, new);
1764 silc_buffer_push_tail(buffer, len);
1765 silc_buffer_pull(packet->buffer, len);
1768 silc_buffer_free(buffer);
1772 /* Received private message. This resolves the destination of the message
1773 and sends the packet. This is used by both server and router. If the
1774 destination is our locally connected client this sends the packet to
1775 the client. This may also send the message for further routing if
1776 the destination is not in our server (or router). */
1778 void silc_server_private_message(SilcServer server,
1779 SilcSocketConnection sock,
1780 SilcPacketContext *packet)
1782 SilcSocketConnection dst_sock;
1783 SilcIDListData idata;
1784 SilcClientEntry client;
1786 SILC_LOG_DEBUG(("Start"));
1788 if (packet->src_id_type != SILC_ID_CLIENT ||
1789 packet->dst_id_type != SILC_ID_CLIENT || !packet->dst_id)
1792 /* Get the route to the client */
1793 dst_sock = silc_server_get_client_route(server, packet->dst_id,
1794 packet->dst_id_len, NULL,
1798 unsigned char error;
1800 if (client && client->mode & SILC_UMODE_DETACHED) {
1801 SILC_LOG_DEBUG(("Client is detached, discarding packet"));
1805 /* Send SILC_NOTIFY_TYPE_ERROR to indicate that such destination ID
1806 does not exist or is invalid. */
1807 idp = silc_id_payload_encode_data(packet->dst_id,
1809 packet->dst_id_type);
1813 error = SILC_STATUS_ERR_NO_SUCH_CLIENT_ID;
1814 if (packet->src_id_type == SILC_ID_CLIENT) {
1815 SilcClientID *client_id = silc_id_str2id(packet->src_id,
1817 packet->src_id_type);
1818 silc_server_send_notify_dest(server, sock, FALSE,
1819 client_id, SILC_ID_CLIENT,
1820 SILC_NOTIFY_TYPE_ERROR, 2,
1822 idp->data, idp->len);
1823 silc_free(client_id);
1825 silc_server_send_notify(server, sock, FALSE,
1826 SILC_NOTIFY_TYPE_ERROR, 2,
1828 idp->data, idp->len);
1831 silc_buffer_free(idp);
1835 /* Check whether destination client wishes to receive private messages */
1836 if (client && !(packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY) &&
1837 client->mode & SILC_UMODE_BLOCK_PRIVMSG) {
1838 SILC_LOG_DEBUG(("Client blocks private messages, discarding packet"));
1842 /* Send the private message */
1843 silc_server_send_private_message(server, dst_sock, idata->send_key,
1844 idata->hmac_send, idata->psn_send++,
1848 /* Received private message key packet.. This packet is never for us. It is to
1849 the client in the packet's destination ID. Sending of this sort of packet
1850 equals sending private message, ie. it is sent point to point from
1851 one client to another. */
1853 void silc_server_private_message_key(SilcServer server,
1854 SilcSocketConnection sock,
1855 SilcPacketContext *packet)
1857 SilcSocketConnection dst_sock;
1858 SilcIDListData idata;
1860 SILC_LOG_DEBUG(("Start"));
1862 if (packet->src_id_type != SILC_ID_CLIENT ||
1863 packet->dst_id_type != SILC_ID_CLIENT)
1866 if (!packet->dst_id)
1869 /* Get the route to the client */
1870 dst_sock = silc_server_get_client_route(server, packet->dst_id,
1871 packet->dst_id_len, NULL,
1876 /* Relay the packet */
1877 silc_server_relay_packet(server, dst_sock, idata->send_key,
1878 idata->hmac_send, idata->psn_send++, packet, FALSE);
1881 /* Processes incoming command reply packet. The command reply packet may
1882 be destined to one of our clients or it may directly for us. We will
1883 call the command reply routine after processing the packet. */
1885 void silc_server_command_reply(SilcServer server,
1886 SilcSocketConnection sock,
1887 SilcPacketContext *packet)
1889 SilcBuffer buffer = packet->buffer;
1890 SilcClientEntry client = NULL;
1891 SilcSocketConnection dst_sock;
1892 SilcIDListData idata;
1893 SilcClientID *id = NULL;
1895 SILC_LOG_DEBUG(("Start"));
1897 /* Source must be server or router */
1898 if (packet->src_id_type != SILC_ID_SERVER &&
1899 sock->type != SILC_SOCKET_TYPE_ROUTER)
1902 if (packet->dst_id_type == SILC_ID_CHANNEL)
1905 if (packet->dst_id_type == SILC_ID_CLIENT) {
1906 /* Destination must be one of ours */
1907 id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CLIENT);
1910 client = silc_idlist_find_client_by_id(server->local_list, id, TRUE, NULL);
1912 SILC_LOG_ERROR(("Cannot process command reply to unknown client"));
1918 if (packet->dst_id_type == SILC_ID_SERVER) {
1919 /* For now this must be for us */
1920 if (memcmp(packet->dst_id, server->id_string, server->id_string_len)) {
1921 SILC_LOG_ERROR(("Cannot process command reply to unknown server"));
1926 /* Execute command reply locally for the command */
1927 silc_server_command_reply_process(server, sock, buffer);
1929 if (packet->dst_id_type == SILC_ID_CLIENT && client && id) {
1930 /* Relay the packet to the client */
1931 const SilcBufferStruct p;
1933 dst_sock = (SilcSocketConnection)client->connection;
1934 idata = (SilcIDListData)client;
1936 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1937 + packet->dst_id_len + packet->padlen);
1938 if (!silc_packet_send_prepare(dst_sock, 0, 0, buffer->len,
1939 idata->hmac_send, (const SilcBuffer)&p)) {
1940 SILC_LOG_ERROR(("Cannot send packet"));
1943 silc_buffer_put((SilcBuffer)&p, buffer->data, buffer->len);
1945 /* Encrypt packet */
1946 silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
1947 (SilcBuffer)&p, buffer->len);
1949 /* Send the packet */
1950 silc_server_packet_send_real(server, dst_sock, TRUE);
1956 /* Process received channel message. The message can be originated from
1957 client or server. */
1959 void silc_server_channel_message(SilcServer server,
1960 SilcSocketConnection sock,
1961 SilcPacketContext *packet)
1963 SilcChannelEntry channel = NULL;
1964 SilcChannelID *id = NULL;
1965 void *sender_id = NULL;
1966 SilcClientEntry sender_entry = NULL;
1967 SilcChannelClientEntry chl;
1970 SILC_LOG_DEBUG(("Processing channel message"));
1973 if (packet->dst_id_type != SILC_ID_CHANNEL) {
1974 SILC_LOG_DEBUG(("Received bad message for channel, dropped"));
1978 /* Find channel entry */
1979 id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CHANNEL);
1982 channel = silc_idlist_find_channel_by_id(server->local_list, id, NULL);
1984 channel = silc_idlist_find_channel_by_id(server->global_list, id, NULL);
1987 unsigned char error;
1989 /* Send SILC_NOTIFY_TYPE_ERROR to indicate that such destination ID
1990 does not exist or is invalid. */
1991 idp = silc_id_payload_encode_data(packet->dst_id,
1993 packet->dst_id_type);
1997 error = SILC_STATUS_ERR_NO_SUCH_CHANNEL_ID;
1998 if (packet->src_id_type == SILC_ID_CLIENT) {
1999 SilcClientID *client_id = silc_id_str2id(packet->src_id,
2001 packet->src_id_type);
2002 silc_server_send_notify_dest(server, sock, FALSE,
2003 client_id, SILC_ID_CLIENT,
2004 SILC_NOTIFY_TYPE_ERROR, 2,
2005 &error, 1, idp->data, idp->len);
2006 silc_free(client_id);
2008 silc_server_send_notify(server, sock, FALSE,
2009 SILC_NOTIFY_TYPE_ERROR, 2,
2010 &error, 1, idp->data, idp->len);
2013 silc_buffer_free(idp);
2018 /* See that this client is on the channel. If the original sender is
2019 not client (as it can be server as well) we don't do the check. */
2020 sender_id = silc_id_str2id(packet->src_id, packet->src_id_len,
2021 packet->src_id_type);
2024 if (packet->src_id_type == SILC_ID_CLIENT) {
2025 sender_entry = silc_idlist_find_client_by_id(server->local_list,
2026 sender_id, TRUE, NULL);
2027 if (!sender_entry) {
2029 sender_entry = silc_idlist_find_client_by_id(server->global_list,
2030 sender_id, TRUE, NULL);
2032 if (!sender_entry || !silc_server_client_on_channel(sender_entry,
2034 SILC_LOG_DEBUG(("Client not on channel"));
2038 /* If channel is moderated check that client is allowed to send
2040 if (channel->mode & SILC_CHANNEL_MODE_SILENCE_USERS &&
2041 !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
2042 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
2043 SILC_LOG_DEBUG(("Channel is silenced from normal users"));
2046 if (channel->mode & SILC_CHANNEL_MODE_SILENCE_OPERS &&
2047 chl->mode & SILC_CHANNEL_UMODE_CHANOP &&
2048 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
2049 SILC_LOG_DEBUG(("Channel is silenced from operators"));
2052 if (chl->mode & SILC_CHANNEL_UMODE_QUIET) {
2053 SILC_LOG_DEBUG(("Sender is quieted on the channel"));
2057 /* If the packet is coming from router, but the client entry is local
2058 entry to us then some router is rerouting this to us and it is not
2059 allowed. When the client is local to us it means that we've routed
2060 this packet to network, and now someone is routing it back to us. */
2061 if (server->server_type == SILC_ROUTER &&
2062 sock->type == SILC_SOCKET_TYPE_ROUTER && local) {
2063 SILC_LOG_DEBUG(("Channel message rerouted to the sender, drop it"));
2068 /* Distribute the packet to our local clients. This will send the
2069 packet for further routing as well, if needed. */
2070 silc_server_packet_relay_to_channel(server, sock, channel, sender_id,
2071 packet->src_id_type, sender_entry,
2072 packet->buffer->data,
2073 packet->buffer->len, FALSE);
2076 silc_free(sender_id);
2080 /* Received channel key packet. We distribute the key to all of our locally
2081 connected clients on the channel. */
2083 void silc_server_channel_key(SilcServer server,
2084 SilcSocketConnection sock,
2085 SilcPacketContext *packet)
2087 SilcBuffer buffer = packet->buffer;
2088 SilcChannelEntry channel;
2090 if (packet->src_id_type != SILC_ID_SERVER ||
2091 (server->server_type == SILC_ROUTER &&
2092 sock->type == SILC_SOCKET_TYPE_ROUTER))
2095 /* Save the channel key */
2096 channel = silc_server_save_channel_key(server, buffer, NULL);
2100 /* Distribute the key to everybody who is on the channel. If we are router
2101 we will also send it to locally connected servers. */
2102 silc_server_send_channel_key(server, sock, channel, FALSE);
2104 if (server->server_type != SILC_BACKUP_ROUTER) {
2105 /* Distribute to local cell backup routers. */
2106 silc_server_backup_send(server, sock->user_data,
2107 SILC_PACKET_CHANNEL_KEY, 0,
2108 buffer->data, buffer->len, FALSE, TRUE);
2112 /* Received New Client packet and processes it. Creates Client ID for the
2113 client. Client becomes registered after calling this functions. */
2115 SilcClientEntry silc_server_new_client(SilcServer server,
2116 SilcSocketConnection sock,
2117 SilcPacketContext *packet)
2119 SilcBuffer buffer = packet->buffer;
2120 SilcClientEntry client;
2121 SilcClientID *client_id;
2122 SilcIDListData idata;
2123 char *username = NULL, *realname = NULL;
2124 SilcUInt16 username_len;
2127 char *hostname, *nickname;
2130 SILC_LOG_DEBUG(("Creating new client"));
2132 if (sock->type != SILC_SOCKET_TYPE_CLIENT)
2135 /* Take client entry */
2136 client = (SilcClientEntry)sock->user_data;
2137 idata = (SilcIDListData)client;
2139 /* Remove the old cache entry. */
2140 if (!silc_idcache_del_by_context(server->local_list->clients, client)) {
2141 SILC_LOG_INFO(("Unauthenticated client attempted to register to network"));
2142 silc_server_disconnect_remote(server, sock,
2143 SILC_STATUS_ERR_NOT_AUTHENTICATED, NULL);
2144 if (sock->user_data)
2145 silc_server_free_sock_user_data(server, sock, NULL);
2149 /* Parse incoming packet */
2150 ret = silc_buffer_unformat(buffer,
2151 SILC_STR_UI16_NSTRING_ALLOC(&username,
2153 SILC_STR_UI16_STRING_ALLOC(&realname),
2156 silc_free(username);
2157 silc_free(realname);
2158 SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
2159 "connection", sock->hostname, sock->ip));
2160 silc_server_disconnect_remote(server, sock,
2161 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2163 if (sock->user_data)
2164 silc_server_free_sock_user_data(server, sock, NULL);
2169 silc_free(username);
2170 silc_free(realname);
2171 SILC_LOG_ERROR(("Client %s (%s) did not send its username, closing "
2172 "connection", sock->hostname, sock->ip));
2173 silc_server_disconnect_remote(server, sock,
2174 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2176 if (sock->user_data)
2177 silc_server_free_sock_user_data(server, sock, NULL);
2181 if (username_len > 128)
2182 username[128] = '\0';
2184 /* Check for bad characters for nickname, and modify the nickname if
2185 it includes those. */
2186 if (silc_server_name_bad_chars(username, username_len)) {
2187 nickname = silc_server_name_modify_bad(username, username_len);
2189 nickname = strdup(username);
2192 /* Make sanity checks for the hostname of the client. If the hostname
2193 is provided in the `username' check that it is the same than the
2194 resolved hostname, or if not resolved the hostname that appears in
2195 the client's public key. If the hostname is not present then put
2196 it from the resolved name or from the public key. */
2197 if (strchr(username, '@')) {
2198 SilcPublicKeyIdentifier pident;
2199 int tlen = strcspn(username, "@");
2200 char *phostname = NULL;
2202 hostname = silc_memdup(username + tlen + 1, strlen(username) - tlen - 1);
2204 if (strcmp(sock->hostname, sock->ip) &&
2205 strcmp(sock->hostname, hostname)) {
2206 silc_free(username);
2207 silc_free(hostname);
2208 silc_free(realname);
2209 SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
2210 "connection", sock->hostname, sock->ip));
2211 silc_server_disconnect_remote(server, sock,
2212 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2214 if (sock->user_data)
2215 silc_server_free_sock_user_data(server, sock, NULL);
2219 pident = silc_pkcs_decode_identifier(client->data.public_key->identifier);
2221 phostname = strdup(pident->host);
2222 silc_pkcs_free_identifier(pident);
2225 if (!strcmp(sock->hostname, sock->ip) &&
2226 phostname && strcmp(phostname, hostname)) {
2227 silc_free(username);
2228 silc_free(hostname);
2229 silc_free(phostname);
2230 silc_free(realname);
2231 SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
2232 "connection", sock->hostname, sock->ip));
2233 silc_server_disconnect_remote(server, sock,
2234 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2236 if (sock->user_data)
2237 silc_server_free_sock_user_data(server, sock, NULL);
2241 silc_free(phostname);
2243 /* The hostname is not present, add it. */
2245 /* XXX For now we cannot take the host name from the public key since
2246 they are not trusted or we cannot verify them as trusted. Just take
2247 what the resolved name or address is. */
2249 if (strcmp(sock->hostname, sock->ip)) {
2251 newusername = silc_calloc(strlen(username) +
2252 strlen(sock->hostname) + 2,
2253 sizeof(*newusername));
2254 strncat(newusername, username, strlen(username));
2255 strncat(newusername, "@", 1);
2256 strncat(newusername, sock->hostname, strlen(sock->hostname));
2257 silc_free(username);
2258 username = newusername;
2261 SilcPublicKeyIdentifier pident =
2262 silc_pkcs_decode_identifier(client->data.public_key->identifier);
2265 newusername = silc_calloc(strlen(username) +
2266 strlen(pident->host) + 2,
2267 sizeof(*newusername));
2268 strncat(newusername, username, strlen(username));
2269 strncat(newusername, "@", 1);
2270 strncat(newusername, pident->host, strlen(pident->host));
2271 silc_free(username);
2272 username = newusername;
2273 silc_pkcs_free_identifier(pident);
2279 /* Create Client ID */
2280 while (!silc_id_create_client_id(server, server->id, server->rng,
2281 server->md5hash, nickname, &client_id)) {
2284 silc_server_disconnect_remote(server, sock,
2285 SILC_STATUS_ERR_BAD_NICKNAME, NULL);
2286 if (sock->user_data)
2287 silc_server_free_sock_user_data(server, sock, NULL);
2290 snprintf(&nickname[strlen(nickname) - 1], 1, "%d", nickfail);
2293 /* If client marked as anonymous, scramble the username and hostname */
2294 if (client->mode & SILC_UMODE_ANONYMOUS) {
2297 if (strlen(username) >= 2) {
2298 username[0] = silc_rng_get_byte_fast(server->rng);
2299 username[1] = silc_rng_get_byte_fast(server->rng);
2302 scramble = silc_hash_babbleprint(server->sha1hash, username,
2306 memcpy(&scramble[16], ".silc", 5);
2307 scramble[21] = '\0';
2308 silc_free(username);
2309 username = scramble;
2312 /* Update client entry */
2313 idata->status |= SILC_IDLIST_STATUS_REGISTERED;
2314 client->nickname = nickname;
2315 client->username = username;
2316 client->userinfo = realname ? realname : strdup(" ");
2317 client->id = client_id;
2318 id_len = silc_id_get_len(client_id, SILC_ID_CLIENT);
2320 /* Add the client again to the ID cache */
2321 silc_idcache_add(server->local_list->clients, client->nickname,
2322 client_id, client, 0, NULL);
2324 /* Notify our router about new client on the SILC network */
2325 silc_server_send_new_id(server, SILC_PRIMARY_ROUTE(server),
2326 SILC_BROADCAST(server), client->id,
2327 SILC_ID_CLIENT, id_len);
2329 /* Distribute to backup routers */
2330 if (server->server_type == SILC_ROUTER) {
2331 SilcBuffer idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
2332 silc_server_backup_send(server, sock->user_data, SILC_PACKET_NEW_ID, 0,
2333 idp->data, idp->len, FALSE, TRUE);
2334 silc_buffer_free(idp);
2337 /* Send the new client ID to the client. */
2338 silc_server_send_new_id(server, sock, FALSE, client->id, SILC_ID_CLIENT,
2339 silc_id_get_len(client->id, SILC_ID_CLIENT));
2341 /* Send some nice info to the client */
2342 silc_server_send_connect_notifys(server, sock, client);
2344 /* Check if anyone is watching this nickname */
2345 if (server->server_type == SILC_ROUTER)
2346 silc_server_check_watcher_list(server, client, NULL, 0);
2351 /* Create new server. This processes received New Server packet and
2352 saves the received Server ID. The server is our locally connected
2353 server thus we save all the information and save it to local list.
2354 This funtion can be used by both normal server and router server.
2355 If normal server uses this it means that its router has connected
2356 to the server. If router uses this it means that one of the cell's
2357 servers is connected to the router. */
2359 SilcServerEntry silc_server_new_server(SilcServer server,
2360 SilcSocketConnection sock,
2361 SilcPacketContext *packet)
2363 SilcBuffer buffer = packet->buffer;
2364 SilcServerEntry new_server, server_entry;
2365 SilcServerID *server_id;
2366 SilcIDListData idata;
2367 unsigned char *server_name, *id_string;
2368 SilcUInt16 id_len, name_len;
2372 SILC_LOG_DEBUG(("Creating new server"));
2374 if (sock->type != SILC_SOCKET_TYPE_SERVER &&
2375 sock->type != SILC_SOCKET_TYPE_ROUTER)
2378 /* Take server entry */
2379 new_server = (SilcServerEntry)sock->user_data;
2380 idata = (SilcIDListData)new_server;
2382 /* Remove the old cache entry */
2383 if (!silc_idcache_del_by_context(server->local_list->servers, new_server)) {
2384 if (!silc_idcache_del_by_context(server->global_list->servers,
2386 SILC_LOG_INFO(("Unauthenticated %s attempted to register to "
2387 "network", (sock->type == SILC_SOCKET_TYPE_SERVER ?
2388 "server" : "router")));
2389 silc_server_disconnect_remote(server, sock,
2390 SILC_STATUS_ERR_NOT_AUTHENTICATED, NULL);
2391 if (sock->user_data)
2392 silc_server_free_sock_user_data(server, sock, NULL);
2398 /* Parse the incoming packet */
2399 ret = silc_buffer_unformat(buffer,
2400 SILC_STR_UI16_NSTRING_ALLOC(&id_string, &id_len),
2401 SILC_STR_UI16_NSTRING_ALLOC(&server_name,
2405 silc_free(id_string);
2406 silc_free(server_name);
2407 silc_server_disconnect_remote(server, sock,
2408 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2410 if (sock->user_data)
2411 silc_server_free_sock_user_data(server, sock, NULL);
2415 if (id_len > buffer->len) {
2416 silc_free(id_string);
2417 silc_free(server_name);
2418 silc_server_disconnect_remote(server, sock,
2419 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2421 if (sock->user_data)
2422 silc_server_free_sock_user_data(server, sock, NULL);
2427 server_name[255] = '\0';
2430 server_id = silc_id_str2id(id_string, id_len, SILC_ID_SERVER);
2432 silc_free(id_string);
2433 silc_free(server_name);
2434 silc_server_disconnect_remote(server, sock,
2435 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2437 if (sock->user_data)
2438 silc_server_free_sock_user_data(server, sock, NULL);
2441 silc_free(id_string);
2443 /* Check for valid server ID */
2444 if (!silc_id_is_valid_server_id(server, server_id, sock)) {
2445 SILC_LOG_INFO(("Invalid server ID sent by %s (%s)",
2446 sock->ip, sock->hostname));
2447 silc_server_disconnect_remote(server, sock,
2448 SILC_STATUS_ERR_BAD_SERVER_ID, NULL);
2449 if (sock->user_data)
2450 silc_server_free_sock_user_data(server, sock, NULL);
2451 silc_free(server_name);
2455 /* Check that we do not have this ID already */
2456 server_entry = silc_idlist_find_server_by_id(server->local_list,
2457 server_id, TRUE, NULL);
2459 silc_idcache_del_by_context(server->local_list->servers, server_entry);
2461 server_entry = silc_idlist_find_server_by_id(server->global_list,
2462 server_id, TRUE, NULL);
2464 silc_idcache_del_by_context(server->global_list->servers, server_entry);
2467 /* Update server entry */
2468 idata->status |= SILC_IDLIST_STATUS_REGISTERED;
2469 new_server->server_name = server_name;
2470 new_server->id = server_id;
2472 SILC_LOG_DEBUG(("New server id(%s)",
2473 silc_id_render(server_id, SILC_ID_SERVER)));
2475 /* Add again the entry to the ID cache. */
2476 silc_idcache_add(local ? server->local_list->servers :
2477 server->global_list->servers, server_name, server_id,
2478 new_server, 0, NULL);
2480 /* Distribute the information about new server in the SILC network
2481 to our router. If we are normal server we won't send anything
2482 since this connection must be our router connection. */
2483 if (server->server_type == SILC_ROUTER && !server->standalone &&
2484 SILC_PRIMARY_ROUTE(server) != sock)
2485 silc_server_send_new_id(server, SILC_PRIMARY_ROUTE(server),
2486 TRUE, new_server->id, SILC_ID_SERVER,
2487 silc_id_get_len(server_id, SILC_ID_SERVER));
2489 if (server->server_type == SILC_ROUTER) {
2490 /* Distribute to backup routers */
2491 SilcBuffer idp = silc_id_payload_encode(new_server->id, SILC_ID_SERVER);
2492 silc_server_backup_send(server, sock->user_data, SILC_PACKET_NEW_ID, 0,
2493 idp->data, idp->len, FALSE, TRUE);
2494 silc_buffer_free(idp);
2497 server->stat.cell_servers++;
2500 /* Check whether this router connection has been replaced by an
2501 backup router. If it has been then we'll disable the server and will
2502 ignore everything it will send until the backup router resuming
2503 protocol has been completed. */
2504 if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
2505 silc_server_backup_replaced_get(server, server_id, NULL)) {
2506 /* Send packet to the server indicating that it cannot use this
2507 connection as it has been replaced by backup router. */
2508 SilcBuffer packet = silc_buffer_alloc(2);
2509 silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
2510 silc_buffer_format(packet,
2511 SILC_STR_UI_CHAR(SILC_SERVER_BACKUP_REPLACED),
2512 SILC_STR_UI_CHAR(0),
2514 silc_server_packet_send(server, sock,
2515 SILC_PACKET_RESUME_ROUTER, 0,
2516 packet->data, packet->len, TRUE);
2517 silc_buffer_free(packet);
2519 /* Mark the router disabled. The data sent earlier will go but nothing
2520 after this does not go to this connection. */
2521 idata->status |= SILC_IDLIST_STATUS_DISABLED;
2523 /* If it is router announce our stuff to it. */
2524 if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
2525 server->server_type == SILC_ROUTER) {
2526 silc_server_announce_servers(server, FALSE, 0, sock);
2527 silc_server_announce_clients(server, 0, sock);
2528 silc_server_announce_channels(server, 0, sock);
2531 /* Announce our information to backup router */
2532 if (new_server->server_type == SILC_BACKUP_ROUTER &&
2533 sock->type == SILC_SOCKET_TYPE_SERVER &&
2534 server->server_type == SILC_ROUTER) {
2535 silc_server_announce_servers(server, TRUE, 0, sock);
2536 silc_server_announce_clients(server, 0, sock);
2537 silc_server_announce_channels(server, 0, sock);
2540 /* If backup router, mark it as one of ours. This server is considered
2541 to be backup router after this setting. */
2542 if (new_server->server_type == SILC_BACKUP_ROUTER) {
2543 SilcServerConfigRouter *backup;
2544 backup = silc_server_config_find_backup_conn(server, sock->ip);
2546 backup = silc_server_config_find_backup_conn(server, sock->hostname);
2548 /* Add as our backup router */
2549 silc_server_backup_add(server, new_server, backup->backup_replace_ip,
2550 backup->backup_replace_port,
2551 backup->backup_local);
2555 /* By default the servers connected to backup router are disabled
2556 until backup router has become the primary */
2557 if (server->server_type == SILC_BACKUP_ROUTER &&
2558 sock->type == SILC_SOCKET_TYPE_SERVER)
2559 idata->status |= SILC_IDLIST_STATUS_DISABLED;
2565 /* Processes incoming New ID packet. New ID Payload is used to distribute
2566 information about newly registered clients and servers. */
2568 static void silc_server_new_id_real(SilcServer server,
2569 SilcSocketConnection sock,
2570 SilcPacketContext *packet,
2573 SilcBuffer buffer = packet->buffer;
2575 SilcServerEntry router, server_entry;
2576 SilcSocketConnection router_sock;
2581 SILC_LOG_DEBUG(("Processing new ID"));
2583 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2584 server->server_type == SILC_SERVER ||
2585 packet->src_id_type != SILC_ID_SERVER)
2588 idp = silc_id_payload_parse(buffer->data, buffer->len);
2592 id_type = silc_id_payload_get_type(idp);
2594 /* Normal server cannot have other normal server connections */
2595 server_entry = (SilcServerEntry)sock->user_data;
2596 if (id_type == SILC_ID_SERVER && sock->type == SILC_SOCKET_TYPE_SERVER &&
2597 server_entry->server_type == SILC_SERVER)
2600 id = silc_id_payload_get_id(idp);
2604 /* If the packet is coming from server then use the sender as the
2605 origin of the the packet. If it came from router then check the real
2606 sender of the packet and use that as the origin. */
2607 if (sock->type == SILC_SOCKET_TYPE_SERVER) {
2608 id_list = server->local_list;
2610 router = sock->user_data;
2612 /* If the sender is backup router and ID is server (and we are not
2613 backup router) then switch the entry to global list. */
2614 if (server_entry->server_type == SILC_BACKUP_ROUTER &&
2615 id_type == SILC_ID_SERVER &&
2616 server->id_entry->server_type != SILC_BACKUP_ROUTER) {
2617 id_list = server->global_list;
2618 router_sock = server->router ? SILC_PRIMARY_ROUTE(server) : sock;
2621 void *sender_id = silc_id_str2id(packet->src_id, packet->src_id_len,
2622 packet->src_id_type);
2623 router = silc_idlist_find_server_by_id(server->global_list,
2624 sender_id, TRUE, NULL);
2626 router = silc_idlist_find_server_by_id(server->local_list,
2627 sender_id, TRUE, NULL);
2628 silc_free(sender_id);
2630 id_list = server->global_list;
2637 case SILC_ID_CLIENT:
2639 SilcClientEntry entry;
2641 /* Check that we do not have this client already */
2642 entry = silc_idlist_find_client_by_id(server->global_list,
2643 id, server->server_type,
2646 entry = silc_idlist_find_client_by_id(server->local_list,
2647 id, server->server_type,
2650 SILC_LOG_DEBUG(("Ignoring client that we already have"));
2654 SILC_LOG_DEBUG(("New client id(%s) from [%s] %s",
2655 silc_id_render(id, SILC_ID_CLIENT),
2656 sock->type == SILC_SOCKET_TYPE_SERVER ?
2657 "Server" : "Router", sock->hostname));
2659 /* As a router we keep information of all global information in our
2660 global list. Cell wide information however is kept in the local
2662 entry = silc_idlist_add_client(id_list, NULL, NULL, NULL,
2663 id, router, NULL, 0);
2665 SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
2667 /* Inform the sender that the ID is not usable */
2668 silc_server_send_notify_signoff(server, sock, FALSE, id, NULL);
2671 entry->nickname = NULL;
2672 entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
2674 if (sock->type == SILC_SOCKET_TYPE_SERVER)
2675 server->stat.cell_clients++;
2676 server->stat.clients++;
2678 /* Check if anyone is watching this nickname */
2679 if (server->server_type == SILC_ROUTER && id_list == server->local_list)
2680 silc_server_check_watcher_list(server, entry, NULL, 0);
2684 case SILC_ID_SERVER:
2686 SilcServerEntry entry;
2688 /* If the ID is mine, ignore it. */
2689 if (SILC_ID_SERVER_COMPARE(id, server->id)) {
2690 SILC_LOG_DEBUG(("Ignoring my own ID as new ID"));
2694 /* If the ID is the sender's ID, ignore it (we have it already) */
2695 if (SILC_ID_SERVER_COMPARE(id, router->id)) {
2696 SILC_LOG_DEBUG(("Ignoring sender's own ID"));
2700 /* Check that we do not have this server already */
2701 entry = silc_idlist_find_server_by_id(server->global_list,
2702 id, server->server_type,
2705 entry = silc_idlist_find_server_by_id(server->local_list,
2706 id, server->server_type,
2709 SILC_LOG_DEBUG(("Ignoring server that we already have"));
2713 SILC_LOG_DEBUG(("New server id(%s) from [%s] %s",
2714 silc_id_render(id, SILC_ID_SERVER),
2715 sock->type == SILC_SOCKET_TYPE_SERVER ?
2716 "Server" : "Router", sock->hostname));
2718 /* As a router we keep information of all global information in our
2719 global list. Cell wide information however is kept in the local
2721 entry = silc_idlist_add_server(id_list, NULL, 0, id, router,
2724 SILC_LOG_ERROR(("Could not add new server to the ID Cache"));
2727 entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
2729 if (sock->type == SILC_SOCKET_TYPE_SERVER)
2730 server->stat.cell_servers++;
2731 server->stat.servers++;
2735 case SILC_ID_CHANNEL:
2736 SILC_LOG_ERROR(("Channel cannot be registered with NEW_ID packet"));
2745 /* If the sender of this packet is server and we are router we need to
2746 broadcast this packet to other routers in the network. */
2747 if (broadcast && server->server_type == SILC_ROUTER &&
2748 sock->type == SILC_SOCKET_TYPE_SERVER &&
2749 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2750 SILC_LOG_DEBUG(("Broadcasting received New ID packet"));
2751 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
2753 packet->flags | SILC_PACKET_FLAG_BROADCAST,
2754 buffer->data, buffer->len, FALSE);
2755 silc_server_backup_send(server, sock->user_data,
2756 packet->type, packet->flags,
2757 packet->buffer->data, packet->buffer->len,
2762 silc_id_payload_free(idp);
2766 /* Processes incoming New ID packet. New ID Payload is used to distribute
2767 information about newly registered clients and servers. */
2769 void silc_server_new_id(SilcServer server, SilcSocketConnection sock,
2770 SilcPacketContext *packet)
2772 silc_server_new_id_real(server, sock, packet, TRUE);
2775 /* Receoved New Id List packet, list of New ID payloads inside one
2776 packet. Process the New ID payloads one by one. */
2778 void silc_server_new_id_list(SilcServer server, SilcSocketConnection sock,
2779 SilcPacketContext *packet)
2781 SilcPacketContext *new_id;
2785 SILC_LOG_DEBUG(("Processing New ID List"));
2787 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2788 packet->src_id_type != SILC_ID_SERVER)
2791 /* If the sender of this packet is server and we are router we need to
2792 broadcast this packet to other routers in the network. Broadcast
2793 this list packet instead of multiple New ID packets. */
2794 if (server->server_type == SILC_ROUTER &&
2795 sock->type == SILC_SOCKET_TYPE_SERVER &&
2796 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2797 SILC_LOG_DEBUG(("Broadcasting received New ID List packet"));
2798 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
2800 packet->flags | SILC_PACKET_FLAG_BROADCAST,
2801 packet->buffer->data,
2802 packet->buffer->len, FALSE);
2803 silc_server_backup_send(server, sock->user_data,
2804 packet->type, packet->flags,
2805 packet->buffer->data, packet->buffer->len,
2809 /* Make copy of the original packet context, except for the actual
2810 data buffer, which we will here now fetch from the original buffer. */
2811 new_id = silc_packet_context_alloc();
2812 new_id->type = SILC_PACKET_NEW_ID;
2813 new_id->flags = packet->flags & (~SILC_PACKET_FLAG_LIST);
2814 new_id->src_id = packet->src_id;
2815 new_id->src_id_len = packet->src_id_len;
2816 new_id->src_id_type = packet->src_id_type;
2817 new_id->dst_id = packet->dst_id;
2818 new_id->dst_id_len = packet->dst_id_len;
2819 new_id->dst_id_type = packet->dst_id_type;
2821 idp = silc_buffer_alloc(256);
2822 new_id->buffer = idp;
2824 while (packet->buffer->len) {
2825 SILC_GET16_MSB(id_len, packet->buffer->data + 2);
2826 if ((id_len > packet->buffer->len) ||
2827 (id_len > idp->truelen))
2830 silc_buffer_pull_tail(idp, 4 + id_len);
2831 silc_buffer_put(idp, packet->buffer->data, 4 + id_len);
2833 /* Process the New ID */
2834 silc_server_new_id_real(server, sock, new_id, FALSE);
2836 silc_buffer_push_tail(idp, 4 + id_len);
2837 silc_buffer_pull(packet->buffer, 4 + id_len);
2840 silc_buffer_free(idp);
2844 /* Received New Channel packet. Information about new channels in the
2845 network are distributed using this packet. Save the information about
2846 the new channel. This usually comes from router but also normal server
2847 can send this to notify channels it has when it connects to us. */
2849 void silc_server_new_channel(SilcServer server,
2850 SilcSocketConnection sock,
2851 SilcPacketContext *packet)
2853 SilcChannelPayload payload;
2854 SilcChannelID *channel_id;
2856 SilcUInt32 name_len;
2859 SilcServerEntry server_entry;
2860 SilcChannelEntry channel;
2862 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2863 packet->src_id_type != SILC_ID_SERVER ||
2864 server->server_type == SILC_SERVER)
2867 /* Parse the channel payload */
2868 payload = silc_channel_payload_parse(packet->buffer->data,
2869 packet->buffer->len);
2873 /* Get the channel ID */
2874 channel_id = silc_channel_get_id_parse(payload);
2876 silc_channel_payload_free(payload);
2880 channel_name = silc_channel_get_name(payload, &name_len);
2882 channel_name[255] = '\0';
2884 id = silc_channel_get_id(payload, &id_len);
2886 server_entry = (SilcServerEntry)sock->user_data;
2888 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
2889 /* Add the channel to global list as it is coming from router. It
2890 cannot be our own channel as it is coming from router. */
2892 /* Check that we don't already have this channel */
2893 channel = silc_idlist_find_channel_by_name(server->local_list,
2894 channel_name, NULL);
2896 channel = silc_idlist_find_channel_by_name(server->global_list,
2897 channel_name, NULL);
2899 SILC_LOG_DEBUG(("New channel id(%s) from [Router] %s",
2900 silc_id_render(channel_id, SILC_ID_CHANNEL),
2904 silc_idlist_add_channel(server->global_list, strdup(channel_name),
2905 0, channel_id, sock->user_data, NULL, NULL, 0);
2908 channel->disabled = TRUE; /* Disabled until someone JOINs */
2910 server->stat.channels++;
2911 if (server->server_type == SILC_ROUTER)
2912 channel->users_resolved = TRUE;
2915 /* The channel is coming from our server, thus it is in our cell
2916 we will add it to our local list. */
2919 SILC_LOG_DEBUG(("Channel id(%s) from [Server] %s",
2920 silc_id_render(channel_id, SILC_ID_CHANNEL),
2923 /* Check that we don't already have this channel */
2924 channel = silc_idlist_find_channel_by_name(server->local_list,
2925 channel_name, NULL);
2927 channel = silc_idlist_find_channel_by_name(server->global_list,
2928 channel_name, NULL);
2930 /* If the channel does not exist, then create it. This creates a new
2931 key to the channel as well that we will send to the server. */
2933 SILC_LOG_DEBUG(("Channel is new to us"));
2935 /* The protocol says that the Channel ID's IP address must be based
2936 on the router's IP address. Check whether the ID is based in our
2937 IP and if it is not then create a new ID and enforce the server
2938 to switch the ID. */
2939 if (server_entry->server_type != SILC_BACKUP_ROUTER &&
2940 !SILC_ID_COMPARE(channel_id, server->id, server->id->ip.data_len)) {
2942 SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
2943 if (silc_id_create_channel_id(server, server->id, server->rng, &tmp)) {
2944 silc_server_send_notify_channel_change(server, sock, FALSE,
2946 silc_free(channel_id);
2950 /* Wait that server re-announces this channel */
2954 /* Create the channel with the provided Channel ID */
2955 channel = silc_server_create_new_channel_with_id(server, NULL, NULL,
2959 silc_channel_payload_free(payload);
2960 silc_free(channel_id);
2963 channel->disabled = TRUE; /* Disabled until someone JOINs */
2965 #if 0 /* We assume that CMODE_CHANGE notify is sent to us after this. */
2967 /* XXX Dunno if this is supposed to be set in any server type. If set
2968 here the CMODE_CHANGE that may follow sets mode that we already
2969 have, and we may loose data from the CMODE_CHANGE notify. */
2970 if (server_entry->server_type != SILC_BACKUP_ROUTER)
2971 channel->mode = silc_channel_get_mode(payload);
2974 /* Send the new channel key to the server */
2975 id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
2976 id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
2977 chk = silc_channel_key_payload_encode(id_len, id,
2978 strlen(channel->channel_key->
2980 channel->channel_key->cipher->name,
2981 channel->key_len / 8,
2983 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
2984 chk->data, chk->len, FALSE);
2985 silc_buffer_free(chk);
2987 /* The channel exist by that name, check whether the ID's match.
2988 If they don't then we'll force the server to use the ID we have.
2989 We also create a new key for the channel. */
2990 SilcBuffer modes = NULL, users = NULL, users_modes = NULL;
2992 SILC_LOG_DEBUG(("Channel already exists"));
2994 if (!SILC_ID_CHANNEL_COMPARE(channel_id, channel->id)) {
2995 /* They don't match, send CHANNEL_CHANGE notify to the server to
2996 force the ID change. */
2997 SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
2998 silc_server_send_notify_channel_change(server, sock, FALSE,
2999 channel_id, channel->id);
3001 /* Wait that server re-announces this channel */
3005 #if 0 /* We will announce our CMODE anyway for this channel, so no need
3006 to check it (implicit enforce). */
3008 /* If the mode is different from what we have then enforce the
3010 mode = silc_channel_get_mode(payload);
3011 if (channel->mode != mode) {
3012 SILC_LOG_DEBUG(("Forcing the server to change channel mode"));
3013 silc_server_send_notify_cmode(server, sock, FALSE, channel,
3014 channel->mode, server->id,
3015 SILC_ID_SERVER, channel->cipher,
3017 channel->passphrase,
3018 channel->founder_key);
3022 /* Create new key for the channel and send it to the server and
3023 everybody else possibly on the channel. */
3024 if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
3026 if (silc_hash_table_count(channel->user_list)) {
3027 if (!silc_server_create_channel_key(server, channel, 0))
3030 /* Send to the channel */
3031 silc_server_send_channel_key(server, sock, channel, FALSE);
3034 /* Send to the server */
3035 id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
3036 id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
3037 chk = silc_channel_key_payload_encode(id_len, id,
3038 strlen(channel->channel_key->
3040 channel->channel_key->
3042 channel->key_len / 8,
3044 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
3045 chk->data, chk->len, FALSE);
3046 silc_buffer_free(chk);
3050 silc_free(channel_id);
3052 /* Update statistics */
3053 server->stat.channels++;
3054 server->stat.cell_channels++;
3056 /* Since the channel is coming from server and we also know about it
3057 then send the JOIN notify to the server so that it see's our
3058 users on the channel "joining" the channel. */
3059 silc_server_announce_get_channel_users(server, channel, &modes, &users,
3062 silc_buffer_push(users, users->data - users->head);
3063 silc_server_packet_send(server, sock,
3064 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
3065 users->data, users->len, FALSE);
3066 silc_buffer_free(users);
3069 silc_buffer_push(modes, modes->data - modes->head);
3070 silc_server_packet_send_dest(server, sock,
3071 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
3072 channel->id, SILC_ID_CHANNEL,
3073 modes->data, modes->len, FALSE);
3074 silc_buffer_free(modes);
3077 silc_buffer_push(users_modes, users_modes->data - users_modes->head);
3078 silc_server_packet_send_dest(server, sock,
3079 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
3080 channel->id, SILC_ID_CHANNEL,
3082 users_modes->len, FALSE);
3083 silc_buffer_free(users_modes);
3085 if (channel->topic) {
3086 silc_server_send_notify_topic_set(server, sock,
3087 server->server_type == SILC_ROUTER ?
3088 TRUE : FALSE, channel,
3089 server->id, SILC_ID_SERVER,
3095 /* If the sender of this packet is server and we are router we need to
3096 broadcast this packet to other routers in the network. Broadcast
3097 this list packet instead of multiple New Channel packets. */
3098 if (server->server_type == SILC_ROUTER &&
3099 sock->type == SILC_SOCKET_TYPE_SERVER &&
3100 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
3101 SILC_LOG_DEBUG(("Broadcasting received New Channel packet"));
3102 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3104 packet->flags | SILC_PACKET_FLAG_BROADCAST,
3105 packet->buffer->data,
3106 packet->buffer->len, FALSE);
3107 silc_server_backup_send(server, sock->user_data,
3108 packet->type, packet->flags,
3109 packet->buffer->data, packet->buffer->len,
3113 silc_channel_payload_free(payload);
3116 /* Received New Channel List packet, list of New Channel List payloads inside
3117 one packet. Process the New Channel payloads one by one. */
3119 void silc_server_new_channel_list(SilcServer server,
3120 SilcSocketConnection sock,
3121 SilcPacketContext *packet)
3123 SilcPacketContext *new;
3125 SilcUInt16 len1, len2;
3127 SILC_LOG_DEBUG(("Processing New Channel List"));
3129 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
3130 packet->src_id_type != SILC_ID_SERVER ||
3131 server->server_type == SILC_SERVER)
3134 /* Make copy of the original packet context, except for the actual
3135 data buffer, which we will here now fetch from the original buffer. */
3136 new = silc_packet_context_alloc();
3137 new->type = SILC_PACKET_NEW_CHANNEL;
3138 new->flags = packet->flags & (~SILC_PACKET_FLAG_LIST);
3139 new->src_id = packet->src_id;
3140 new->src_id_len = packet->src_id_len;
3141 new->src_id_type = packet->src_id_type;
3142 new->dst_id = packet->dst_id;
3143 new->dst_id_len = packet->dst_id_len;
3144 new->dst_id_type = packet->dst_id_type;
3146 buffer = silc_buffer_alloc(512);
3147 new->buffer = buffer;
3149 while (packet->buffer->len) {
3150 SILC_GET16_MSB(len1, packet->buffer->data);
3151 if ((len1 > packet->buffer->len) ||
3152 (len1 > buffer->truelen))
3155 SILC_GET16_MSB(len2, packet->buffer->data + 2 + len1);
3156 if ((len2 > packet->buffer->len) ||
3157 (len2 > buffer->truelen))
3160 silc_buffer_pull_tail(buffer, 8 + len1 + len2);
3161 silc_buffer_put(buffer, packet->buffer->data, 8 + len1 + len2);
3163 /* Process the New Channel */
3164 silc_server_new_channel(server, sock, new);
3166 silc_buffer_push_tail(buffer, 8 + len1 + len2);
3167 silc_buffer_pull(packet->buffer, 8 + len1 + len2);
3170 silc_buffer_free(buffer);
3174 /* Received key agreement packet. This packet is never for us. It is to
3175 the client in the packet's destination ID. Sending of this sort of packet
3176 equals sending private message, ie. it is sent point to point from
3177 one client to another. */
3179 void silc_server_key_agreement(SilcServer server,
3180 SilcSocketConnection sock,
3181 SilcPacketContext *packet)
3183 SilcSocketConnection dst_sock;
3184 SilcIDListData idata;
3186 SILC_LOG_DEBUG(("Start"));
3188 if (packet->src_id_type != SILC_ID_CLIENT ||
3189 packet->dst_id_type != SILC_ID_CLIENT)
3192 if (!packet->dst_id)
3195 /* Get the route to the client */
3196 dst_sock = silc_server_get_client_route(server, packet->dst_id,
3197 packet->dst_id_len, NULL,
3202 /* Relay the packet */
3203 silc_server_relay_packet(server, dst_sock, idata->send_key,
3204 idata->hmac_send, idata->psn_send++,
3208 /* Received connection auth request packet that is used during connection
3209 phase to resolve the mandatory authentication method. This packet can
3210 actually be received at anytime but usually it is used only during
3211 the connection authentication phase. Now, protocol says that this packet
3212 can come from client or server, however, we support only this coming
3213 from client and expect that server always knows what authentication
3216 void silc_server_connection_auth_request(SilcServer server,
3217 SilcSocketConnection sock,
3218 SilcPacketContext *packet)
3220 SilcServerConfigClient *client = NULL;
3221 SilcUInt16 conn_type;
3223 SilcAuthMethod auth_meth = SILC_AUTH_NONE;
3225 if (packet->src_id_type && packet->src_id_type != SILC_ID_CLIENT) {
3226 SILC_LOG_DEBUG(("Request not from client"));
3230 /* Parse the payload */
3231 ret = silc_buffer_unformat(packet->buffer,
3232 SILC_STR_UI_SHORT(&conn_type),
3233 SILC_STR_UI_SHORT(NULL),
3238 if (conn_type != SILC_SOCKET_TYPE_CLIENT)
3241 /* Get the authentication method for the client */
3242 auth_meth = SILC_AUTH_NONE;
3243 client = silc_server_config_find_client(server, sock->ip);
3245 client = silc_server_config_find_client(server, sock->hostname);
3247 if (client->passphrase) {
3248 if (client->publickeys && !server->config->prefer_passphrase_auth)
3249 auth_meth = SILC_AUTH_PUBLIC_KEY;
3251 auth_meth = SILC_AUTH_PASSWORD;
3252 } else if (client->publickeys)
3253 auth_meth = SILC_AUTH_PUBLIC_KEY;
3256 SILC_LOG_DEBUG(("Authentication method is [%s]",
3257 (auth_meth == SILC_AUTH_NONE ? "None" :
3258 auth_meth == SILC_AUTH_PASSWORD ? "Passphrase" :
3259 "Digital signatures")));
3261 /* Send it back to the client */
3262 silc_server_send_connection_auth_request(server, sock, conn_type, auth_meth);
3265 /* Received REKEY packet. The sender of the packet wants to regenerate
3266 its session keys. This starts the REKEY protocol. */
3268 void silc_server_rekey(SilcServer server,
3269 SilcSocketConnection sock,
3270 SilcPacketContext *packet)
3272 SilcProtocol protocol;
3273 SilcServerRekeyInternalContext *proto_ctx;
3274 SilcIDListData idata = (SilcIDListData)sock->user_data;
3276 SILC_LOG_DEBUG(("Start"));
3278 /* Allocate internal protocol context. This is sent as context
3280 proto_ctx = silc_calloc(1, sizeof(*proto_ctx));
3281 proto_ctx->server = (void *)server;
3282 proto_ctx->sock = sock;
3283 proto_ctx->responder = TRUE;
3284 proto_ctx->pfs = idata->rekey->pfs;
3286 /* Perform rekey protocol. Will call the final callback after the
3287 protocol is over. */
3288 silc_protocol_alloc(SILC_PROTOCOL_SERVER_REKEY,
3289 &protocol, proto_ctx, silc_server_rekey_final);
3290 sock->protocol = protocol;
3292 if (proto_ctx->pfs == FALSE)
3293 /* Run the protocol */
3294 silc_protocol_execute(protocol, server->schedule, 0, 0);
3297 /* Received file transger packet. This packet is never for us. It is to
3298 the client in the packet's destination ID. Sending of this sort of packet
3299 equals sending private message, ie. it is sent point to point from
3300 one client to another. */
3302 void silc_server_ftp(SilcServer server,
3303 SilcSocketConnection sock,
3304 SilcPacketContext *packet)
3306 SilcSocketConnection dst_sock;
3307 SilcIDListData idata;
3309 SILC_LOG_DEBUG(("Start"));
3311 if (packet->src_id_type != SILC_ID_CLIENT ||
3312 packet->dst_id_type != SILC_ID_CLIENT)
3315 if (!packet->dst_id)
3318 /* Get the route to the client */
3319 dst_sock = silc_server_get_client_route(server, packet->dst_id,
3320 packet->dst_id_len, NULL,
3325 /* Relay the packet */
3326 silc_server_relay_packet(server, dst_sock, idata->send_key,
3327 idata->hmac_send, idata->psn_send++,
3333 SilcSocketConnection sock;
3334 SilcPacketContext *packet;
3336 } *SilcServerResumeResolve;
3338 SILC_SERVER_CMD_FUNC(resume_resolve)
3340 SilcServerResumeResolve r = (SilcServerResumeResolve)context;
3341 SilcServer server = r->server;
3342 SilcSocketConnection sock = r->sock;
3343 SilcServerCommandReplyContext reply = context2;
3344 SilcClientEntry client;
3346 SILC_LOG_DEBUG(("Start"));
3348 if (!reply || !silc_command_get_status(reply->payload, NULL, NULL)) {
3349 SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
3350 "closing connection", sock->hostname, sock->ip));
3351 silc_server_disconnect_remote(server, sock,
3352 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3353 "Resuming not possible");
3354 if (sock->user_data)
3355 silc_server_free_sock_user_data(server, sock, NULL);
3359 if (reply && silc_command_get(reply->payload) == SILC_COMMAND_WHOIS) {
3360 /* Get entry to the client, and resolve it if we don't have it. */
3361 client = silc_idlist_find_client_by_id(server->local_list,
3362 r->data, TRUE, NULL);
3364 client = silc_idlist_find_client_by_id(server->global_list,
3365 r->data, TRUE, NULL);
3367 SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
3368 "closing connection", sock->hostname, sock->ip));
3369 silc_server_disconnect_remote(server, sock,
3370 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3371 "Resuming not possible");
3372 if (sock->user_data)
3373 silc_server_free_sock_user_data(server, sock, NULL);
3378 if (!(client->mode & SILC_UMODE_DETACHED)) {
3379 SILC_LOG_ERROR(("Client %s (%s) tried to resume un-detached client, "
3380 "closing connection", sock->hostname, sock->ip));
3381 silc_server_disconnect_remote(server, sock,
3382 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3383 "Resuming not possible");
3384 if (sock->user_data)
3385 silc_server_free_sock_user_data(server, sock, NULL);
3390 /* Reprocess the packet */
3391 silc_server_resume_client(server, sock, r->packet);
3394 silc_socket_free(r->sock);
3395 silc_packet_context_free(r->packet);
3400 /* Received client resuming packet. This is used to resume detached
3401 client session. It can be sent by the client who wishes to resume
3402 but this is also sent by servers and routers to notify other routers
3403 that the client is not detached anymore. */
3405 void silc_server_resume_client(SilcServer server,
3406 SilcSocketConnection sock,
3407 SilcPacketContext *packet)
3409 SilcBuffer buffer = packet->buffer, buf;
3410 SilcIDListData idata;
3411 SilcIDCacheEntry id_cache = NULL;
3412 SilcClientEntry detached_client;
3413 SilcClientID *client_id = NULL;
3414 unsigned char *id_string, *auth = NULL;
3415 SilcUInt16 id_len, auth_len = 0;
3416 int ret, nickfail = 0;
3417 bool resolved, local, nick_change = FALSE, resolve = FALSE;
3418 SilcChannelEntry channel;
3419 SilcHashTableList htl;
3420 SilcChannelClientEntry chl;
3421 SilcServerResumeResolve r;
3423 ret = silc_buffer_unformat(buffer,
3424 SILC_STR_UI16_NSTRING(&id_string, &id_len),
3427 client_id = silc_id_str2id(id_string, id_len, SILC_ID_CLIENT);
3429 if (sock->type == SILC_SOCKET_TYPE_CLIENT) {
3430 /* Client send this and is attempting to resume to old client session */
3431 SilcClientEntry client;
3435 silc_buffer_pull(buffer, 2 + id_len);
3436 auth = buffer->data;
3437 auth_len = buffer->len;
3438 silc_buffer_push(buffer, 2 + id_len);
3441 if (!client_id || auth_len < 128) {
3442 SILC_LOG_ERROR(("Client %s (%s) sent incomplete resume information, "
3443 "closing connection", sock->hostname, sock->ip));
3444 silc_server_disconnect_remote(server, sock,
3445 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3446 "Resuming not possible");
3447 if (sock->user_data)
3448 silc_server_free_sock_user_data(server, sock, NULL);
3449 silc_free(client_id);
3453 /* Take client entry of this connection */
3454 client = (SilcClientEntry)sock->user_data;
3455 idata = (SilcIDListData)client;
3457 /* Get entry to the client, and resolve it if we don't have it. */
3458 detached_client = silc_server_get_client_resolve(server, client_id, FALSE,
3460 if (!detached_client) {
3462 /* The client info is being resolved. Reprocess this packet after
3463 receiving the reply to the query. */
3464 SILC_LOG_DEBUG(("Resolving client"));
3465 r = silc_calloc(1, sizeof(*r));
3469 r->sock = silc_socket_dup(sock);
3470 r->packet = silc_packet_context_dup(packet);
3471 r->data = client_id;
3472 silc_server_command_pending(server, SILC_COMMAND_WHOIS,
3474 silc_server_command_resume_resolve, r);
3476 SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
3477 "closing connection", sock->hostname, sock->ip));
3478 silc_server_disconnect_remote(server, sock,
3479 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3480 "Resuming not possible");
3481 if (sock->user_data)
3482 silc_server_free_sock_user_data(server, sock, NULL);
3483 silc_free(client_id);
3488 if (!(detached_client->mode & SILC_UMODE_DETACHED))
3490 if (!silc_hash_table_count(detached_client->channels) &&
3491 detached_client->router)
3493 if (!detached_client->nickname)
3497 if (server->server_type == SILC_SERVER && !server->standalone) {
3498 /* The client info is being resolved. Reprocess this packet after
3499 receiving the reply to the query. */
3500 SILC_LOG_DEBUG(("Resolving client info"));
3501 silc_server_get_client_resolve(server, client_id, TRUE, NULL);
3502 r = silc_calloc(1, sizeof(*r));
3506 r->sock = silc_socket_dup(sock);
3507 r->packet = silc_packet_context_dup(packet);
3508 r->data = client_id;
3509 silc_server_command_pending(server, SILC_COMMAND_WHOIS,
3511 silc_server_command_resume_resolve, r);
3514 if (server->server_type == SILC_SERVER) {
3515 SILC_LOG_ERROR(("Client %s (%s) tried to resume un-detached client, "
3516 "closing connection", sock->hostname, sock->ip));
3517 silc_server_disconnect_remote(server, sock,
3518 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3519 "Resuming not possible");
3520 if (sock->user_data)
3521 silc_server_free_sock_user_data(server, sock, NULL);
3522 silc_free(client_id);
3527 /* Check that we have the public key of the client, if not then we must
3528 resolve it first. */
3529 if (!detached_client->data.public_key) {
3530 if (server->server_type == SILC_SERVER && server->standalone) {
3531 SILC_LOG_ERROR(("Detached client's public key not present, "
3532 "closing connection"));
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);
3540 /* We must retrieve the detached client's public key by sending
3541 GETKEY command. Reprocess this packet after receiving the key */
3542 SilcBuffer idp = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
3543 SilcSocketConnection dest_sock =
3544 silc_server_get_client_route(server, NULL, 0, client_id, NULL, NULL);
3546 SILC_LOG_DEBUG(("Resolving client public key"));
3548 silc_server_send_command(server, dest_sock ? dest_sock :
3549 SILC_PRIMARY_ROUTE(server),
3550 SILC_COMMAND_GETKEY, ++server->cmd_ident,
3551 1, 1, idp->data, idp->len);
3553 r = silc_calloc(1, sizeof(*r));
3555 silc_free(client_id);
3560 r->sock = silc_socket_dup(sock);
3561 r->packet = silc_packet_context_dup(packet);
3562 silc_server_command_pending(server, SILC_COMMAND_GETKEY,
3564 silc_server_command_resume_resolve, r);
3566 silc_buffer_free(idp);
3568 silc_free(client_id);
3570 } else if (!silc_pkcs_public_key_compare(detached_client->data.public_key,
3571 idata->public_key)) {
3572 /* We require that the connection and resuming authentication data
3573 must be using same key pair. */
3574 SILC_LOG_ERROR(("Resuming attempted with wrong public key, "
3575 "closing connection"));
3576 silc_server_disconnect_remote(server, sock,
3577 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3578 "Resuming not possible");
3579 if (sock->user_data)
3580 silc_server_free_sock_user_data(server, sock, NULL);
3581 silc_free(client_id);
3585 /* Verify the authentication payload. This has to be successful in
3586 order to allow the resuming */
3588 !silc_auth_verify_data(auth, auth_len, SILC_AUTH_PUBLIC_KEY,
3589 detached_client->data.public_key, 0,
3590 idata->hash, detached_client->id,
3592 SILC_LOG_ERROR(("Client %s (%s) resume authentication failed, "
3593 "closing connection", sock->hostname, sock->ip));
3594 silc_server_disconnect_remote(server, sock,
3595 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3596 "Resuming not possible");
3597 if (sock->user_data)
3598 silc_server_free_sock_user_data(server, sock, NULL);
3599 silc_free(client_id);
3603 /* Now resume the client to the network */
3605 silc_schedule_task_del_by_context(server->schedule, detached_client);
3606 sock->user_data = detached_client;
3607 detached_client->connection = sock;
3609 /* Take new keys and stuff into use in the old entry */
3610 silc_idlist_del_data(detached_client);
3611 silc_idlist_add_data(detached_client, idata);
3612 detached_client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
3613 detached_client->data.status |= SILC_IDLIST_STATUS_RESUMED;
3614 detached_client->mode &= ~SILC_UMODE_DETACHED;
3615 server->stat.my_detached--;
3617 /* Send the RESUME_CLIENT packet to our primary router so that others
3618 know this client isn't detached anymore. */
3619 buf = silc_buffer_alloc_size(2 + id_len);
3620 silc_buffer_format(buf,
3621 SILC_STR_UI_SHORT(id_len),
3622 SILC_STR_UI_XNSTRING(id_string, id_len),
3625 /* Send to primary router */
3626 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3627 SILC_PACKET_RESUME_CLIENT, 0,
3628 buf->data, buf->len, TRUE);
3630 /* As router we must deliver this packet directly to the original
3631 server whom this client was earlier. */
3632 if (server->server_type == SILC_ROUTER && detached_client->router &&
3633 detached_client->router->server_type != SILC_ROUTER)
3634 silc_server_packet_send(server, detached_client->router->connection,
3635 SILC_PACKET_RESUME_CLIENT, 0,
3636 buf->data, buf->len, TRUE);
3637 silc_buffer_free(buf);
3639 detached_client->router = NULL;
3641 /* Delete this client entry since we're resuming to old one. */
3642 server->stat.my_clients--;
3643 server->stat.clients--;
3644 if (server->stat.cell_clients)
3645 server->stat.cell_clients--;
3646 silc_server_remove_from_channels(server, NULL, client, FALSE, NULL, FALSE);
3647 silc_server_del_from_watcher_list(server, client);
3648 if (!silc_idlist_del_client(server->local_list, client))
3649 silc_idlist_del_client(server->global_list, client);
3650 client = detached_client;
3652 /* If the ID is not based in our ID then change it */
3653 if (!SILC_ID_COMPARE(client->id, server->id, server->id->ip.data_len)) {
3654 silc_free(client_id);
3655 while (!silc_id_create_client_id(server, server->id, server->rng,
3656 server->md5hash, client->nickname,
3660 silc_server_disconnect_remote(server, sock,
3661 SILC_STATUS_ERR_BAD_NICKNAME, NULL);
3662 if (sock->user_data)
3663 silc_server_free_sock_user_data(server, sock, NULL);
3666 snprintf(&client->nickname[strlen(client->nickname) - 1], 1,
3673 /* Notify about Client ID change, nickname doesn't actually change. */
3674 silc_server_send_notify_nick_change(server, SILC_PRIMARY_ROUTE(server),
3675 SILC_BROADCAST(server),
3676 client->id, client_id,
3680 /* Resolve users on those channels that client has joined but we
3681 haven't resolved user list yet. */
3682 if (server->server_type == SILC_SERVER && !server->standalone) {
3683 silc_hash_table_list(client->channels, &htl);
3684 while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
3685 channel = chl->channel;
3686 SILC_LOG_DEBUG(("Resolving users for %s channel",
3687 channel->channel_name));
3688 if (channel->disabled || !channel->users_resolved) {
3689 silc_server_send_command(server, SILC_PRIMARY_ROUTE(server),
3690 SILC_COMMAND_USERS, ++server->cmd_ident,
3691 1, 2, channel->channel_name,
3692 strlen(channel->channel_name));
3695 silc_hash_table_list_reset(&htl);
3698 /* Send the new client ID to the client. After this client may start
3699 receiving other packets, and may start sending packets too. */
3700 silc_server_send_new_id(server, sock, FALSE, client_id, SILC_ID_CLIENT,
3701 silc_id_get_len(client_id, SILC_ID_CLIENT));
3704 /* Send NICK change notify to channels as well. */
3705 SilcBuffer oidp, nidp;
3706 oidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
3707 nidp = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
3708 silc_server_send_notify_on_channels(server, NULL, client,
3709 SILC_NOTIFY_TYPE_NICK_CHANGE, 3,
3710 oidp->data, oidp->len,
3711 nidp->data, nidp->len,
3713 strlen(client->nickname));
3714 silc_buffer_free(oidp);
3715 silc_buffer_free(nidp);
3718 /* Add the client again to the ID cache to get it to correct list */
3719 if (!silc_idcache_del_by_context(server->local_list->clients, client))
3720 silc_idcache_del_by_context(server->global_list->clients, client);
3721 silc_free(client->id);
3722 client->id = client_id;
3724 silc_idcache_add(server->local_list->clients, client->nickname,
3725 client->id, client, 0, NULL);
3727 /* Send some nice info to the client */
3728 silc_server_send_connect_notifys(server, sock, client);
3730 /* Send all channel keys of channels the client has joined */
3731 silc_hash_table_list(client->channels, &htl);
3732 while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
3733 bool created = FALSE;
3734 channel = chl->channel;
3736 if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY)
3739 /* If we don't have channel key, then create one */
3740 if (!channel->channel_key) {
3741 if (!silc_server_create_channel_key(server, channel, 0))
3746 id_string = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
3748 silc_channel_key_payload_encode(silc_id_get_len(channel->id,
3751 strlen(channel->channel_key->
3753 channel->channel_key->cipher->name,
3754 channel->key_len / 8, channel->key);
3755 silc_free(id_string);
3757 /* Send the key packet to client */
3758 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
3759 keyp->data, keyp->len, FALSE);
3761 if (created && server->server_type == SILC_SERVER)
3762 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3763 SILC_PACKET_CHANNEL_KEY, 0,
3764 keyp->data, keyp->len, FALSE);
3766 silc_buffer_free(keyp);
3768 silc_hash_table_list_reset(&htl);
3770 } else if (sock->type != SILC_SOCKET_TYPE_CLIENT) {
3771 /* Server or router sent this to us to notify that that a client has
3773 SilcServerEntry server_entry;
3774 SilcServerID *server_id;
3777 SILC_LOG_DEBUG(("Malformed resuming packet"));
3781 /* Get entry to the client, and resolve it if we don't have it. */
3782 detached_client = silc_idlist_find_client_by_id(server->local_list,
3785 if (!detached_client) {
3786 detached_client = silc_idlist_find_client_by_id(server->global_list,
3789 if (!detached_client) {
3790 SILC_LOG_DEBUG(("Resuming client is unknown"));
3791 silc_free(client_id);
3796 /* Check that the client has not been resumed already because it is
3797 protocol error to attempt to resume more than once. The client
3798 will be killed if this protocol error occurs. */
3799 if (detached_client->data.status & SILC_IDLIST_STATUS_RESUMED &&
3800 !(detached_client->mode & SILC_UMODE_DETACHED)) {
3801 /* The client is clearly attempting to resume more than once and
3802 perhaps playing around by resuming from several different places
3803 at the same time. */
3804 SILC_LOG_DEBUG(("Attempting to re-resume client, killing both"));
3805 silc_server_kill_client(server, detached_client, NULL,
3806 server->id, SILC_ID_SERVER);
3807 silc_free(client_id);
3811 /* Check whether client is detached at all */
3812 if (!(detached_client->mode & SILC_UMODE_DETACHED)) {
3813 SILC_LOG_DEBUG(("Client is not detached"));
3814 silc_free(client_id);
3818 SILC_LOG_DEBUG(("Resuming detached client"));
3820 /* If the sender of this packet is server and we are router we need to
3821 broadcast this packet to other routers in the network. */
3822 if (server->server_type == SILC_ROUTER &&
3823 sock->type == SILC_SOCKET_TYPE_SERVER &&
3824 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
3825 SILC_LOG_DEBUG(("Broadcasting received Resume Client packet"));
3826 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3828 packet->flags | SILC_PACKET_FLAG_BROADCAST,
3829 buffer->data, buffer->len, FALSE);
3830 silc_server_backup_send(server, sock->user_data,
3831 packet->type, packet->flags,
3832 packet->buffer->data, packet->buffer->len,
3836 /* Client is detached, and now it is resumed. Remove the detached
3837 mode and mark that it is resumed. */
3838 detached_client->mode &= ~SILC_UMODE_DETACHED;
3839 detached_client->data.status |= SILC_IDLIST_STATUS_RESUMED;
3840 detached_client->data.status &= ~SILC_IDLIST_STATUS_LOCAL;
3841 id_cache->expire = 0;
3843 /* Update channel information regarding global clients on channel. */
3844 if (server->server_type == SILC_SERVER) {
3845 silc_hash_table_list(detached_client->channels, &htl);
3846 while (silc_hash_table_get(&htl, NULL, (void **)&chl))
3847 chl->channel->global_users =
3848 silc_server_channel_has_global(chl->channel);
3849 silc_hash_table_list_reset(&htl);
3852 silc_schedule_task_del_by_context(server->schedule, detached_client);
3854 /* Get the new owner of the resumed client */
3855 server_id = silc_id_str2id(packet->src_id, packet->src_id_len,
3856 packet->src_id_type);
3858 silc_free(client_id);
3862 /* Get server entry */
3863 server_entry = silc_idlist_find_server_by_id(server->global_list,
3864 server_id, TRUE, NULL);
3866 if (!server_entry) {
3867 server_entry = silc_idlist_find_server_by_id(server->local_list,
3868 server_id, TRUE, NULL);
3870 if (!server_entry) {
3871 silc_free(server_id);
3872 silc_free(client_id);
3877 if (server->server_type == SILC_ROUTER &&
3878 sock->type == SILC_SOCKET_TYPE_ROUTER &&
3879 server_entry->server_type == SILC_ROUTER)
3882 /* Change the client to correct list. */
3883 if (!silc_idcache_del_by_context(server->local_list->clients,
3885 silc_idcache_del_by_context(server->global_list->clients,
3887 silc_idcache_add(local && server->server_type == SILC_ROUTER ?
3888 server->local_list->clients :
3889 server->global_list->clients,
3890 detached_client->nickname,
3891 detached_client->id, detached_client, FALSE, NULL);
3893 /* Change the owner of the client */
3894 detached_client->router = server_entry;
3896 silc_free(server_id);
3899 silc_free(client_id);