5 Author: Pekka Riikonen <priikone@silcnet.org>
7 Copyright (C) 1997 - 2002 Pekka Riikonen
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
21 * Server packet routines to handle received packets.
25 #include "serverincludes.h"
26 #include "server_internal.h"
28 /* Received notify packet. Server can receive notify packets from router.
29 Server then relays the notify messages to clients if needed. */
31 void silc_server_notify(SilcServer server,
32 SilcSocketConnection sock,
33 SilcPacketContext *packet)
35 SilcNotifyPayload payload;
37 SilcArgumentPayload args;
38 SilcChannelID *channel_id = NULL, *channel_id2;
39 SilcClientID *client_id, *client_id2;
40 SilcServerID *server_id;
42 SilcChannelEntry channel = NULL;
43 SilcClientEntry client = NULL, client2 = NULL;
44 SilcServerEntry server_entry = NULL;
45 SilcChannelClientEntry chl;
46 SilcIDCacheEntry cache = NULL;
47 SilcHashTableList htl;
53 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
54 packet->src_id_type != SILC_ID_SERVER || !packet->dst_id) {
55 SILC_LOG_DEBUG(("Bad notify packet received"));
59 /* If the packet is destined directly to a client then relay the packet
60 before processing it. */
61 if (packet->dst_id_type == SILC_ID_CLIENT) {
63 SilcSocketConnection dst_sock;
65 /* Get the route to the client */
66 dst_sock = silc_server_get_client_route(server, packet->dst_id,
67 packet->dst_id_len, NULL,
70 /* Relay the packet */
71 silc_server_relay_packet(server, dst_sock, idata->send_key,
72 idata->hmac_send, idata->psn_send++,
76 /* Parse the Notify Payload */
77 payload = silc_notify_payload_parse(packet->buffer->data,
82 /* If we are router and this packet is not already broadcast packet
83 we will broadcast it. The sending socket really cannot be router or
84 the router is buggy. If this packet is coming from router then it must
85 have the broadcast flag set already and we won't do anything. */
86 if (server->server_type == SILC_ROUTER &&
87 sock->type == SILC_SOCKET_TYPE_SERVER &&
88 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
89 SILC_LOG_DEBUG(("Broadcasting received Notify packet"));
90 if (packet->dst_id_type == SILC_ID_CHANNEL) {
91 /* Packet is destined to channel */
92 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
97 silc_server_packet_send_dest(server, SILC_PRIMARY_ROUTE(server),
98 packet->type, packet->flags |
99 SILC_PACKET_FLAG_BROADCAST,
100 channel_id, SILC_ID_CHANNEL,
101 packet->buffer->data,
102 packet->buffer->len, FALSE);
103 silc_server_backup_send_dest(server, sock->user_data,
104 packet->type, packet->flags,
105 channel_id, SILC_ID_CHANNEL,
106 packet->buffer->data, packet->buffer->len,
109 /* Packet is destined to client or server */
110 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
112 packet->flags | SILC_PACKET_FLAG_BROADCAST,
113 packet->buffer->data, packet->buffer->len,
115 silc_server_backup_send(server, sock->user_data,
116 packet->type, packet->flags,
117 packet->buffer->data, packet->buffer->len,
122 type = silc_notify_get_type(payload);
123 args = silc_notify_get_args(payload);
128 case SILC_NOTIFY_TYPE_JOIN:
130 * Distribute the notify to local clients on the channel
132 SILC_LOG_DEBUG(("JOIN notify"));
135 silc_free(channel_id);
138 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
141 channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
145 /* Get channel entry */
146 channel = silc_idlist_find_channel_by_id(server->global_list,
149 channel = silc_idlist_find_channel_by_id(server->local_list,
152 SILC_LOG_DEBUG(("Notify for unknown channel"));
153 silc_free(channel_id);
157 silc_free(channel_id);
160 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
163 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
167 /* If the the client is not in local list we check global list (ie. the
168 channel will be global channel) and if it does not exist then create
169 entry for the client. */
170 client = silc_idlist_find_client_by_id(server->global_list,
171 client_id, server->server_type,
174 client = silc_idlist_find_client_by_id(server->local_list,
175 client_id, server->server_type,
178 /* If router did not find the client the it is bogus */
179 if (server->server_type != SILC_SERVER) {
180 silc_free(client_id);
185 silc_idlist_add_client(server->global_list, NULL, NULL, NULL,
186 silc_id_dup(client_id, SILC_ID_CLIENT),
187 sock->user_data, NULL, 0);
189 SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
190 silc_free(client_id);
194 client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
197 silc_free(client_id);
199 /* Do not process the notify if the client is not registered */
200 if (!(client->data.status & SILC_IDLIST_STATUS_REGISTERED))
203 /* Do not add client to channel if it is there already */
204 if (silc_server_client_on_channel(client, channel, NULL)) {
205 SILC_LOG_DEBUG(("Client already on channel %s",
206 channel->channel_name));
210 /* Send to channel */
211 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
212 FALSE, packet->buffer->data,
213 packet->buffer->len, FALSE);
215 if (server->server_type != SILC_ROUTER &&
216 sock->type == SILC_SOCKET_TYPE_ROUTER)
217 /* The channel is global now */
218 channel->global_users = TRUE;
220 SILC_LOG_DEBUG(("Joining to channel %s", channel->channel_name));
222 /* JOIN the global client to the channel (local clients (if router
223 created the channel) is joined in the pending JOIN command). */
224 chl = silc_calloc(1, sizeof(*chl));
225 chl->client = client;
226 chl->channel = channel;
228 if (server->server_type != SILC_ROUTER ||
229 sock->type == SILC_SOCKET_TYPE_ROUTER) {
230 /* If this is the first one on the channel then it is the founder of
231 the channel. This is done on normal server and on router if this
232 notify is coming from router */
233 if (!silc_hash_table_count(channel->user_list)) {
234 SILC_LOG_DEBUG(("Client %s is founder on channel",
235 silc_id_render(chl->client->id, SILC_ID_CLIENT)));
236 chl->mode = (SILC_CHANNEL_UMODE_CHANOP | SILC_CHANNEL_UMODE_CHANFO);
240 silc_hash_table_add(channel->user_list, client, chl);
241 silc_hash_table_add(client->channels, channel, chl);
242 channel->user_count++;
243 channel->disabled = FALSE;
245 /* Make sure we don't expire clients that are on channel */
249 /* Update statistics */
250 if (server->server_type == SILC_ROUTER) {
251 if (sock->type != SILC_SOCKET_TYPE_ROUTER)
252 server->stat.cell_chanclients++;
253 server->stat.chanclients++;
258 case SILC_NOTIFY_TYPE_LEAVE:
260 * Distribute the notify to local clients on the channel
262 SILC_LOG_DEBUG(("LEAVE notify"));
265 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
266 packet->dst_id_type);
271 /* Get channel entry */
272 channel = silc_idlist_find_channel_by_id(server->global_list,
275 channel = silc_idlist_find_channel_by_id(server->local_list,
278 SILC_LOG_DEBUG(("Notify for unknown channel"));
279 silc_free(channel_id);
285 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
287 silc_free(channel_id);
290 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
292 silc_free(channel_id);
296 /* Get client entry */
297 client = silc_idlist_find_client_by_id(server->global_list,
298 client_id, TRUE, NULL);
300 client = silc_idlist_find_client_by_id(server->local_list,
301 client_id, TRUE, NULL);
303 silc_free(client_id);
304 silc_free(channel_id);
308 silc_free(client_id);
309 silc_free(channel_id);
311 /* Check if on channel */
312 if (!silc_server_client_on_channel(client, channel, NULL))
315 /* Send the leave notify to channel */
316 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
317 FALSE, packet->buffer->data,
318 packet->buffer->len, FALSE);
320 /* Remove the user from channel */
321 silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
324 case SILC_NOTIFY_TYPE_SIGNOFF:
326 * Distribute the notify to local clients on the channel
328 SILC_LOG_DEBUG(("SIGNOFF notify"));
331 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
334 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
338 /* Get client entry */
339 client = silc_idlist_find_client_by_id(server->global_list,
340 client_id, TRUE, &cache);
342 client = silc_idlist_find_client_by_id(server->local_list,
343 client_id, TRUE, &cache);
345 silc_free(client_id);
349 silc_free(client_id);
351 /* Get signoff message */
352 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
356 /* Update statistics */
357 server->stat.clients--;
358 if (server->stat.cell_clients)
359 server->stat.cell_clients--;
360 SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
361 SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
362 silc_schedule_task_del_by_context(server->schedule, client);
364 /* Remove the client from all channels. */
365 silc_server_remove_from_channels(server, NULL, client, TRUE,
368 /* Check if anyone is watching this nickname */
369 if (server->server_type == SILC_ROUTER)
370 silc_server_check_watcher_list(server, client, NULL,
371 SILC_NOTIFY_TYPE_SIGNOFF);
373 /* Remove this client from watcher list if it is */
374 silc_server_del_from_watcher_list(server, client);
376 client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
377 cache->expire = SILC_ID_CACHE_EXPIRE_DEF;
380 case SILC_NOTIFY_TYPE_TOPIC_SET:
382 * Distribute the notify to local clients on the channel
385 SILC_LOG_DEBUG(("TOPIC SET notify"));
388 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
391 client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
395 /* Get client entry */
396 if (id_type == SILC_ID_CLIENT) {
397 client = silc_idlist_find_client_by_id(server->global_list,
398 client_id, TRUE, &cache);
400 client = silc_idlist_find_client_by_id(server->local_list,
401 client_id, TRUE, &cache);
403 silc_free(client_id);
407 silc_free(client_id);
411 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
413 silc_free(channel_id);
418 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
419 packet->dst_id_type);
424 /* Get channel entry */
425 channel = silc_idlist_find_channel_by_id(server->global_list,
428 channel = silc_idlist_find_channel_by_id(server->local_list,
431 SILC_LOG_DEBUG(("Notify for unknown channel"));
432 silc_free(channel_id);
436 silc_free(channel_id);
438 if (channel->topic && !strcmp(channel->topic, tmp)) {
439 SILC_LOG_DEBUG(("Topic is already set and same"));
444 /* Get user's channel entry and check that topic set is allowed. */
445 if (!silc_server_client_on_channel(client, channel, &chl))
447 if (channel->mode & SILC_CHANNEL_MODE_TOPIC &&
448 !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
449 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
450 SILC_LOG_DEBUG(("Topic change is not allowed"));
455 /* Change the topic */
456 silc_free(channel->topic);
457 channel->topic = strdup(tmp);
459 /* Send the same notify to the channel */
460 silc_server_packet_send_to_channel(server, NULL, channel, packet->type,
461 FALSE, packet->buffer->data,
462 packet->buffer->len, FALSE);
465 case SILC_NOTIFY_TYPE_NICK_CHANGE:
468 * Distribute the notify to local clients on the channel
470 unsigned char *id, *id2;
472 SilcUInt32 nickname_len;
474 SILC_LOG_DEBUG(("NICK CHANGE notify"));
476 /* Get old client ID */
477 id = silc_argument_get_arg_type(args, 1, &tmp_len);
480 client_id = silc_id_payload_parse_id(id, tmp_len, NULL);
484 /* Get new client ID */
485 id2 = silc_argument_get_arg_type(args, 2, &tmp_len);
488 client_id2 = silc_id_payload_parse_id(id2, tmp_len, NULL);
490 silc_free(client_id);
494 SILC_LOG_DEBUG(("Old Client ID id(%s)",
495 silc_id_render(client_id, SILC_ID_CLIENT)));
496 SILC_LOG_DEBUG(("New Client ID id(%s)",
497 silc_id_render(client_id2, SILC_ID_CLIENT)));
499 /* From protocol version 1.1 we also get the new nickname */
500 nickname = silc_argument_get_arg_type(args, 3, &nickname_len);;
502 /* Replace the Client ID */
503 client = silc_idlist_replace_client_id(server,
504 server->global_list, client_id,
505 client_id2, nickname);
507 client = silc_idlist_replace_client_id(server,
508 server->local_list, client_id,
509 client_id2, nickname);
512 /* Send the NICK_CHANGE notify type to local clients on the channels
513 this client is joined to. */
514 silc_server_send_notify_on_channels(server, client, client,
515 SILC_NOTIFY_TYPE_NICK_CHANGE, 3,
516 id, tmp_len, id2, tmp_len,
521 silc_free(client_id);
523 silc_free(client_id2);
527 case SILC_NOTIFY_TYPE_CMODE_CHANGE:
529 * Distribute the notify to local clients on the channel
532 SILC_LOG_DEBUG(("CMODE CHANGE notify"));
535 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
538 client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
542 /* Get client entry */
543 if (id_type == SILC_ID_CLIENT) {
544 client = silc_idlist_find_client_by_id(server->global_list,
545 client_id, TRUE, &cache);
547 client = silc_idlist_find_client_by_id(server->local_list,
548 client_id, TRUE, &cache);
550 silc_free(client_id);
555 silc_free(client_id);
558 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
559 packet->dst_id_type);
564 /* Get channel entry */
565 channel = silc_idlist_find_channel_by_id(server->global_list,
568 channel = silc_idlist_find_channel_by_id(server->local_list,
571 SILC_LOG_DEBUG(("Notify for unknown channel"));
572 silc_free(channel_id);
576 silc_free(channel_id);
579 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
582 SILC_GET32_MSB(mode, tmp);
584 /* Check if mode changed */
585 if (channel->mode == mode) {
586 SILC_LOG_DEBUG(("Mode is changed already"));
588 /* If this mode change has founder mode then we'll enforce the
589 change so that the server gets the real founder public key */
590 if (server->server_type != SILC_SERVER &&
591 sock != SILC_PRIMARY_ROUTE(server) &&
592 mode & SILC_CHANNEL_MODE_FOUNDER_AUTH && channel->founder_key) {
593 SILC_LOG_DEBUG(("Sending founder public key to server"));
594 silc_server_send_notify_cmode(server, sock, FALSE, channel,
595 channel->mode, server->id,
596 SILC_ID_SERVER, channel->cipher,
599 channel->founder_key);
602 /* If we received same mode from our primary check whether founder
603 mode and key in the notify is set. We update the founder key
604 here since we may have wrong one */
605 if (server->server_type == SILC_SERVER &&
606 sock == SILC_PRIMARY_ROUTE(server) &&
607 mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
608 SILC_LOG_DEBUG(("Founder public key received from router"));
609 tmp = silc_argument_get_arg_type(args, 6, &tmp_len);
613 if (channel->founder_key)
614 silc_pkcs_public_key_free(channel->founder_key);
615 channel->founder_key = NULL;
616 silc_pkcs_public_key_payload_decode(tmp, tmp_len,
617 &channel->founder_key);
623 /* Get user's channel entry and check that mode change is allowed */
625 if (!silc_server_client_on_channel(client, channel, &chl))
627 if (!silc_server_check_cmode_rights(server, channel, chl, mode)) {
628 SILC_LOG_DEBUG(("CMODE change is not allowed"));
629 silc_server_send_notify_cmode(server, sock, FALSE, channel,
630 channel->mode, server->id,
631 SILC_ID_SERVER, channel->cipher,
634 channel->founder_key);
638 /* Assure that server is not removing founder mode from us */
639 if (server->server_type == SILC_ROUTER &&
640 sock != SILC_PRIMARY_ROUTE(server) &&
641 channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH &&
642 !(mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
643 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
644 silc_server_send_notify_cmode(server, sock, FALSE, channel,
645 channel->mode, server->id,
646 SILC_ID_SERVER, channel->cipher,
649 channel->founder_key);
653 /* If server is adding founder mode, check whether there is founder
654 on channel already and is not from this server */
655 if (server->server_type == SILC_ROUTER &&
656 sock != SILC_PRIMARY_ROUTE(server) &&
657 mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
658 silc_hash_table_list(channel->user_list, &htl);
659 while (silc_hash_table_get(&htl, NULL, (void *)&chl))
660 if (chl->mode & SILC_CHANNEL_UMODE_CHANFO &&
661 chl->client->router != sock->user_data) {
662 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
663 silc_server_send_notify_cmode(server, sock, FALSE, channel,
664 channel->mode, server->id,
665 SILC_ID_SERVER, channel->cipher,
668 channel->founder_key);
669 silc_hash_table_list_reset(&htl);
672 silc_hash_table_list_reset(&htl);
676 /* If the channel had private keys set and the mode was removed then
677 we must re-generate and re-distribute a new channel key */
678 if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY &&
679 !(mode & SILC_CHANNEL_MODE_PRIVKEY)) {
680 /* Re-generate channel key */
681 if (!silc_server_create_channel_key(server, channel, 0))
684 /* Send the channel key. This sends it to our local clients and if
685 we are normal server to our router as well. */
686 silc_server_send_channel_key(server, NULL, channel,
687 server->server_type == SILC_ROUTER ?
688 FALSE : !server->standalone);
692 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
694 unsigned char hash[32];
697 silc_hmac_free(channel->hmac);
698 if (!silc_hmac_alloc(tmp, NULL, &channel->hmac))
701 /* Set the HMAC key out of current channel key. The client must do
703 silc_hash_make(silc_hmac_get_hash(channel->hmac), channel->key,
704 channel->key_len / 8, hash);
705 silc_hmac_set_key(channel->hmac, hash,
706 silc_hash_len(silc_hmac_get_hash(channel->hmac)));
707 memset(hash, 0, sizeof(hash));
710 /* Get the passphrase */
711 tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
713 silc_free(channel->passphrase);
714 channel->passphrase = silc_memdup(tmp, tmp_len);
717 /* Get founder public key */
718 tmp = silc_argument_get_arg_type(args, 6, &tmp_len);
719 if (tmp && mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
720 if (channel->founder_key)
721 silc_pkcs_public_key_free(channel->founder_key);
722 channel->founder_key = NULL;
723 silc_pkcs_public_key_payload_decode(tmp, tmp_len, &channel->founder_key);
725 if (!channel->founder_key ||
726 (client && client->data.public_key &&
727 server->server_type == SILC_ROUTER &&
728 !silc_pkcs_public_key_compare(channel->founder_key,
729 client->data.public_key))) {
730 /* A really buggy server isn't checking public keys correctly.
731 It's not possible that the mode setter and founder wouldn't
732 have same public key. */
733 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
735 mode &= ~SILC_CHANNEL_MODE_FOUNDER_AUTH;
736 silc_server_send_notify_cmode(server, sock, FALSE, channel,
737 mode, server->id, SILC_ID_SERVER,
740 channel->passphrase, NULL);
741 if (channel->founder_key)
742 silc_pkcs_public_key_free(channel->founder_key);
743 channel->founder_key = NULL;
744 } else if (client && !client->data.public_key) {
745 client->data.public_key =
746 silc_pkcs_public_key_copy(channel->founder_key);
750 if (mode & SILC_CHANNEL_MODE_FOUNDER_AUTH && !channel->founder_key &&
751 server->server_type == SILC_ROUTER) {
752 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
753 mode &= ~SILC_CHANNEL_MODE_FOUNDER_AUTH;
754 silc_server_send_notify_cmode(server, sock, FALSE, channel,
755 mode, server->id, SILC_ID_SERVER,
758 channel->passphrase, NULL);
761 /* Send the same notify to the channel */
762 silc_server_packet_send_to_channel(server, NULL, channel, packet->type,
763 FALSE, packet->buffer->data,
764 packet->buffer->len, FALSE);
767 channel->mode = mode;
769 if (!(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) &&
770 channel->founder_key) {
771 silc_pkcs_public_key_free(channel->founder_key);
772 channel->founder_key = NULL;
777 case SILC_NOTIFY_TYPE_CUMODE_CHANGE:
780 * Distribute the notify to local clients on the channel
782 SilcChannelClientEntry chl2 = NULL;
783 bool notify_sent = FALSE;
785 SILC_LOG_DEBUG(("CUMODE CHANGE notify"));
788 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
791 client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
795 /* Get client entry */
796 if (id_type == SILC_ID_CLIENT) {
797 client = silc_idlist_find_client_by_id(server->global_list,
798 client_id, TRUE, &cache);
800 client = silc_idlist_find_client_by_id(server->local_list,
801 client_id, TRUE, &cache);
803 silc_free(client_id);
808 silc_free(client_id);
811 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
812 packet->dst_id_type);
817 /* Get channel entry */
818 channel = silc_idlist_find_channel_by_id(server->global_list,
821 channel = silc_idlist_find_channel_by_id(server->local_list,
824 SILC_LOG_DEBUG(("Notify for unknown channel"));
825 silc_free(channel_id);
831 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
833 silc_free(channel_id);
837 SILC_GET32_MSB(mode, tmp);
839 /* Get target client */
840 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
843 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
847 /* Get client entry */
848 client2 = silc_idlist_find_client_by_id(server->global_list,
849 client_id, TRUE, NULL);
851 client2 = silc_idlist_find_client_by_id(server->local_list,
852 client_id, TRUE, NULL);
854 silc_free(client_id);
858 silc_free(client_id);
861 /* Check that sender is on channel */
862 if (!silc_server_client_on_channel(client, channel, &chl))
865 if (client != client2 && server->server_type == SILC_ROUTER) {
866 /* Sender must be operator */
867 if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
868 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
869 SILC_LOG_DEBUG(("CUMODE change is not allowed"));
873 if (!silc_server_client_on_channel(client2, channel, &chl))
876 /* If target is founder mode change is not allowed. */
877 if (chl->mode & SILC_CHANNEL_UMODE_CHANFO) {
878 SILC_LOG_DEBUG(("CUMODE change is not allowed"));
884 /* Get target channel user entry */
885 if (!silc_server_client_on_channel(client2, channel, &chl))
888 if (server->server_type == SILC_SERVER && chl->mode == mode) {
889 SILC_LOG_DEBUG(("Mode is changed already"));
893 if (mode & SILC_CHANNEL_UMODE_CHANFO &&
894 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO) &&
895 server->server_type == SILC_ROUTER &&
896 sock != SILC_PRIMARY_ROUTE(server)) {
897 SilcPublicKey founder_key = NULL;
899 /* If channel doesn't have founder auth mode then it's impossible
900 that someone would be getting founder rights with CUMODE command.
901 In that case there already either is founder or there isn't
902 founder at all on the channel. */
903 if (client && !(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
904 /* Force the mode to not have founder mode */
905 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
906 silc_server_force_cumode_change(server, sock, channel, chl, mode);
911 /* Get the founder of the channel and if found then this client
912 cannot be the founder since there already is one. */
913 silc_hash_table_list(channel->user_list, &htl);
914 while (silc_hash_table_get(&htl, NULL, (void *)&chl2))
915 if (chl2->mode & SILC_CHANNEL_UMODE_CHANFO) {
916 /* If the founder on the channel is not the one whom has set
917 the founder mode, then it's possible that this CUMODE_CHANGE
918 is correct. Due to netsplits it's possible that this
919 situation happens. */
920 if (!(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) ||
921 (channel->founder_key && chl2->client->data.public_key &&
922 silc_pkcs_public_key_compare(
923 channel->founder_key,
924 chl2->client->data.public_key))) {
925 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
926 silc_server_force_cumode_change(server, sock, channel,
932 silc_hash_table_list_reset(&htl);
933 if (!(mode & SILC_CHANNEL_UMODE_CHANFO))
936 /* Founder not found of the channel. Since the founder auth mode
937 is set on the channel now check whether this is the client that
938 originally set the mode. */
940 if (channel->founder_key) {
941 /* Get public key that must be present in notify */
942 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
943 if (!tmp || !silc_pkcs_public_key_payload_decode(tmp, tmp_len,
945 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
946 silc_server_force_cumode_change(server, sock, channel, chl, mode);
951 /* Now match the public key we have cached and public key sent.
953 #if 0 /* The key may be other than the client's in 1.2 */
954 if (client && client->data.public_key &&
955 !silc_pkcs_public_key_compare(channel->founder_key,
956 client->data.public_key)) {
957 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
958 silc_server_force_cumode_change(server, sock, channel, chl, mode);
963 if (!silc_pkcs_public_key_compare(channel->founder_key,
965 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
966 silc_server_force_cumode_change(server, sock, channel, chl, mode);
972 /* There cannot be anyone else as founder on the channel now. This
973 client is definitely the founder due to this authentication */
974 silc_hash_table_list(channel->user_list, &htl);
975 while (silc_hash_table_get(&htl, NULL, (void *)&chl2))
976 if (chl2->mode & SILC_CHANNEL_UMODE_CHANFO) {
977 chl2->mode &= ~SILC_CHANNEL_UMODE_CHANFO;
978 silc_server_force_cumode_change(server, NULL, channel, chl2,
982 silc_hash_table_list_reset(&htl);
985 silc_pkcs_public_key_free(founder_key);
988 if (server->server_type != SILC_SERVER && chl->mode == mode) {
989 SILC_LOG_DEBUG(("Mode is changed already"));
993 SILC_LOG_DEBUG(("Changing %s channel user mode",
994 chl->client->nickname ? chl->client->nickname :
995 (unsigned char *)""));
997 /* Change the mode */
1000 /* Send the same notify to the channel */
1002 silc_server_packet_send_to_channel(server, NULL, channel,
1004 FALSE, packet->buffer->data,
1005 packet->buffer->len, FALSE);
1007 silc_free(channel_id);
1011 case SILC_NOTIFY_TYPE_INVITE:
1013 if (packet->dst_id_type == SILC_ID_CLIENT)
1016 SILC_LOG_DEBUG(("INVITE notify"));
1018 /* Get Channel ID */
1019 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1022 channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1026 /* Get channel entry */
1027 channel = silc_idlist_find_channel_by_id(server->global_list,
1030 channel = silc_idlist_find_channel_by_id(server->local_list,
1033 SILC_LOG_DEBUG(("Notify for unknown channel"));
1034 silc_free(channel_id);
1038 silc_free(channel_id);
1041 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1044 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1048 /* Get client entry */
1049 client = silc_idlist_find_client_by_id(server->global_list,
1050 client_id, TRUE, &cache);
1052 client = silc_idlist_find_client_by_id(server->local_list,
1053 client_id, TRUE, &cache);
1055 silc_free(client_id);
1059 silc_free(client_id);
1061 /* Get user's channel entry and check that inviting is allowed. */
1062 if (!silc_server_client_on_channel(client, channel, &chl))
1064 if (channel->mode & SILC_CHANNEL_MODE_INVITE &&
1065 !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
1066 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
1067 SILC_LOG_DEBUG(("Inviting is not allowed"));
1071 /* Get the invite action */
1072 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
1073 if (tmp && tmp_len == 1) {
1074 SilcUInt8 action = (SilcUInt8)tmp[0];
1075 SilcUInt16 iargc = 0;
1076 SilcArgumentPayload iargs;
1078 /* Get invite list */
1079 tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
1080 if (!tmp || tmp_len < 2)
1083 /* Parse the arguments to see they are constructed correctly */
1084 SILC_GET16_MSB(iargc, tmp);
1085 iargs = silc_argument_payload_parse(tmp + 2, tmp_len - 2, iargc);
1089 if (action == 0 && !channel->invite_list)
1090 channel->invite_list =
1091 silc_hash_table_alloc(0, silc_hash_ptr,
1093 silc_server_inviteban_destruct, channel, TRUE);
1095 /* Proces the invite action */
1096 silc_server_inviteban_process(server, channel->invite_list, action,
1098 silc_argument_payload_free(iargs);
1103 case SILC_NOTIFY_TYPE_CHANNEL_CHANGE:
1105 * Distribute to the local clients on the channel and change the
1109 SILC_LOG_DEBUG(("CHANNEL CHANGE"));
1111 if (sock->type != SILC_SOCKET_TYPE_ROUTER)
1114 /* Get the old Channel ID */
1115 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1118 channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1122 /* Get the channel entry */
1123 channel = silc_idlist_find_channel_by_id(server->local_list,
1126 channel = silc_idlist_find_channel_by_id(server->global_list,
1129 SILC_LOG_DEBUG(("Notify for unknown channel"));
1130 silc_free(channel_id);
1135 /* Send the notify to the channel */
1136 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
1137 FALSE, packet->buffer->data,
1138 packet->buffer->len, FALSE);
1140 /* Get the new Channel ID */
1141 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1144 channel_id2 = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1148 SILC_LOG_DEBUG(("Old Channel ID id(%s)",
1149 silc_id_render(channel_id, SILC_ID_CHANNEL)));
1150 SILC_LOG_DEBUG(("New Channel ID id(%s)",
1151 silc_id_render(channel_id2, SILC_ID_CHANNEL)));
1153 /* Replace the Channel ID */
1154 if (!silc_idlist_replace_channel_id(server->local_list, channel_id,
1156 if (!silc_idlist_replace_channel_id(server->global_list, channel_id,
1158 silc_free(channel_id2);
1163 SilcBuffer modes = NULL, users = NULL, users_modes = NULL;
1165 /* Re-announce this channel which ID was changed. */
1166 silc_server_send_new_channel(server, sock, FALSE, channel->channel_name,
1168 silc_id_get_len(channel->id,
1172 /* Re-announce our clients on the channel as the ID has changed now */
1173 silc_server_announce_get_channel_users(server, channel, &modes, &users,
1176 silc_buffer_push(users, users->data - users->head);
1177 silc_server_packet_send(server, sock,
1178 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1179 users->data, users->len, FALSE);
1180 silc_buffer_free(users);
1183 silc_buffer_push(modes, modes->data - modes->head);
1184 silc_server_packet_send_dest(server, sock,
1185 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1186 channel->id, SILC_ID_CHANNEL,
1187 modes->data, modes->len, FALSE);
1188 silc_buffer_free(modes);
1191 silc_buffer_push(users_modes, users_modes->data - users_modes->head);
1192 silc_server_packet_send_dest(server, sock,
1193 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1194 channel->id, SILC_ID_CHANNEL,
1196 users_modes->len, FALSE);
1197 silc_buffer_free(users_modes);
1200 /* Re-announce channel's topic */
1201 if (channel->topic) {
1202 silc_server_send_notify_topic_set(server, sock,
1203 server->server_type == SILC_ROUTER ?
1204 TRUE : FALSE, channel,
1205 server->id, SILC_ID_SERVER,
1210 silc_free(channel_id);
1214 case SILC_NOTIFY_TYPE_SERVER_SIGNOFF:
1216 * Remove the server entry and all clients that this server owns.
1219 SILC_LOG_DEBUG(("SERVER SIGNOFF notify"));
1222 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1225 server_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1229 /* If the ID is mine, this notify is not allowed. */
1230 if (SILC_ID_SERVER_COMPARE(server_id, server->id)) {
1231 SILC_LOG_DEBUG(("Ignoring my own ID for SERVER_SIGNOFF"));
1235 /* Get server entry */
1236 server_entry = silc_idlist_find_server_by_id(server->global_list,
1237 server_id, TRUE, NULL);
1239 if (!server_entry) {
1240 server_entry = silc_idlist_find_server_by_id(server->local_list,
1241 server_id, TRUE, NULL);
1243 if (!server_entry) {
1244 /* If we are normal server then we might not have the server. Check
1245 whether router was kind enough to send the list of all clients
1246 that actually was to be removed. Remove them if the list is
1248 if (server->server_type != SILC_ROUTER &&
1249 silc_argument_get_arg_num(args) > 1) {
1252 for (i = 1; i < silc_argument_get_arg_num(args); i++) {
1254 tmp = silc_argument_get_arg_type(args, i + 1, &tmp_len);
1257 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1261 /* Get client entry */
1262 client = silc_idlist_find_client_by_id(server->global_list,
1263 client_id, TRUE, &cache);
1266 client = silc_idlist_find_client_by_id(server->local_list,
1267 client_id, TRUE, &cache);
1270 silc_free(client_id);
1274 silc_free(client_id);
1276 /* Update statistics */
1277 server->stat.clients--;
1278 if (server->stat.cell_clients)
1279 server->stat.cell_clients--;
1280 SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
1281 SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
1283 /* Remove the client from all channels. */
1284 silc_server_remove_from_channels(server, NULL, client,
1285 TRUE, NULL, FALSE, FALSE);
1287 /* Check if anyone is watching this nickname */
1288 if (server->server_type == SILC_ROUTER)
1289 silc_server_check_watcher_list(server, client, NULL,
1290 SILC_NOTIFY_TYPE_SERVER_SIGNOFF);
1292 /* Remove this client from watcher list if it is */
1294 silc_server_del_from_watcher_list(server, client);
1296 /* Remove the client */
1297 silc_idlist_del_data(client);
1298 silc_idlist_del_client(local ? server->local_list :
1299 server->global_list, client);
1303 silc_free(server_id);
1307 silc_free(server_id);
1309 /* For local entrys SERVER_SIGNOFF is processed only on backup router.
1310 It is possible that router sends server signoff for a server. If
1311 backup router has it as local connection it will be closed. */
1312 if (SILC_IS_LOCAL(server_entry)) {
1313 if (server->server_type == SILC_BACKUP_ROUTER) {
1314 sock = server_entry->connection;
1315 SILC_LOG_DEBUG(("Closing connection %s after SERVER_SIGNOFF",
1317 SILC_SET_DISCONNECTING(sock);
1318 if (sock->user_data)
1319 silc_server_free_sock_user_data(server, sock, NULL);
1320 silc_server_close_connection(server, sock);
1326 /* Remove all servers that are originated from this server, and
1327 remove the clients of those servers too. */
1328 silc_server_remove_servers_by_server(server, server_entry, TRUE);
1330 /* Remove the clients that this server owns as they will become
1332 silc_server_remove_clients_by_server(server, server_entry->router,
1333 server_entry, TRUE);
1334 silc_server_backup_del(server, server_entry);
1336 /* Remove the server entry */
1337 silc_idlist_del_server(local ? server->local_list :
1338 server->global_list, server_entry);
1340 /* Update statistics */
1341 if (server->server_type == SILC_ROUTER)
1342 server->stat.servers--;
1346 case SILC_NOTIFY_TYPE_KICKED:
1348 * Distribute the notify to local clients on the channel
1351 SILC_LOG_DEBUG(("KICKED notify"));
1354 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
1355 packet->dst_id_type);
1360 /* Get channel entry */
1361 channel = silc_idlist_find_channel_by_id(server->global_list,
1364 channel = silc_idlist_find_channel_by_id(server->local_list,
1367 SILC_LOG_DEBUG(("Notify for unknown channel"));
1368 silc_free(channel_id);
1372 silc_free(channel_id);
1375 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1378 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1382 /* If the the client is not in local list we check global list */
1383 client = silc_idlist_find_client_by_id(server->global_list,
1384 client_id, TRUE, NULL);
1386 client = silc_idlist_find_client_by_id(server->local_list,
1387 client_id, TRUE, NULL);
1389 silc_free(client_id);
1393 silc_free(client_id);
1395 /* If target is founder they cannot be kicked */
1396 if (!silc_server_client_on_channel(client, channel, &chl))
1398 if (chl->mode & SILC_CHANNEL_UMODE_CHANFO)
1401 /* Get the kicker's Client ID */
1402 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1405 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1409 /* If the the client is not in local list we check global list */
1410 client2 = silc_idlist_find_client_by_id(server->global_list,
1411 client_id, TRUE, NULL);
1413 client2 = silc_idlist_find_client_by_id(server->local_list,
1414 client_id, TRUE, NULL);
1416 silc_free(client_id);
1420 silc_free(client_id);
1422 /* Kicker must be operator on channel */
1423 if (!silc_server_client_on_channel(client2, channel, &chl))
1425 if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
1426 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
1427 SILC_LOG_DEBUG(("Kicking is not allowed"));
1431 /* Send to channel */
1432 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
1433 FALSE, packet->buffer->data,
1434 packet->buffer->len, FALSE);
1436 /* Remove the client from channel's invite list */
1437 if (channel->invite_list && silc_hash_table_count(channel->invite_list)) {
1439 SilcArgumentPayload iargs;
1440 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1441 ab = silc_argument_payload_encode_one(NULL, tmp, tmp_len, 3);
1442 iargs = silc_argument_payload_parse(ab->data, ab->len, 1);
1443 silc_server_inviteban_process(server, channel->invite_list, 1, iargs);
1444 silc_buffer_free(ab);
1445 silc_argument_payload_free(iargs);
1448 /* Remove the client from channel */
1449 silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
1453 case SILC_NOTIFY_TYPE_KILLED:
1456 * Distribute the notify to local clients on channels
1458 unsigned char *id, *comment;
1459 SilcUInt32 id_len, comment_len;
1461 SILC_LOG_DEBUG(("KILLED notify"));
1464 id = silc_argument_get_arg_type(args, 1, &id_len);
1467 client_id = silc_id_payload_parse_id(id, id_len, NULL);
1471 /* If the the client is not in local list we check global list */
1472 client = silc_idlist_find_client_by_id(server->global_list,
1473 client_id, TRUE, &cache);
1475 client = silc_idlist_find_client_by_id(server->local_list,
1476 client_id, TRUE, &cache);
1478 silc_free(client_id);
1482 silc_free(client_id);
1484 /* If the client is one of ours, then close the connection to the
1485 client now. This removes the client from all channels as well. */
1486 if (packet->dst_id_type == SILC_ID_CLIENT && client->connection) {
1487 sock = client->connection;
1488 silc_server_free_client_data(server, NULL, client, FALSE, NULL);
1489 silc_server_close_connection(server, sock);
1494 comment = silc_argument_get_arg_type(args, 2, &comment_len);
1495 if (comment_len > 128)
1498 /* Get the killer's Client ID */
1499 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1502 client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
1506 if (id_type == SILC_ID_CLIENT) {
1507 /* If the the client is not in local list we check global list */
1508 client2 = silc_idlist_find_client_by_id(server->global_list,
1509 client_id, TRUE, NULL);
1511 client2 = silc_idlist_find_client_by_id(server->local_list,
1512 client_id, TRUE, NULL);
1514 silc_free(client_id);
1518 silc_free(client_id);
1520 /* Killer must be router operator */
1521 if (server->server_type != SILC_SERVER &&
1522 !(client2->mode & SILC_UMODE_ROUTER_OPERATOR)) {
1523 SILC_LOG_DEBUG(("Killing is not allowed"));
1528 /* Send the notify to local clients on the channels except to the
1529 client who is killed. */
1530 silc_server_send_notify_on_channels(server, client, client,
1531 SILC_NOTIFY_TYPE_KILLED, 3,
1532 id, id_len, comment, comment_len,
1535 /* Remove the client from all channels */
1536 silc_server_remove_from_channels(server, NULL, client, FALSE, NULL,
1539 /* Check if anyone is watching this nickname */
1540 silc_server_check_watcher_list(server, client, NULL,
1541 SILC_NOTIFY_TYPE_KILLED);
1543 /* Update statistics */
1544 server->stat.clients--;
1545 if (server->stat.cell_clients)
1546 server->stat.cell_clients--;
1547 SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
1548 SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
1550 if (SILC_IS_LOCAL(client)) {
1551 server->stat.my_clients--;
1552 silc_schedule_task_del_by_context(server->schedule, client);
1553 silc_idlist_del_data(client);
1557 client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
1558 cache->expire = SILC_ID_CACHE_EXPIRE_DEF;
1562 case SILC_NOTIFY_TYPE_UMODE_CHANGE:
1564 * Save the mode of the client.
1567 SILC_LOG_DEBUG(("UMODE_CHANGE notify"));
1570 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1573 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1577 /* Get client entry */
1578 client = silc_idlist_find_client_by_id(server->global_list,
1579 client_id, TRUE, NULL);
1581 client = silc_idlist_find_client_by_id(server->local_list,
1582 client_id, TRUE, NULL);
1584 silc_free(client_id);
1588 silc_free(client_id);
1591 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1594 SILC_GET32_MSB(mode, tmp);
1596 /* Remove internal resumed flag if client is marked detached now */
1597 if (mode & SILC_UMODE_DETACHED)
1598 client->data.status &= ~SILC_IDLIST_STATUS_RESUMED;
1600 /* Update statistics */
1601 if (server->server_type == SILC_ROUTER) {
1602 if (mode & SILC_UMODE_GONE) {
1603 if (!(client->mode & SILC_UMODE_GONE))
1604 server->stat.aways++;
1606 if (client->mode & SILC_UMODE_GONE)
1607 server->stat.aways--;
1609 if (mode & SILC_UMODE_DETACHED) {
1610 if (!(client->mode & SILC_UMODE_DETACHED))
1611 server->stat.detached++;
1613 if (client->mode & SILC_UMODE_DETACHED)
1614 server->stat.detached--;
1617 SILC_UMODE_STATS_UPDATE(server, SILC_UMODE_SERVER_OPERATOR);
1618 SILC_UMODE_STATS_UPDATE(router, SILC_UMODE_ROUTER_OPERATOR);
1620 /* Change the mode */
1621 client->mode = mode;
1623 /* Check if anyone is watching this nickname */
1624 if (server->server_type == SILC_ROUTER)
1625 silc_server_check_watcher_list(server, client, NULL,
1626 SILC_NOTIFY_TYPE_UMODE_CHANGE);
1630 case SILC_NOTIFY_TYPE_BAN:
1635 SILC_LOG_DEBUG(("BAN notify"));
1637 /* Get Channel ID */
1638 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1641 channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1645 /* Get channel entry */
1646 channel = silc_idlist_find_channel_by_id(server->global_list,
1649 channel = silc_idlist_find_channel_by_id(server->local_list,
1652 SILC_LOG_DEBUG(("Notify for unknown channel"));
1653 silc_free(channel_id);
1657 silc_free(channel_id);
1659 /* Get the ban action */
1660 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1661 if (tmp && tmp_len == 1) {
1662 SilcUInt8 action = (SilcUInt8)tmp[0];
1663 SilcUInt16 iargc = 0;
1664 SilcArgumentPayload iargs;
1667 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1668 if (!tmp || tmp_len < 2)
1671 /* Parse the arguments to see they are constructed correctly */
1672 SILC_GET16_MSB(iargc, tmp);
1673 iargs = silc_argument_payload_parse(tmp + 2, tmp_len - 2, iargc);
1677 if (action == 0 && !channel->ban_list)
1679 silc_hash_table_alloc(0, silc_hash_ptr,
1681 silc_server_inviteban_destruct, channel, TRUE);
1683 /* Proces the ban action */
1684 silc_server_inviteban_process(server, channel->ban_list, action,
1686 silc_argument_payload_free(iargs);
1690 case SILC_NOTIFY_TYPE_ERROR:
1697 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1698 if (!tmp && tmp_len != 1)
1700 error = (SilcStatus)tmp[0];
1702 SILC_LOG_DEBUG(("ERROR notify (%d)", error));
1704 if (error == SILC_STATUS_ERR_NO_SUCH_CLIENT_ID &&
1705 sock->type == SILC_SOCKET_TYPE_ROUTER) {
1706 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1708 SILC_LOG_DEBUG(("Received invalid client ID notification, deleting "
1709 "the entry from cache"));
1710 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1713 client = silc_idlist_find_client_by_id(server->global_list,
1714 client_id, FALSE, NULL);
1716 silc_server_remove_from_channels(server, NULL, client, TRUE,
1718 silc_idlist_del_data(client);
1719 silc_idlist_del_client(server->global_list, client);
1721 silc_free(client_id);
1727 /* Ignore rest of the notify types for now */
1728 case SILC_NOTIFY_TYPE_NONE:
1729 case SILC_NOTIFY_TYPE_MOTD:
1736 silc_notify_payload_free(payload);
1739 void silc_server_notify_list(SilcServer server,
1740 SilcSocketConnection sock,
1741 SilcPacketContext *packet)
1743 SilcPacketContext *new;
1747 SILC_LOG_DEBUG(("Processing Notify List"));
1749 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
1750 packet->src_id_type != SILC_ID_SERVER)
1753 /* Make copy of the original packet context, except for the actual
1754 data buffer, which we will here now fetch from the original buffer. */
1755 new = silc_packet_context_alloc();
1756 new->type = SILC_PACKET_NOTIFY;
1757 new->flags = packet->flags;
1758 new->src_id = packet->src_id;
1759 new->src_id_len = packet->src_id_len;
1760 new->src_id_type = packet->src_id_type;
1761 new->dst_id = packet->dst_id;
1762 new->dst_id_len = packet->dst_id_len;
1763 new->dst_id_type = packet->dst_id_type;
1765 buffer = silc_buffer_alloc(1024);
1766 new->buffer = buffer;
1768 while (packet->buffer->len) {
1769 SILC_GET16_MSB(len, packet->buffer->data + 2);
1770 if (len > packet->buffer->len)
1773 if (len > buffer->truelen) {
1774 silc_buffer_free(buffer);
1775 buffer = silc_buffer_alloc(1024 + len);
1778 silc_buffer_pull_tail(buffer, len);
1779 silc_buffer_put(buffer, packet->buffer->data, len);
1781 /* Process the Notify */
1782 silc_server_notify(server, sock, new);
1784 silc_buffer_push_tail(buffer, len);
1785 silc_buffer_pull(packet->buffer, len);
1788 silc_buffer_free(buffer);
1792 /* Received private message. This resolves the destination of the message
1793 and sends the packet. This is used by both server and router. If the
1794 destination is our locally connected client this sends the packet to
1795 the client. This may also send the message for further routing if
1796 the destination is not in our server (or router). */
1798 void silc_server_private_message(SilcServer server,
1799 SilcSocketConnection sock,
1800 SilcPacketContext *packet)
1802 SilcSocketConnection dst_sock;
1803 SilcIDListData idata;
1804 SilcClientEntry client;
1806 SILC_LOG_DEBUG(("Start"));
1808 if (packet->src_id_type != SILC_ID_CLIENT ||
1809 packet->dst_id_type != SILC_ID_CLIENT || !packet->dst_id)
1812 /* Get the route to the client */
1813 dst_sock = silc_server_get_client_route(server, packet->dst_id,
1814 packet->dst_id_len, NULL,
1818 unsigned char error;
1820 if (client && client->mode & SILC_UMODE_DETACHED) {
1821 SILC_LOG_DEBUG(("Client is detached, discarding packet"));
1825 /* Send SILC_NOTIFY_TYPE_ERROR to indicate that such destination ID
1826 does not exist or is invalid. */
1827 idp = silc_id_payload_encode_data(packet->dst_id,
1829 packet->dst_id_type);
1833 error = SILC_STATUS_ERR_NO_SUCH_CLIENT_ID;
1834 if (packet->src_id_type == SILC_ID_CLIENT) {
1835 SilcClientID *client_id = silc_id_str2id(packet->src_id,
1837 packet->src_id_type);
1838 silc_server_send_notify_dest(server, sock, FALSE,
1839 client_id, SILC_ID_CLIENT,
1840 SILC_NOTIFY_TYPE_ERROR, 2,
1842 idp->data, idp->len);
1843 silc_free(client_id);
1845 silc_server_send_notify(server, sock, FALSE,
1846 SILC_NOTIFY_TYPE_ERROR, 2,
1848 idp->data, idp->len);
1851 silc_buffer_free(idp);
1855 /* Check whether destination client wishes to receive private messages */
1856 if (client && !(packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY) &&
1857 client->mode & SILC_UMODE_BLOCK_PRIVMSG) {
1858 SILC_LOG_DEBUG(("Client blocks private messages, discarding packet"));
1862 /* Send the private message */
1863 silc_server_send_private_message(server, dst_sock, idata->send_key,
1864 idata->hmac_send, idata->psn_send++,
1868 /* Received private message key packet.. This packet is never for us. It is to
1869 the client in the packet's destination ID. Sending of this sort of packet
1870 equals sending private message, ie. it is sent point to point from
1871 one client to another. */
1873 void silc_server_private_message_key(SilcServer server,
1874 SilcSocketConnection sock,
1875 SilcPacketContext *packet)
1877 SilcSocketConnection dst_sock;
1878 SilcIDListData idata;
1880 SILC_LOG_DEBUG(("Start"));
1882 if (packet->src_id_type != SILC_ID_CLIENT ||
1883 packet->dst_id_type != SILC_ID_CLIENT)
1886 if (!packet->dst_id)
1889 /* Get the route to the client */
1890 dst_sock = silc_server_get_client_route(server, packet->dst_id,
1891 packet->dst_id_len, NULL,
1896 /* Relay the packet */
1897 silc_server_relay_packet(server, dst_sock, idata->send_key,
1898 idata->hmac_send, idata->psn_send++, packet, FALSE);
1901 /* Processes incoming command reply packet. The command reply packet may
1902 be destined to one of our clients or it may directly for us. We will
1903 call the command reply routine after processing the packet. */
1905 void silc_server_command_reply(SilcServer server,
1906 SilcSocketConnection sock,
1907 SilcPacketContext *packet)
1909 SilcBuffer buffer = packet->buffer;
1910 SilcClientEntry client = NULL;
1911 SilcSocketConnection dst_sock;
1912 SilcIDListData idata;
1913 SilcClientID *id = NULL;
1915 SILC_LOG_DEBUG(("Start"));
1917 if (packet->dst_id_type == SILC_ID_CHANNEL)
1920 if (packet->dst_id_type == SILC_ID_CLIENT) {
1921 /* Destination must be one of ours */
1922 id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CLIENT);
1925 client = silc_idlist_find_client_by_id(server->local_list, id, TRUE, NULL);
1927 SILC_LOG_ERROR(("Cannot process command reply to unknown client"));
1933 if (packet->dst_id_type == SILC_ID_SERVER) {
1934 /* For now this must be for us */
1935 if (memcmp(packet->dst_id, server->id_string, server->id_string_len)) {
1936 SILC_LOG_ERROR(("Cannot process command reply to unknown server"));
1941 /* Execute command reply locally for the command */
1942 silc_server_command_reply_process(server, sock, buffer);
1944 if (packet->dst_id_type == SILC_ID_CLIENT && client && id) {
1945 /* Relay the packet to the client */
1946 const SilcBufferStruct p;
1948 dst_sock = (SilcSocketConnection)client->connection;
1949 idata = (SilcIDListData)client;
1951 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1952 + packet->dst_id_len + packet->padlen);
1953 if (!silc_packet_send_prepare(dst_sock, 0, 0, buffer->len,
1954 idata->hmac_send, (const SilcBuffer)&p)) {
1955 SILC_LOG_ERROR(("Cannot send packet"));
1958 silc_buffer_put((SilcBuffer)&p, buffer->data, buffer->len);
1960 /* Encrypt packet */
1961 silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
1962 (SilcBuffer)&p, buffer->len);
1964 /* Send the packet */
1965 silc_server_packet_send_real(server, dst_sock, TRUE);
1971 /* Process received channel message. The message can be originated from
1972 client or server. */
1974 void silc_server_channel_message(SilcServer server,
1975 SilcSocketConnection sock,
1976 SilcPacketContext *packet)
1978 SilcChannelEntry channel = NULL;
1979 SilcChannelID *id = NULL;
1980 void *sender_id = NULL;
1981 SilcClientEntry sender_entry = NULL;
1982 SilcChannelClientEntry chl;
1985 SILC_LOG_DEBUG(("Processing channel message"));
1988 if (packet->dst_id_type != SILC_ID_CHANNEL) {
1989 SILC_LOG_DEBUG(("Received bad message for channel, dropped"));
1993 /* Find channel entry */
1994 id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CHANNEL);
1997 channel = silc_idlist_find_channel_by_id(server->local_list, id, NULL);
1999 channel = silc_idlist_find_channel_by_id(server->global_list, id, NULL);
2002 unsigned char error;
2004 /* Send SILC_NOTIFY_TYPE_ERROR to indicate that such destination ID
2005 does not exist or is invalid. */
2006 idp = silc_id_payload_encode_data(packet->dst_id,
2008 packet->dst_id_type);
2012 error = SILC_STATUS_ERR_NO_SUCH_CHANNEL_ID;
2013 if (packet->src_id_type == SILC_ID_CLIENT) {
2014 SilcClientID *client_id = silc_id_str2id(packet->src_id,
2016 packet->src_id_type);
2017 silc_server_send_notify_dest(server, sock, FALSE,
2018 client_id, SILC_ID_CLIENT,
2019 SILC_NOTIFY_TYPE_ERROR, 2,
2020 &error, 1, idp->data, idp->len);
2021 silc_free(client_id);
2023 silc_server_send_notify(server, sock, FALSE,
2024 SILC_NOTIFY_TYPE_ERROR, 2,
2025 &error, 1, idp->data, idp->len);
2028 silc_buffer_free(idp);
2033 /* See that this client is on the channel. If the original sender is
2034 not client (as it can be server as well) we don't do the check. */
2035 sender_id = silc_id_str2id(packet->src_id, packet->src_id_len,
2036 packet->src_id_type);
2039 if (packet->src_id_type == SILC_ID_CLIENT) {
2040 sender_entry = silc_idlist_find_client_by_id(server->local_list,
2041 sender_id, TRUE, NULL);
2042 if (!sender_entry) {
2044 sender_entry = silc_idlist_find_client_by_id(server->global_list,
2045 sender_id, TRUE, NULL);
2047 if (!sender_entry || !silc_server_client_on_channel(sender_entry,
2049 SILC_LOG_DEBUG(("Client not on channel"));
2053 /* If channel is moderated check that client is allowed to send
2055 if (channel->mode & SILC_CHANNEL_MODE_SILENCE_USERS &&
2056 !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
2057 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
2058 SILC_LOG_DEBUG(("Channel is silenced from normal users"));
2061 if (channel->mode & SILC_CHANNEL_MODE_SILENCE_OPERS &&
2062 chl->mode & SILC_CHANNEL_UMODE_CHANOP &&
2063 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
2064 SILC_LOG_DEBUG(("Channel is silenced from operators"));
2067 if (chl->mode & SILC_CHANNEL_UMODE_QUIET) {
2068 SILC_LOG_DEBUG(("Sender is quieted on the channel"));
2072 /* If the packet is coming from router, but the client entry is local
2073 entry to us then some router is rerouting this to us and it is not
2074 allowed. When the client is local to us it means that we've routed
2075 this packet to network, and now someone is routing it back to us. */
2076 if (server->server_type == SILC_ROUTER &&
2077 sock->type == SILC_SOCKET_TYPE_ROUTER && local) {
2078 SILC_LOG_DEBUG(("Channel message rerouted to the sender, drop it"));
2083 /* Distribute the packet to our local clients. This will send the
2084 packet for further routing as well, if needed. */
2085 silc_server_packet_relay_to_channel(server, sock, channel, sender_id,
2086 packet->src_id_type, sender_entry,
2087 packet->buffer->data,
2088 packet->buffer->len, FALSE);
2091 silc_free(sender_id);
2095 /* Received channel key packet. We distribute the key to all of our locally
2096 connected clients on the channel. */
2098 void silc_server_channel_key(SilcServer server,
2099 SilcSocketConnection sock,
2100 SilcPacketContext *packet)
2102 SilcBuffer buffer = packet->buffer;
2103 SilcChannelEntry channel;
2105 if (packet->src_id_type != SILC_ID_SERVER ||
2106 (server->server_type == SILC_ROUTER && !server->backup_router &&
2107 sock->type == SILC_SOCKET_TYPE_ROUTER))
2110 /* Save the channel key */
2111 channel = silc_server_save_channel_key(server, buffer, NULL);
2113 SILC_LOG_ERROR(("Bad channel key from %s (%s)",
2114 sock->hostname, sock->ip));
2118 /* Distribute the key to everybody who is on the channel. If we are router
2119 we will also send it to locally connected servers. */
2120 silc_server_send_channel_key(server, sock, channel, FALSE);
2122 if (server->server_type != SILC_BACKUP_ROUTER) {
2123 /* Distribute to local cell backup routers. */
2124 silc_server_backup_send(server, sock->user_data,
2125 SILC_PACKET_CHANNEL_KEY, 0,
2126 buffer->data, buffer->len, FALSE, TRUE);
2130 /* Received New Client packet and processes it. Creates Client ID for the
2131 client. Client becomes registered after calling this functions. */
2133 SilcClientEntry silc_server_new_client(SilcServer server,
2134 SilcSocketConnection sock,
2135 SilcPacketContext *packet)
2137 SilcBuffer buffer = packet->buffer;
2138 SilcClientEntry client;
2139 SilcClientID *client_id;
2140 SilcIDListData idata;
2141 char *username = NULL, *realname = NULL;
2142 SilcUInt16 username_len;
2145 char *hostname, *nickname;
2148 SILC_LOG_DEBUG(("Creating new client"));
2150 if (sock->type != SILC_SOCKET_TYPE_CLIENT)
2153 /* Take client entry */
2154 client = (SilcClientEntry)sock->user_data;
2155 idata = (SilcIDListData)client;
2157 /* Remove the old cache entry. */
2158 if (!silc_idcache_del_by_context(server->local_list->clients, client)) {
2159 SILC_LOG_INFO(("Unauthenticated client attempted to register to network"));
2160 silc_server_disconnect_remote(server, sock,
2161 SILC_STATUS_ERR_NOT_AUTHENTICATED, NULL);
2162 if (sock->user_data)
2163 silc_server_free_sock_user_data(server, sock, NULL);
2167 /* Make sure this client hasn't registered already */
2168 if (idata->status & SILC_IDLIST_STATUS_REGISTERED) {
2169 silc_server_disconnect_remote(server, sock,
2170 SILC_STATUS_ERR_OPERATION_ALLOWED,
2171 "Too many registrations");
2172 if (sock->user_data)
2173 silc_server_free_sock_user_data(server, sock, NULL);
2177 /* Parse incoming packet */
2178 ret = silc_buffer_unformat(buffer,
2179 SILC_STR_UI16_NSTRING_ALLOC(&username,
2181 SILC_STR_UI16_STRING_ALLOC(&realname),
2184 silc_free(username);
2185 silc_free(realname);
2186 SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
2187 "connection", sock->hostname, sock->ip));
2188 silc_server_disconnect_remote(server, sock,
2189 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2191 if (sock->user_data)
2192 silc_server_free_sock_user_data(server, sock, NULL);
2197 silc_free(username);
2198 silc_free(realname);
2199 SILC_LOG_ERROR(("Client %s (%s) did not send its username, closing "
2200 "connection", sock->hostname, sock->ip));
2201 silc_server_disconnect_remote(server, sock,
2202 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2204 if (sock->user_data)
2205 silc_server_free_sock_user_data(server, sock, NULL);
2209 if (username_len > 128)
2210 username[128] = '\0';
2212 /* Check for bad characters for nickname, and modify the nickname if
2213 it includes those. */
2214 if (silc_server_name_bad_chars(username, username_len)) {
2215 nickname = silc_server_name_modify_bad(username, username_len);
2217 nickname = strdup(username);
2220 /* Make sanity checks for the hostname of the client. If the hostname
2221 is provided in the `username' check that it is the same than the
2222 resolved hostname, or if not resolved the hostname that appears in
2223 the client's public key. If the hostname is not present then put
2224 it from the resolved name or from the public key. */
2225 if (strchr(username, '@')) {
2226 SilcPublicKeyIdentifier pident;
2227 int tlen = strcspn(username, "@");
2228 char *phostname = NULL;
2230 hostname = silc_memdup(username + tlen + 1, strlen(username) - tlen - 1);
2232 if (strcmp(sock->hostname, sock->ip) &&
2233 strcmp(sock->hostname, hostname)) {
2234 silc_free(username);
2235 silc_free(hostname);
2236 silc_free(realname);
2237 SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
2238 "connection", sock->hostname, sock->ip));
2239 silc_server_disconnect_remote(server, sock,
2240 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2242 if (sock->user_data)
2243 silc_server_free_sock_user_data(server, sock, NULL);
2247 pident = silc_pkcs_decode_identifier(client->data.public_key->identifier);
2249 phostname = strdup(pident->host);
2250 silc_pkcs_free_identifier(pident);
2253 if (!strcmp(sock->hostname, sock->ip) &&
2254 phostname && strcmp(phostname, hostname)) {
2255 silc_free(username);
2256 silc_free(hostname);
2257 silc_free(phostname);
2258 silc_free(realname);
2259 SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
2260 "connection", sock->hostname, sock->ip));
2261 silc_server_disconnect_remote(server, sock,
2262 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2264 if (sock->user_data)
2265 silc_server_free_sock_user_data(server, sock, NULL);
2269 silc_free(phostname);
2271 /* The hostname is not present, add it. */
2273 /* XXX For now we cannot take the host name from the public key since
2274 they are not trusted or we cannot verify them as trusted. Just take
2275 what the resolved name or address is. */
2277 if (strcmp(sock->hostname, sock->ip)) {
2279 newusername = silc_calloc(strlen(username) +
2280 strlen(sock->hostname) + 2,
2281 sizeof(*newusername));
2282 strncat(newusername, username, strlen(username));
2283 strncat(newusername, "@", 1);
2284 strncat(newusername, sock->hostname, strlen(sock->hostname));
2285 silc_free(username);
2286 username = newusername;
2289 SilcPublicKeyIdentifier pident =
2290 silc_pkcs_decode_identifier(client->data.public_key->identifier);
2293 newusername = silc_calloc(strlen(username) +
2294 strlen(pident->host) + 2,
2295 sizeof(*newusername));
2296 strncat(newusername, username, strlen(username));
2297 strncat(newusername, "@", 1);
2298 strncat(newusername, pident->host, strlen(pident->host));
2299 silc_free(username);
2300 username = newusername;
2301 silc_pkcs_free_identifier(pident);
2307 /* Create Client ID */
2308 while (!silc_id_create_client_id(server, server->id, server->rng,
2309 server->md5hash, nickname, &client_id)) {
2312 silc_server_disconnect_remote(server, sock,
2313 SILC_STATUS_ERR_BAD_NICKNAME, NULL);
2314 if (sock->user_data)
2315 silc_server_free_sock_user_data(server, sock, NULL);
2318 snprintf(&nickname[strlen(nickname) - 1], 1, "%d", nickfail);
2321 /* If client marked as anonymous, scramble the username and hostname */
2322 if (client->mode & SILC_UMODE_ANONYMOUS) {
2325 if (strlen(username) >= 2) {
2326 username[0] = silc_rng_get_byte_fast(server->rng);
2327 username[1] = silc_rng_get_byte_fast(server->rng);
2330 scramble = silc_hash_babbleprint(server->sha1hash, username,
2334 memcpy(&scramble[16], ".silc", 5);
2335 scramble[21] = '\0';
2336 silc_free(username);
2337 username = scramble;
2340 /* Update client entry */
2341 idata->status |= SILC_IDLIST_STATUS_REGISTERED;
2342 client->nickname = nickname;
2343 client->username = username;
2344 client->userinfo = realname ? realname : strdup(username);
2345 client->id = client_id;
2346 id_len = silc_id_get_len(client_id, SILC_ID_CLIENT);
2348 /* Add the client again to the ID cache */
2349 silc_idcache_add(server->local_list->clients, client->nickname,
2350 client_id, client, 0, NULL);
2352 /* Notify our router about new client on the SILC network */
2353 silc_server_send_new_id(server, SILC_PRIMARY_ROUTE(server),
2354 SILC_BROADCAST(server), client->id,
2355 SILC_ID_CLIENT, id_len);
2357 /* Distribute to backup routers */
2358 if (server->server_type == SILC_ROUTER) {
2359 SilcBuffer idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
2360 silc_server_backup_send(server, sock->user_data, SILC_PACKET_NEW_ID, 0,
2361 idp->data, idp->len, FALSE, TRUE);
2362 silc_buffer_free(idp);
2365 /* Send the new client ID to the client. */
2366 silc_server_send_new_id(server, sock, FALSE, client->id, SILC_ID_CLIENT,
2367 silc_id_get_len(client->id, SILC_ID_CLIENT));
2369 /* Send some nice info to the client */
2370 silc_server_send_connect_notifys(server, sock, client);
2372 /* Check if anyone is watching this nickname */
2373 if (server->server_type == SILC_ROUTER)
2374 silc_server_check_watcher_list(server, client, NULL, 0);
2379 /* Create new server. This processes received New Server packet and
2380 saves the received Server ID. The server is our locally connected
2381 server thus we save all the information and save it to local list.
2382 This funtion can be used by both normal server and router server.
2383 If normal server uses this it means that its router has connected
2384 to the server. If router uses this it means that one of the cell's
2385 servers is connected to the router. */
2387 SilcServerEntry silc_server_new_server(SilcServer server,
2388 SilcSocketConnection sock,
2389 SilcPacketContext *packet)
2391 SilcBuffer buffer = packet->buffer;
2392 SilcServerEntry new_server, server_entry;
2393 SilcServerID *server_id;
2394 SilcIDListData idata;
2395 unsigned char *server_name, *id_string;
2396 SilcUInt16 id_len, name_len;
2400 SILC_LOG_DEBUG(("Creating new server"));
2402 if (sock->type != SILC_SOCKET_TYPE_SERVER &&
2403 sock->type != SILC_SOCKET_TYPE_ROUTER)
2406 /* Take server entry */
2407 new_server = (SilcServerEntry)sock->user_data;
2408 idata = (SilcIDListData)new_server;
2410 /* Remove the old cache entry */
2411 if (!silc_idcache_del_by_context(server->local_list->servers, new_server)) {
2412 if (!silc_idcache_del_by_context(server->global_list->servers,
2414 SILC_LOG_INFO(("Unauthenticated %s attempted to register to "
2415 "network", (sock->type == SILC_SOCKET_TYPE_SERVER ?
2416 "server" : "router")));
2417 silc_server_disconnect_remote(server, sock,
2418 SILC_STATUS_ERR_NOT_AUTHENTICATED, NULL);
2419 if (sock->user_data)
2420 silc_server_free_sock_user_data(server, sock, NULL);
2426 /* Make sure this server hasn't registered already */
2427 if (idata->status & SILC_IDLIST_STATUS_REGISTERED) {
2428 silc_server_disconnect_remote(server, sock,
2429 SILC_STATUS_ERR_OPERATION_ALLOWED,
2430 "Too many registrations");
2431 if (sock->user_data)
2432 silc_server_free_sock_user_data(server, sock, NULL);
2436 /* Parse the incoming packet */
2437 ret = silc_buffer_unformat(buffer,
2438 SILC_STR_UI16_NSTRING_ALLOC(&id_string, &id_len),
2439 SILC_STR_UI16_NSTRING_ALLOC(&server_name,
2443 silc_free(id_string);
2444 silc_free(server_name);
2445 silc_server_disconnect_remote(server, sock,
2446 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2448 if (sock->user_data)
2449 silc_server_free_sock_user_data(server, sock, NULL);
2453 if (id_len > buffer->len) {
2454 silc_free(id_string);
2455 silc_free(server_name);
2456 silc_server_disconnect_remote(server, sock,
2457 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2459 if (sock->user_data)
2460 silc_server_free_sock_user_data(server, sock, NULL);
2465 server_name[255] = '\0';
2468 server_id = silc_id_str2id(id_string, id_len, SILC_ID_SERVER);
2470 silc_free(id_string);
2471 silc_free(server_name);
2472 silc_server_disconnect_remote(server, sock,
2473 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2475 if (sock->user_data)
2476 silc_server_free_sock_user_data(server, sock, NULL);
2479 silc_free(id_string);
2481 /* Check for valid server ID */
2482 if (!silc_id_is_valid_server_id(server, server_id, sock)) {
2483 SILC_LOG_INFO(("Invalid server ID sent by %s (%s)",
2484 sock->ip, sock->hostname));
2485 silc_server_disconnect_remote(server, sock,
2486 SILC_STATUS_ERR_BAD_SERVER_ID, NULL);
2487 if (sock->user_data)
2488 silc_server_free_sock_user_data(server, sock, NULL);
2489 silc_free(server_name);
2493 /* Check that we do not have this ID already */
2494 server_entry = silc_idlist_find_server_by_id(server->local_list,
2495 server_id, TRUE, NULL);
2497 if (SILC_IS_LOCAL(server_entry)) {
2498 silc_server_disconnect_remote(server, server_entry->connection,
2499 SILC_STATUS_ERR_OPERATION_ALLOWED,
2500 "Too many registrations");
2501 if (((SilcSocketConnection)server_entry->connection)->user_data)
2502 silc_server_free_sock_user_data(server, sock, NULL);
2504 silc_idcache_del_by_context(server->local_list->servers, server_entry);
2507 server_entry = silc_idlist_find_server_by_id(server->global_list,
2508 server_id, TRUE, NULL);
2510 if (SILC_IS_LOCAL(server_entry)) {
2511 silc_server_disconnect_remote(server, server_entry->connection,
2512 SILC_STATUS_ERR_OPERATION_ALLOWED,
2513 "Too many registrations");
2514 if (((SilcSocketConnection)server_entry->connection)->user_data)
2515 silc_server_free_sock_user_data(server, server_entry->connection,
2518 silc_idcache_del_by_context(server->global_list->servers,
2524 /* Update server entry */
2525 idata->status |= SILC_IDLIST_STATUS_REGISTERED;
2526 new_server->server_name = server_name;
2527 new_server->id = server_id;
2529 SILC_LOG_DEBUG(("New server id(%s)",
2530 silc_id_render(server_id, SILC_ID_SERVER)));
2532 /* Add again the entry to the ID cache. */
2533 silc_idcache_add(local ? server->local_list->servers :
2534 server->global_list->servers, server_name, server_id,
2535 new_server, 0, NULL);
2537 /* Distribute the information about new server in the SILC network
2538 to our router. If we are normal server we won't send anything
2539 since this connection must be our router connection. */
2540 if (server->server_type == SILC_ROUTER && !server->standalone &&
2541 SILC_PRIMARY_ROUTE(server) != sock)
2542 silc_server_send_new_id(server, SILC_PRIMARY_ROUTE(server),
2543 TRUE, new_server->id, SILC_ID_SERVER,
2544 silc_id_get_len(server_id, SILC_ID_SERVER));
2546 if (server->server_type == SILC_ROUTER) {
2547 /* Distribute to backup routers */
2548 SilcBuffer idp = silc_id_payload_encode(new_server->id, SILC_ID_SERVER);
2549 silc_server_backup_send(server, sock->user_data, SILC_PACKET_NEW_ID, 0,
2550 idp->data, idp->len, FALSE, TRUE);
2551 silc_buffer_free(idp);
2554 server->stat.cell_servers++;
2557 /* Check whether this router connection has been replaced by an
2558 backup router. If it has been then we'll disable the server and will
2559 ignore everything it will send until the backup router resuming
2560 protocol has been completed. */
2561 if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
2562 silc_server_backup_replaced_get(server, server_id, NULL)) {
2563 /* Send packet to the server indicating that it cannot use this
2564 connection as it has been replaced by backup router. */
2565 SilcBuffer packet = silc_buffer_alloc(2);
2566 silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
2567 silc_buffer_format(packet,
2568 SILC_STR_UI_CHAR(SILC_SERVER_BACKUP_REPLACED),
2569 SILC_STR_UI_CHAR(0),
2571 silc_server_packet_send(server, sock,
2572 SILC_PACKET_RESUME_ROUTER, 0,
2573 packet->data, packet->len, TRUE);
2574 silc_buffer_free(packet);
2576 /* Mark the router disabled. The data sent earlier will go but nothing
2577 after this does not go to this connection. */
2578 idata->status |= SILC_IDLIST_STATUS_DISABLED;
2580 /* If it is router announce our stuff to it. */
2581 if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
2582 server->server_type == SILC_ROUTER) {
2583 silc_server_announce_servers(server, FALSE, 0, sock);
2584 silc_server_announce_clients(server, 0, sock);
2585 silc_server_announce_channels(server, 0, sock);
2588 /* Announce our information to backup router */
2589 if (new_server->server_type == SILC_BACKUP_ROUTER &&
2590 sock->type == SILC_SOCKET_TYPE_SERVER &&
2591 server->server_type == SILC_ROUTER) {
2592 silc_server_announce_servers(server, TRUE, 0, sock);
2593 silc_server_announce_clients(server, 0, sock);
2594 silc_server_announce_channels(server, 0, sock);
2597 /* If backup router, mark it as one of ours. This server is considered
2598 to be backup router after this setting. */
2599 if (new_server->server_type == SILC_BACKUP_ROUTER) {
2600 SilcServerConfigRouter *backup;
2601 backup = silc_server_config_find_backup_conn(server, sock->ip);
2603 backup = silc_server_config_find_backup_conn(server, sock->hostname);
2605 /* Add as our backup router */
2606 silc_server_backup_add(server, new_server, backup->backup_replace_ip,
2607 backup->backup_replace_port,
2608 backup->backup_local);
2612 /* By default the servers connected to backup router are disabled
2613 until backup router has become the primary */
2614 if (server->server_type == SILC_BACKUP_ROUTER &&
2615 sock->type == SILC_SOCKET_TYPE_SERVER)
2616 idata->status |= SILC_IDLIST_STATUS_DISABLED;
2622 /* Processes incoming New ID packet. New ID Payload is used to distribute
2623 information about newly registered clients and servers. */
2625 static void silc_server_new_id_real(SilcServer server,
2626 SilcSocketConnection sock,
2627 SilcPacketContext *packet,
2630 SilcBuffer buffer = packet->buffer;
2632 SilcServerEntry router, server_entry;
2633 SilcSocketConnection router_sock;
2638 SILC_LOG_DEBUG(("Processing new ID"));
2640 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2641 server->server_type == SILC_SERVER ||
2642 packet->src_id_type != SILC_ID_SERVER)
2645 idp = silc_id_payload_parse(buffer->data, buffer->len);
2649 id_type = silc_id_payload_get_type(idp);
2651 /* Normal server cannot have other normal server connections */
2652 server_entry = (SilcServerEntry)sock->user_data;
2653 if (id_type == SILC_ID_SERVER && sock->type == SILC_SOCKET_TYPE_SERVER &&
2654 server_entry->server_type == SILC_SERVER)
2657 id = silc_id_payload_get_id(idp);
2661 /* If the packet is coming from server then use the sender as the
2662 origin of the the packet. If it came from router then check the real
2663 sender of the packet and use that as the origin. */
2664 if (sock->type == SILC_SOCKET_TYPE_SERVER) {
2665 id_list = server->local_list;
2667 router = sock->user_data;
2669 /* If the sender is backup router and ID is server (and we are not
2670 backup router) then switch the entry to global list. */
2671 if (server_entry->server_type == SILC_BACKUP_ROUTER &&
2672 id_type == SILC_ID_SERVER &&
2673 server->id_entry->server_type != SILC_BACKUP_ROUTER) {
2674 id_list = server->global_list;
2675 router_sock = server->router ? SILC_PRIMARY_ROUTE(server) : sock;
2678 void *sender_id = silc_id_str2id(packet->src_id, packet->src_id_len,
2679 packet->src_id_type);
2680 router = silc_idlist_find_server_by_id(server->global_list,
2681 sender_id, TRUE, NULL);
2683 router = silc_idlist_find_server_by_id(server->local_list,
2684 sender_id, TRUE, NULL);
2685 silc_free(sender_id);
2687 id_list = server->global_list;
2694 case SILC_ID_CLIENT:
2696 SilcClientEntry entry;
2698 /* Check that we do not have this client already */
2699 entry = silc_idlist_find_client_by_id(server->global_list,
2700 id, server->server_type,
2703 entry = silc_idlist_find_client_by_id(server->local_list,
2704 id, server->server_type,
2707 SILC_LOG_DEBUG(("Ignoring client that we already have"));
2711 SILC_LOG_DEBUG(("New client id(%s) from [%s] %s",
2712 silc_id_render(id, SILC_ID_CLIENT),
2713 sock->type == SILC_SOCKET_TYPE_SERVER ?
2714 "Server" : "Router", sock->hostname));
2716 /* As a router we keep information of all global information in our
2717 global list. Cell wide information however is kept in the local
2719 entry = silc_idlist_add_client(id_list, NULL, NULL, NULL,
2720 id, router, NULL, 0);
2722 SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
2724 /* Inform the sender that the ID is not usable */
2725 silc_server_send_notify_signoff(server, sock, FALSE, id, NULL);
2728 entry->nickname = NULL;
2729 entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
2731 if (sock->type == SILC_SOCKET_TYPE_SERVER)
2732 server->stat.cell_clients++;
2733 server->stat.clients++;
2735 /* Check if anyone is watching this nickname */
2736 if (server->server_type == SILC_ROUTER && id_list == server->local_list)
2737 silc_server_check_watcher_list(server, entry, NULL, 0);
2741 case SILC_ID_SERVER:
2743 SilcServerEntry entry;
2745 /* If the ID is mine, ignore it. */
2746 if (SILC_ID_SERVER_COMPARE(id, server->id)) {
2747 SILC_LOG_DEBUG(("Ignoring my own ID as new ID"));
2751 /* If the ID is the sender's ID, ignore it (we have it already) */
2752 if (SILC_ID_SERVER_COMPARE(id, router->id)) {
2753 SILC_LOG_DEBUG(("Ignoring sender's own ID"));
2757 /* Check that we do not have this server already */
2758 entry = silc_idlist_find_server_by_id(server->global_list,
2759 id, server->server_type,
2762 entry = silc_idlist_find_server_by_id(server->local_list,
2763 id, server->server_type,
2766 SILC_LOG_DEBUG(("Ignoring server that we already have"));
2770 SILC_LOG_DEBUG(("New server id(%s) from [%s] %s",
2771 silc_id_render(id, SILC_ID_SERVER),
2772 sock->type == SILC_SOCKET_TYPE_SERVER ?
2773 "Server" : "Router", sock->hostname));
2775 /* As a router we keep information of all global information in our
2776 global list. Cell wide information however is kept in the local
2778 entry = silc_idlist_add_server(id_list, NULL, 0, id, router,
2781 SILC_LOG_ERROR(("Could not add new server to the ID Cache"));
2784 entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
2786 if (sock->type == SILC_SOCKET_TYPE_SERVER)
2787 server->stat.cell_servers++;
2788 server->stat.servers++;
2792 case SILC_ID_CHANNEL:
2793 SILC_LOG_ERROR(("Channel cannot be registered with NEW_ID packet"));
2802 /* If the sender of this packet is server and we are router we need to
2803 broadcast this packet to other routers in the network. */
2804 if (broadcast && server->server_type == SILC_ROUTER &&
2805 sock->type == SILC_SOCKET_TYPE_SERVER &&
2806 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2807 SILC_LOG_DEBUG(("Broadcasting received New ID packet"));
2808 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
2810 packet->flags | SILC_PACKET_FLAG_BROADCAST,
2811 buffer->data, buffer->len, FALSE);
2812 silc_server_backup_send(server, sock->user_data,
2813 packet->type, packet->flags,
2814 packet->buffer->data, packet->buffer->len,
2819 silc_id_payload_free(idp);
2823 /* Processes incoming New ID packet. New ID Payload is used to distribute
2824 information about newly registered clients and servers. */
2826 void silc_server_new_id(SilcServer server, SilcSocketConnection sock,
2827 SilcPacketContext *packet)
2829 silc_server_new_id_real(server, sock, packet, TRUE);
2832 /* Receoved New Id List packet, list of New ID payloads inside one
2833 packet. Process the New ID payloads one by one. */
2835 void silc_server_new_id_list(SilcServer server, SilcSocketConnection sock,
2836 SilcPacketContext *packet)
2838 SilcPacketContext *new_id;
2842 SILC_LOG_DEBUG(("Processing New ID List"));
2844 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2845 packet->src_id_type != SILC_ID_SERVER)
2848 /* If the sender of this packet is server and we are router we need to
2849 broadcast this packet to other routers in the network. Broadcast
2850 this list packet instead of multiple New ID packets. */
2851 if (server->server_type == SILC_ROUTER &&
2852 sock->type == SILC_SOCKET_TYPE_SERVER &&
2853 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2854 SILC_LOG_DEBUG(("Broadcasting received New ID List packet"));
2855 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
2857 packet->flags | SILC_PACKET_FLAG_BROADCAST,
2858 packet->buffer->data,
2859 packet->buffer->len, FALSE);
2860 silc_server_backup_send(server, sock->user_data,
2861 packet->type, packet->flags,
2862 packet->buffer->data, packet->buffer->len,
2866 /* Make copy of the original packet context, except for the actual
2867 data buffer, which we will here now fetch from the original buffer. */
2868 new_id = silc_packet_context_alloc();
2869 new_id->type = SILC_PACKET_NEW_ID;
2870 new_id->flags = packet->flags & (~SILC_PACKET_FLAG_LIST);
2871 new_id->src_id = packet->src_id;
2872 new_id->src_id_len = packet->src_id_len;
2873 new_id->src_id_type = packet->src_id_type;
2874 new_id->dst_id = packet->dst_id;
2875 new_id->dst_id_len = packet->dst_id_len;
2876 new_id->dst_id_type = packet->dst_id_type;
2878 idp = silc_buffer_alloc(256);
2879 new_id->buffer = idp;
2881 while (packet->buffer->len) {
2882 SILC_GET16_MSB(id_len, packet->buffer->data + 2);
2883 if ((id_len > packet->buffer->len) ||
2884 (id_len > idp->truelen))
2887 silc_buffer_pull_tail(idp, 4 + id_len);
2888 silc_buffer_put(idp, packet->buffer->data, 4 + id_len);
2890 /* Process the New ID */
2891 silc_server_new_id_real(server, sock, new_id, FALSE);
2893 silc_buffer_push_tail(idp, 4 + id_len);
2894 silc_buffer_pull(packet->buffer, 4 + id_len);
2897 silc_buffer_free(idp);
2901 /* Received New Channel packet. Information about new channels in the
2902 network are distributed using this packet. Save the information about
2903 the new channel. This usually comes from router but also normal server
2904 can send this to notify channels it has when it connects to us. */
2906 void silc_server_new_channel(SilcServer server,
2907 SilcSocketConnection sock,
2908 SilcPacketContext *packet)
2910 SilcChannelPayload payload;
2911 SilcChannelID *channel_id;
2913 SilcUInt32 name_len;
2915 SilcUInt32 id_len, cipher_len;
2916 SilcServerEntry server_entry;
2917 SilcChannelEntry channel;
2920 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2921 packet->src_id_type != SILC_ID_SERVER ||
2922 server->server_type == SILC_SERVER)
2925 /* Parse the channel payload */
2926 payload = silc_channel_payload_parse(packet->buffer->data,
2927 packet->buffer->len);
2931 /* Get the channel ID */
2932 channel_id = silc_channel_get_id_parse(payload);
2934 silc_channel_payload_free(payload);
2938 channel_name = silc_channel_get_name(payload, &name_len);
2940 channel_name[255] = '\0';
2942 id = silc_channel_get_id(payload, &id_len);
2944 server_entry = (SilcServerEntry)sock->user_data;
2946 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
2947 /* Add the channel to global list as it is coming from router. It
2948 cannot be our own channel as it is coming from router. */
2950 /* Check that we don't already have this channel */
2951 channel = silc_idlist_find_channel_by_name(server->local_list,
2952 channel_name, NULL);
2954 channel = silc_idlist_find_channel_by_name(server->global_list,
2955 channel_name, NULL);
2957 SILC_LOG_DEBUG(("New channel id(%s) from [Router] %s",
2958 silc_id_render(channel_id, SILC_ID_CHANNEL),
2962 silc_idlist_add_channel(server->global_list, strdup(channel_name),
2963 0, channel_id, sock->user_data, NULL, NULL, 0);
2965 silc_channel_payload_free(payload);
2966 silc_free(channel_id);
2969 channel->disabled = TRUE; /* Disabled until someone JOINs */
2971 server->stat.channels++;
2972 if (server->server_type == SILC_ROUTER)
2973 channel->users_resolved = TRUE;
2976 /* The channel is coming from our server, thus it is in our cell
2977 we will add it to our local list. */
2980 SILC_LOG_DEBUG(("Channel id(%s) from [Server] %s",
2981 silc_id_render(channel_id, SILC_ID_CHANNEL),
2984 /* Check that we don't already have this channel */
2985 channel = silc_idlist_find_channel_by_name(server->local_list,
2986 channel_name, NULL);
2988 channel = silc_idlist_find_channel_by_name(server->global_list,
2989 channel_name, NULL);
2991 /* If the channel does not exist, then create it. This creates a new
2992 key to the channel as well that we will send to the server. */
2994 SILC_LOG_DEBUG(("Channel is new to us"));
2996 /* The protocol says that the Channel ID's IP address must be based
2997 on the router's IP address. Check whether the ID is based in our
2998 IP and if it is not then create a new ID and enforce the server
2999 to switch the ID. */
3000 if (server_entry->server_type != SILC_BACKUP_ROUTER &&
3001 !SILC_ID_COMPARE(channel_id, server->id, server->id->ip.data_len)) {
3003 SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
3004 if (silc_id_create_channel_id(server, server->id, server->rng, &tmp)) {
3005 silc_server_send_notify_channel_change(server, sock, FALSE,
3007 silc_channel_payload_free(payload);
3008 silc_free(channel_id);
3012 /* Wait that server re-announces this channel */
3016 /* Create the channel with the provided Channel ID */
3017 channel = silc_server_create_new_channel_with_id(server, NULL, NULL,
3021 silc_channel_payload_free(payload);
3022 silc_free(channel_id);
3025 channel->disabled = TRUE; /* Disabled until someone JOINs */
3027 #if 0 /* We assume that CMODE_CHANGE notify is sent to us after this. */
3029 /* XXX Dunno if this is supposed to be set in any server type. If set
3030 here the CMODE_CHANGE that may follow sets mode that we already
3031 have, and we may loose data from the CMODE_CHANGE notify. */
3032 if (server_entry->server_type != SILC_BACKUP_ROUTER)
3033 channel->mode = silc_channel_get_mode(payload);
3036 /* Send the new channel key to the server */
3037 id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
3038 id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
3039 cipher = silc_cipher_get_name(channel->channel_key);
3040 cipher_len = strlen(cipher);
3041 chk = silc_channel_key_payload_encode(id_len, id,
3043 channel->key_len / 8,
3045 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
3046 chk->data, chk->len, FALSE);
3047 silc_buffer_free(chk);
3050 /* The channel exist by that name, check whether the ID's match.
3051 If they don't then we'll force the server to use the ID we have.
3052 We also create a new key for the channel. */
3053 SilcBuffer modes = NULL, users = NULL, users_modes = NULL;
3055 SILC_LOG_DEBUG(("Channel already exists"));
3057 if (!SILC_ID_CHANNEL_COMPARE(channel_id, channel->id)) {
3058 /* They don't match, send CHANNEL_CHANGE notify to the server to
3059 force the ID change. */
3060 SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
3061 silc_server_send_notify_channel_change(server, sock, FALSE,
3062 channel_id, channel->id);
3063 silc_channel_payload_free(payload);
3064 silc_free(channel_id);
3066 /* Wait that server re-announces this channel */
3070 #if 0 /* We will announce our CMODE anyway for this channel, so no need
3071 to check it (implicit enforce). */
3073 /* If the mode is different from what we have then enforce the
3075 mode = silc_channel_get_mode(payload);
3076 if (channel->mode != mode) {
3077 SILC_LOG_DEBUG(("Forcing the server to change channel mode"));
3078 silc_server_send_notify_cmode(server, sock, FALSE, channel,
3079 channel->mode, server->id,
3080 SILC_ID_SERVER, channel->cipher,
3082 channel->passphrase,
3083 channel->founder_key);
3087 /* Create new key for the channel and send it to the server and
3088 everybody else possibly on the channel. */
3089 if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
3091 if (silc_hash_table_count(channel->user_list)) {
3092 if (!silc_server_create_channel_key(server, channel, 0)) {
3093 silc_channel_payload_free(payload);
3094 silc_free(channel_id);
3098 /* Send to the channel */
3099 silc_server_send_channel_key(server, sock, channel, FALSE);
3102 /* Send to the server */
3103 id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
3104 id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
3105 cipher = silc_cipher_get_name(channel->channel_key);
3106 cipher_len = strlen(cipher);
3107 chk = silc_channel_key_payload_encode(id_len, id,
3109 channel->key_len / 8,
3111 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
3112 chk->data, chk->len, FALSE);
3113 silc_buffer_free(chk);
3117 silc_free(channel_id);
3119 /* Since the channel is coming from server and we also know about it
3120 then send the JOIN notify to the server so that it see's our
3121 users on the channel "joining" the channel. */
3122 silc_server_announce_get_channel_users(server, channel, &modes, &users,
3125 silc_buffer_push(users, users->data - users->head);
3126 silc_server_packet_send(server, sock,
3127 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
3128 users->data, users->len, FALSE);
3129 silc_buffer_free(users);
3132 silc_buffer_push(modes, modes->data - modes->head);
3133 silc_server_packet_send_dest(server, sock,
3134 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
3135 channel->id, SILC_ID_CHANNEL,
3136 modes->data, modes->len, FALSE);
3137 silc_buffer_free(modes);
3140 silc_buffer_push(users_modes, users_modes->data - users_modes->head);
3141 silc_server_packet_send_dest(server, sock,
3142 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
3143 channel->id, SILC_ID_CHANNEL,
3145 users_modes->len, FALSE);
3146 silc_buffer_free(users_modes);
3148 if (channel->topic) {
3149 silc_server_send_notify_topic_set(server, sock,
3150 server->server_type == SILC_ROUTER ?
3151 TRUE : FALSE, channel,
3152 server->id, SILC_ID_SERVER,
3158 /* If the sender of this packet is server and we are router we need to
3159 broadcast this packet to other routers in the network. Broadcast
3160 this list packet instead of multiple New Channel packets. */
3161 if (server->server_type == SILC_ROUTER &&
3162 sock->type == SILC_SOCKET_TYPE_SERVER &&
3163 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
3164 SILC_LOG_DEBUG(("Broadcasting received New Channel packet"));
3165 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3167 packet->flags | SILC_PACKET_FLAG_BROADCAST,
3168 packet->buffer->data,
3169 packet->buffer->len, FALSE);
3170 silc_server_backup_send(server, sock->user_data,
3171 packet->type, packet->flags,
3172 packet->buffer->data, packet->buffer->len,
3176 silc_channel_payload_free(payload);
3179 /* Received New Channel List packet, list of New Channel List payloads inside
3180 one packet. Process the New Channel payloads one by one. */
3182 void silc_server_new_channel_list(SilcServer server,
3183 SilcSocketConnection sock,
3184 SilcPacketContext *packet)
3186 SilcPacketContext *new;
3188 SilcUInt16 len1, len2;
3190 SILC_LOG_DEBUG(("Processing New Channel List"));
3192 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
3193 packet->src_id_type != SILC_ID_SERVER ||
3194 server->server_type == SILC_SERVER)
3197 /* Make copy of the original packet context, except for the actual
3198 data buffer, which we will here now fetch from the original buffer. */
3199 new = silc_packet_context_alloc();
3200 new->type = SILC_PACKET_NEW_CHANNEL;
3201 new->flags = packet->flags & (~SILC_PACKET_FLAG_LIST);
3202 new->src_id = packet->src_id;
3203 new->src_id_len = packet->src_id_len;
3204 new->src_id_type = packet->src_id_type;
3205 new->dst_id = packet->dst_id;
3206 new->dst_id_len = packet->dst_id_len;
3207 new->dst_id_type = packet->dst_id_type;
3209 buffer = silc_buffer_alloc(512);
3210 new->buffer = buffer;
3212 while (packet->buffer->len) {
3213 SILC_GET16_MSB(len1, packet->buffer->data);
3214 if ((len1 > packet->buffer->len) ||
3215 (len1 > buffer->truelen))
3218 SILC_GET16_MSB(len2, packet->buffer->data + 2 + len1);
3219 if ((len2 > packet->buffer->len) ||
3220 (len2 > buffer->truelen))
3223 silc_buffer_pull_tail(buffer, 8 + len1 + len2);
3224 silc_buffer_put(buffer, packet->buffer->data, 8 + len1 + len2);
3226 /* Process the New Channel */
3227 silc_server_new_channel(server, sock, new);
3229 silc_buffer_push_tail(buffer, 8 + len1 + len2);
3230 silc_buffer_pull(packet->buffer, 8 + len1 + len2);
3233 silc_buffer_free(buffer);
3237 /* Received key agreement packet. This packet is never for us. It is to
3238 the client in the packet's destination ID. Sending of this sort of packet
3239 equals sending private message, ie. it is sent point to point from
3240 one client to another. */
3242 void silc_server_key_agreement(SilcServer server,
3243 SilcSocketConnection sock,
3244 SilcPacketContext *packet)
3246 SilcSocketConnection dst_sock;
3247 SilcIDListData idata;
3249 SILC_LOG_DEBUG(("Start"));
3251 if (packet->src_id_type != SILC_ID_CLIENT ||
3252 packet->dst_id_type != SILC_ID_CLIENT)
3255 if (!packet->dst_id)
3258 /* Get the route to the client */
3259 dst_sock = silc_server_get_client_route(server, packet->dst_id,
3260 packet->dst_id_len, NULL,
3265 /* Relay the packet */
3266 silc_server_relay_packet(server, dst_sock, idata->send_key,
3267 idata->hmac_send, idata->psn_send++,
3271 /* Received connection auth request packet that is used during connection
3272 phase to resolve the mandatory authentication method. This packet can
3273 actually be received at anytime but usually it is used only during
3274 the connection authentication phase. Now, protocol says that this packet
3275 can come from client or server, however, we support only this coming
3276 from client and expect that server always knows what authentication
3279 void silc_server_connection_auth_request(SilcServer server,
3280 SilcSocketConnection sock,
3281 SilcPacketContext *packet)
3283 SilcServerConfigClient *client = NULL;
3284 SilcUInt16 conn_type;
3286 SilcAuthMethod auth_meth = SILC_AUTH_NONE;
3288 if (packet->src_id_type && packet->src_id_type != SILC_ID_CLIENT) {
3289 SILC_LOG_DEBUG(("Request not from client"));
3293 /* Parse the payload */
3294 ret = silc_buffer_unformat(packet->buffer,
3295 SILC_STR_UI_SHORT(&conn_type),
3296 SILC_STR_UI_SHORT(NULL),
3301 if (conn_type != SILC_SOCKET_TYPE_CLIENT)
3304 /* Get the authentication method for the client */
3305 auth_meth = SILC_AUTH_NONE;
3306 client = silc_server_config_find_client(server, sock->ip);
3308 client = silc_server_config_find_client(server, sock->hostname);
3310 if (client->passphrase) {
3311 if (client->publickeys && !server->config->prefer_passphrase_auth)
3312 auth_meth = SILC_AUTH_PUBLIC_KEY;
3314 auth_meth = SILC_AUTH_PASSWORD;
3315 } else if (client->publickeys)
3316 auth_meth = SILC_AUTH_PUBLIC_KEY;
3319 SILC_LOG_DEBUG(("Authentication method is [%s]",
3320 (auth_meth == SILC_AUTH_NONE ? "None" :
3321 auth_meth == SILC_AUTH_PASSWORD ? "Passphrase" :
3322 "Digital signatures")));
3324 /* Send it back to the client */
3325 silc_server_send_connection_auth_request(server, sock, conn_type, auth_meth);
3328 /* Received REKEY packet. The sender of the packet wants to regenerate
3329 its session keys. This starts the REKEY protocol. */
3331 void silc_server_rekey(SilcServer server,
3332 SilcSocketConnection sock,
3333 SilcPacketContext *packet)
3335 SilcProtocol protocol;
3336 SilcServerRekeyInternalContext *proto_ctx;
3337 SilcIDListData idata = (SilcIDListData)sock->user_data;
3339 SILC_LOG_DEBUG(("Start"));
3341 /* Allocate internal protocol context. This is sent as context
3343 proto_ctx = silc_calloc(1, sizeof(*proto_ctx));
3344 proto_ctx->server = (void *)server;
3345 proto_ctx->sock = sock;
3346 proto_ctx->responder = TRUE;
3347 proto_ctx->pfs = idata->rekey->pfs;
3349 /* Perform rekey protocol. Will call the final callback after the
3350 protocol is over. */
3351 silc_protocol_alloc(SILC_PROTOCOL_SERVER_REKEY,
3352 &protocol, proto_ctx, silc_server_rekey_final);
3353 sock->protocol = protocol;
3355 if (proto_ctx->pfs == FALSE)
3356 /* Run the protocol */
3357 silc_protocol_execute(protocol, server->schedule, 0, 0);
3360 /* Received file transger packet. This packet is never for us. It is to
3361 the client in the packet's destination ID. Sending of this sort of packet
3362 equals sending private message, ie. it is sent point to point from
3363 one client to another. */
3365 void silc_server_ftp(SilcServer server,
3366 SilcSocketConnection sock,
3367 SilcPacketContext *packet)
3369 SilcSocketConnection dst_sock;
3370 SilcIDListData idata;
3372 SILC_LOG_DEBUG(("Start"));
3374 if (packet->src_id_type != SILC_ID_CLIENT ||
3375 packet->dst_id_type != SILC_ID_CLIENT)
3378 if (!packet->dst_id)
3381 /* Get the route to the client */
3382 dst_sock = silc_server_get_client_route(server, packet->dst_id,
3383 packet->dst_id_len, NULL,
3388 /* Relay the packet */
3389 silc_server_relay_packet(server, dst_sock, idata->send_key,
3390 idata->hmac_send, idata->psn_send++,
3396 SilcSocketConnection sock;
3397 SilcPacketContext *packet;
3399 } *SilcServerResumeResolve;
3401 SILC_SERVER_CMD_FUNC(resume_resolve)
3403 SilcServerResumeResolve r = (SilcServerResumeResolve)context;
3404 SilcServer server = r->server;
3405 SilcSocketConnection sock = r->sock;
3406 SilcServerCommandReplyContext reply = context2;
3407 SilcClientEntry client;
3409 SILC_LOG_DEBUG(("Start"));
3411 if (!reply || !silc_command_get_status(reply->payload, NULL, NULL)) {
3412 SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
3413 "closing connection", sock->hostname, sock->ip));
3414 silc_server_disconnect_remote(server, sock,
3415 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3416 "Resuming not possible");
3417 if (sock->user_data)
3418 silc_server_free_sock_user_data(server, sock, NULL);
3422 if (reply && silc_command_get(reply->payload) == SILC_COMMAND_WHOIS) {
3423 /* Get entry to the client, and resolve it if we don't have it. */
3424 client = silc_idlist_find_client_by_id(server->local_list,
3425 r->data, TRUE, NULL);
3427 client = silc_idlist_find_client_by_id(server->global_list,
3428 r->data, TRUE, NULL);
3430 SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
3431 "closing connection", sock->hostname, sock->ip));
3432 silc_server_disconnect_remote(server, sock,
3433 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3434 "Resuming not possible");
3435 if (sock->user_data)
3436 silc_server_free_sock_user_data(server, sock, NULL);
3441 if (!(client->mode & SILC_UMODE_DETACHED)) {
3442 SILC_LOG_ERROR(("Client %s (%s) tried to resume un-detached client, "
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);
3452 client->data.status |= SILC_IDLIST_STATUS_RESUME_RES;
3455 /* Reprocess the packet */
3456 silc_server_resume_client(server, sock, r->packet);
3459 silc_socket_free(r->sock);
3460 silc_packet_context_free(r->packet);
3465 /* Received client resuming packet. This is used to resume detached
3466 client session. It can be sent by the client who wishes to resume
3467 but this is also sent by servers and routers to notify other routers
3468 that the client is not detached anymore. */
3470 void silc_server_resume_client(SilcServer server,
3471 SilcSocketConnection sock,
3472 SilcPacketContext *packet)
3474 SilcBuffer buffer = packet->buffer, buf;
3475 SilcIDListData idata;
3476 SilcIDCacheEntry id_cache = NULL;
3477 SilcClientEntry detached_client;
3478 SilcClientID *client_id = NULL;
3479 unsigned char *id_string, *auth = NULL;
3480 SilcUInt16 id_len, auth_len = 0;
3481 int ret, nickfail = 0;
3482 bool resolved, local, nick_change = FALSE, resolve = FALSE;
3483 SilcChannelEntry channel;
3484 SilcHashTableList htl;
3485 SilcChannelClientEntry chl;
3486 SilcServerResumeResolve r;
3489 ret = silc_buffer_unformat(buffer,
3490 SILC_STR_UI16_NSTRING(&id_string, &id_len),
3493 client_id = silc_id_str2id(id_string, id_len, SILC_ID_CLIENT);
3495 if (sock->type == SILC_SOCKET_TYPE_CLIENT) {
3496 /* Client send this and is attempting to resume to old client session */
3497 SilcClientEntry client;
3501 silc_buffer_pull(buffer, 2 + id_len);
3502 auth = buffer->data;
3503 auth_len = buffer->len;
3504 silc_buffer_push(buffer, 2 + id_len);
3507 if (!client_id || auth_len < 128) {
3508 SILC_LOG_ERROR(("Client %s (%s) sent incomplete resume information, "
3509 "closing connection", sock->hostname, sock->ip));
3510 silc_server_disconnect_remote(server, sock,
3511 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3512 "Resuming not possible");
3513 if (sock->user_data)
3514 silc_server_free_sock_user_data(server, sock, NULL);
3515 silc_free(client_id);
3519 /* Take client entry of this connection */
3520 client = (SilcClientEntry)sock->user_data;
3521 idata = (SilcIDListData)client;
3523 /* Get entry to the client, and resolve it if we don't have it. */
3524 detached_client = silc_server_query_client(server, client_id, FALSE,
3526 if (!detached_client) {
3528 /* The client info is being resolved. Reprocess this packet after
3529 receiving the reply to the query. */
3530 SILC_LOG_DEBUG(("Resolving client"));
3531 r = silc_calloc(1, sizeof(*r));
3535 r->sock = silc_socket_dup(sock);
3536 r->packet = silc_packet_context_dup(packet);
3537 r->data = client_id;
3538 silc_server_command_pending(server, SILC_COMMAND_WHOIS,
3540 silc_server_command_resume_resolve, r);
3542 SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
3543 "closing connection", sock->hostname, sock->ip));
3544 silc_server_disconnect_remote(server, sock,
3545 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3546 "Resuming not possible");
3547 if (sock->user_data)
3548 silc_server_free_sock_user_data(server, sock, NULL);
3549 silc_free(client_id);
3554 if (!(detached_client->mode & SILC_UMODE_DETACHED))
3556 if (!silc_hash_table_count(detached_client->channels) &&
3557 detached_client->router)
3559 if (!detached_client->nickname)
3561 if (detached_client->data.status & SILC_IDLIST_STATUS_RESUME_RES)
3565 if (server->server_type == SILC_SERVER && !server->standalone) {
3566 /* The client info is being resolved. Reprocess this packet after
3567 receiving the reply to the query. */
3568 SILC_LOG_DEBUG(("Resolving client info"));
3569 silc_server_query_client(server, client_id, TRUE, NULL);
3570 r = silc_calloc(1, sizeof(*r));
3574 r->sock = silc_socket_dup(sock);
3575 r->packet = silc_packet_context_dup(packet);
3576 r->data = client_id;
3577 silc_server_command_pending(server, SILC_COMMAND_WHOIS,
3579 silc_server_command_resume_resolve, r);
3582 if (server->server_type == SILC_SERVER) {
3583 SILC_LOG_ERROR(("Client %s (%s) tried to resume un-detached client, "
3584 "closing connection", sock->hostname, sock->ip));
3585 silc_server_disconnect_remote(server, sock,
3586 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3587 "Resuming not possible");
3588 if (sock->user_data)
3589 silc_server_free_sock_user_data(server, sock, NULL);
3590 silc_free(client_id);
3595 /* Check that we have the public key of the client, if not then we must
3596 resolve it first. */
3597 if (!detached_client->data.public_key) {
3598 if (server->server_type == SILC_SERVER && server->standalone) {
3599 SILC_LOG_ERROR(("Detached client's public key not present, "
3600 "closing connection"));
3601 silc_server_disconnect_remote(server, sock,
3602 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3603 "Resuming not possible");
3604 if (sock->user_data)
3605 silc_server_free_sock_user_data(server, sock, NULL);
3606 silc_free(client_id);
3608 /* We must retrieve the detached client's public key by sending
3609 GETKEY command. Reprocess this packet after receiving the key */
3610 SilcBuffer idp = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
3611 SilcSocketConnection dest_sock =
3612 silc_server_get_client_route(server, NULL, 0, client_id, NULL, NULL);
3614 SILC_LOG_DEBUG(("Resolving client public key"));
3616 silc_server_send_command(server, dest_sock ? dest_sock :
3617 SILC_PRIMARY_ROUTE(server),
3618 SILC_COMMAND_GETKEY, ++server->cmd_ident,
3619 1, 1, idp->data, idp->len);
3621 r = silc_calloc(1, sizeof(*r));
3623 silc_free(client_id);
3628 r->sock = silc_socket_dup(sock);
3629 r->packet = silc_packet_context_dup(packet);
3630 silc_server_command_pending(server, SILC_COMMAND_GETKEY,
3632 silc_server_command_resume_resolve, r);
3634 silc_buffer_free(idp);
3636 silc_free(client_id);
3638 } else if (!silc_pkcs_public_key_compare(detached_client->data.public_key,
3639 idata->public_key)) {
3640 /* We require that the connection and resuming authentication data
3641 must be using same key pair. */
3642 SILC_LOG_ERROR(("Resuming attempted with wrong public key, "
3643 "closing connection"));
3644 silc_server_disconnect_remote(server, sock,
3645 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3646 "Resuming not possible");
3647 if (sock->user_data)
3648 silc_server_free_sock_user_data(server, sock, NULL);
3649 silc_free(client_id);
3653 /* Verify the authentication payload. This has to be successful in
3654 order to allow the resuming */
3656 !silc_auth_verify_data(auth, auth_len, SILC_AUTH_PUBLIC_KEY,
3657 detached_client->data.public_key, 0,
3658 idata->hash, detached_client->id,
3660 SILC_LOG_ERROR(("Client %s (%s) resume authentication failed, "
3661 "closing connection", sock->hostname, sock->ip));
3662 silc_server_disconnect_remote(server, sock,
3663 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3664 "Resuming not possible");
3665 if (sock->user_data)
3666 silc_server_free_sock_user_data(server, sock, NULL);
3667 silc_free(client_id);
3671 /* Now resume the client to the network */
3673 silc_schedule_task_del_by_context(server->schedule, detached_client);
3674 sock->user_data = detached_client;
3675 detached_client->connection = sock;
3677 /* Take new keys and stuff into use in the old entry */
3678 silc_idlist_del_data(detached_client);
3679 silc_idlist_add_data(detached_client, idata);
3680 detached_client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
3681 detached_client->data.status |= SILC_IDLIST_STATUS_RESUMED;
3682 detached_client->data.status |= SILC_IDLIST_STATUS_LOCAL;
3683 detached_client->data.status &= ~SILC_IDLIST_STATUS_RESUME_RES;
3684 detached_client->mode &= ~SILC_UMODE_DETACHED;
3685 server->stat.my_detached--;
3687 /* Send the RESUME_CLIENT packet to our primary router so that others
3688 know this client isn't detached anymore. */
3689 buf = silc_buffer_alloc_size(2 + id_len);
3690 silc_buffer_format(buf,
3691 SILC_STR_UI_SHORT(id_len),
3692 SILC_STR_UI_XNSTRING(id_string, id_len),
3695 /* Send to primary router */
3696 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3697 SILC_PACKET_RESUME_CLIENT, 0,
3698 buf->data, buf->len, TRUE);
3699 silc_server_backup_send(server, detached_client->router,
3700 SILC_PACKET_RESUME_CLIENT, 0,
3701 buf->data, buf->len, TRUE, TRUE);
3703 /* As router we must deliver this packet directly to the original
3704 server whom this client was earlier. */
3705 if (server->server_type == SILC_ROUTER && detached_client->router &&
3706 detached_client->router->server_type != SILC_ROUTER)
3707 silc_server_packet_send(server, detached_client->router->connection,
3708 SILC_PACKET_RESUME_CLIENT, 0,
3709 buf->data, buf->len, TRUE);
3710 silc_buffer_free(buf);
3712 detached_client->router = NULL;
3714 /* Delete this client entry since we're resuming to old one. */
3715 server->stat.my_clients--;
3716 server->stat.clients--;
3717 if (server->stat.cell_clients)
3718 server->stat.cell_clients--;
3719 silc_server_remove_from_channels(server, NULL, client, FALSE,
3720 NULL, FALSE, FALSE);
3721 silc_server_del_from_watcher_list(server, client);
3722 if (!silc_idlist_del_client(server->local_list, client))
3723 silc_idlist_del_client(server->global_list, client);
3724 client = detached_client;
3725 silc_free(client->servername);
3726 client->servername = strdup(server->server_name);
3728 /* If the ID is not based in our ID then change it */
3729 if (!SILC_ID_COMPARE(client->id, server->id, server->id->ip.data_len)) {
3730 silc_free(client_id);
3731 while (!silc_id_create_client_id(server, server->id, server->rng,
3732 server->md5hash, client->nickname,
3736 silc_server_disconnect_remote(server, sock,
3737 SILC_STATUS_ERR_BAD_NICKNAME, NULL);
3738 if (sock->user_data)
3739 silc_server_free_sock_user_data(server, sock, NULL);
3742 snprintf(&client->nickname[strlen(client->nickname) - 1], 1,
3749 /* Notify about Client ID change, nickname doesn't actually change. */
3750 silc_server_send_notify_nick_change(server, SILC_PRIMARY_ROUTE(server),
3751 SILC_BROADCAST(server),
3752 client->id, client_id,
3756 /* Resolve users on those channels that client has joined but we
3757 haven't resolved user list yet. */
3758 if (server->server_type == SILC_SERVER && !server->standalone) {
3759 silc_hash_table_list(client->channels, &htl);
3760 while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
3761 channel = chl->channel;
3762 SILC_LOG_DEBUG(("Resolving users for %s channel",
3763 channel->channel_name));
3764 if (channel->disabled || !channel->users_resolved) {
3765 silc_server_send_command(server, SILC_PRIMARY_ROUTE(server),
3766 SILC_COMMAND_USERS, ++server->cmd_ident,
3767 1, 2, channel->channel_name,
3768 strlen(channel->channel_name));
3771 silc_hash_table_list_reset(&htl);
3774 /* Send the new client ID to the client. After this client may start
3775 receiving other packets, and may start sending packets too. */
3776 silc_server_send_new_id(server, sock, FALSE, client_id, SILC_ID_CLIENT,
3777 silc_id_get_len(client_id, SILC_ID_CLIENT));
3780 /* Send NICK change notify to channels as well. */
3781 SilcBuffer oidp, nidp;
3782 oidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
3783 nidp = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
3784 silc_server_send_notify_on_channels(server, NULL, client,
3785 SILC_NOTIFY_TYPE_NICK_CHANGE, 3,
3786 oidp->data, oidp->len,
3787 nidp->data, nidp->len,
3789 strlen(client->nickname));
3790 silc_buffer_free(oidp);
3791 silc_buffer_free(nidp);
3794 /* Add the client again to the ID cache to get it to correct list */
3795 if (!silc_idcache_del_by_context(server->local_list->clients, client))
3796 silc_idcache_del_by_context(server->global_list->clients, client);
3797 silc_free(client->id);
3798 client->id = client_id;
3800 silc_idcache_add(server->local_list->clients, client->nickname,
3801 client->id, client, 0, NULL);
3803 /* Send some nice info to the client */
3804 silc_server_send_connect_notifys(server, sock, client);
3806 /* Send all channel keys of channels the client has joined */
3807 silc_hash_table_list(client->channels, &htl);
3808 while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
3809 bool created = FALSE;
3810 channel = chl->channel;
3812 if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY)
3815 /* If we don't have channel key, then create one */
3816 if (!channel->channel_key) {
3817 if (!silc_server_create_channel_key(server, channel, 0))
3822 id_string = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
3823 cipher = silc_cipher_get_name(channel->channel_key);
3825 silc_channel_key_payload_encode(silc_id_get_len(channel->id,
3828 strlen(cipher), cipher,
3829 channel->key_len / 8, channel->key);
3830 silc_free(id_string);
3832 /* Send the channel key to the client */
3833 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
3834 keyp->data, keyp->len, FALSE);
3836 /* Distribute the channel key to channel */
3838 silc_server_send_channel_key(server, NULL, channel,
3839 server->server_type == SILC_ROUTER ?
3840 FALSE : !server->standalone);
3841 silc_server_backup_send(server, NULL, SILC_PACKET_CHANNEL_KEY, 0,
3842 keyp->data, keyp->len, FALSE, TRUE);
3845 silc_buffer_free(keyp);
3847 silc_hash_table_list_reset(&htl);
3849 } else if (sock->type != SILC_SOCKET_TYPE_CLIENT) {
3850 /* Server or router sent this to us to notify that that a client has
3852 SilcServerEntry server_entry;
3853 SilcServerID *server_id;
3856 SILC_LOG_DEBUG(("Malformed resuming packet"));
3860 /* Get entry to the client, and resolve it if we don't have it. */
3861 detached_client = silc_idlist_find_client_by_id(server->local_list,
3864 if (!detached_client) {
3865 detached_client = silc_idlist_find_client_by_id(server->global_list,
3868 if (!detached_client) {
3869 SILC_LOG_DEBUG(("Resuming client is unknown"));
3870 silc_free(client_id);
3875 /* Check that the client has not been resumed already because it is
3876 protocol error to attempt to resume more than once. The client
3877 will be killed if this protocol error occurs. */
3878 if (detached_client->data.status & SILC_IDLIST_STATUS_RESUMED &&
3879 !(detached_client->mode & SILC_UMODE_DETACHED)) {
3880 /* The client is clearly attempting to resume more than once and
3881 perhaps playing around by resuming from several different places
3882 at the same time. */
3883 SILC_LOG_DEBUG(("Attempting to re-resume client, killing both"));
3884 silc_server_kill_client(server, detached_client, NULL,
3885 server->id, SILC_ID_SERVER);
3886 silc_free(client_id);
3890 /* Check whether client is detached at all */
3891 if (!(detached_client->mode & SILC_UMODE_DETACHED)) {
3892 SILC_LOG_DEBUG(("Client is not detached"));
3893 silc_free(client_id);
3897 SILC_LOG_DEBUG(("Resuming detached client"));
3899 /* If the sender of this packet is server and we are router we need to
3900 broadcast this packet to other routers in the network. */
3901 if (server->server_type == SILC_ROUTER &&
3902 sock->type == SILC_SOCKET_TYPE_SERVER &&
3903 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
3904 SILC_LOG_DEBUG(("Broadcasting received Resume Client packet"));
3905 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3907 packet->flags | SILC_PACKET_FLAG_BROADCAST,
3908 buffer->data, buffer->len, FALSE);
3909 silc_server_backup_send(server, sock->user_data,
3910 packet->type, packet->flags,
3911 packet->buffer->data, packet->buffer->len,
3915 /* Client is detached, and now it is resumed. Remove the detached
3916 mode and mark that it is resumed. */
3917 silc_idlist_del_data(detached_client);
3918 detached_client->mode &= ~SILC_UMODE_DETACHED;
3919 detached_client->data.status |= SILC_IDLIST_STATUS_RESUMED;
3920 detached_client->data.status &= ~SILC_IDLIST_STATUS_LOCAL;
3921 id_cache->expire = 0;
3923 silc_schedule_task_del_by_context(server->schedule, detached_client);
3925 /* Get the new owner of the resumed client */
3926 server_id = silc_id_str2id(packet->src_id, packet->src_id_len,
3927 packet->src_id_type);
3929 silc_free(client_id);
3933 /* Get server entry */
3934 server_entry = silc_idlist_find_server_by_id(server->global_list,
3935 server_id, TRUE, NULL);
3937 if (!server_entry) {
3938 server_entry = silc_idlist_find_server_by_id(server->local_list,
3939 server_id, TRUE, NULL);
3941 if (!server_entry) {
3942 silc_free(server_id);
3943 silc_free(client_id);
3948 if (server->server_type == SILC_ROUTER &&
3949 sock->type == SILC_SOCKET_TYPE_ROUTER &&
3950 server_entry->server_type == SILC_ROUTER)
3953 /* Change the client to correct list. */
3954 if (!silc_idcache_del_by_context(server->local_list->clients,
3956 silc_idcache_del_by_context(server->global_list->clients,
3958 silc_idcache_add(local && server->server_type == SILC_ROUTER ?
3959 server->local_list->clients :
3960 server->global_list->clients,
3961 detached_client->nickname,
3962 detached_client->id, detached_client, FALSE, NULL);
3964 /* Change the owner of the client */
3965 detached_client->router = server_entry;
3967 /* Update channel information regarding global clients on channel. */
3968 if (server->server_type != SILC_ROUTER) {
3969 silc_hash_table_list(detached_client->channels, &htl);
3970 while (silc_hash_table_get(&htl, NULL, (void **)&chl))
3971 chl->channel->global_users =
3972 silc_server_channel_has_global(chl->channel);
3973 silc_hash_table_list_reset(&htl);
3976 silc_free(server_id);
3979 silc_free(client_id);