5 Author: Pekka Riikonen <priikone@silcnet.org>
7 Copyright (C) 1997 - 2007 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 #include "serverincludes.h"
22 #include "server_internal.h"
25 /* Received notify packet. Server can receive notify packets from router.
26 Server then relays the notify messages to clients if needed. */
28 static void silc_server_notify_process(SilcServer server,
29 SilcPacketStream sock,
33 SilcIDListData idata = silc_packet_get_context(sock);
34 SilcNotifyPayload payload;
36 SilcArgumentPayload args;
37 SilcChannelID channel_id;
39 SilcChannelEntry channel = NULL;
40 SilcClientEntry client = NULL, client2 = NULL;
41 SilcServerEntry server_entry = NULL;
42 SilcChannelClientEntry chl;
43 SilcIDCacheEntry cache = NULL;
44 SilcHashTableList htl;
46 unsigned char *tmp, *tmp2;
47 SilcUInt32 tmp_len, tmp2_len;
50 if (idata->conn_type == SILC_CONN_CLIENT) {
51 SILC_LOG_DEBUG(("Notify received from client, drop it"));
55 if (packet->src_id_type != SILC_ID_SERVER){
56 SILC_LOG_DEBUG(("Bad notify packet received"));
60 if (!packet->dst_id) {
61 SILC_LOG_DEBUG(("Bad notify packet received"));
65 /* If the packet is destined directly to a client then relay the packet
66 before processing it. */
67 if (packet->dst_id_type == SILC_ID_CLIENT) {
69 SilcPacketStream dst_sock;
71 /* Get the route to the client */
72 dst_sock = silc_server_get_client_route(server, packet->dst_id,
73 packet->dst_id_len, NULL,
76 /* Relay the packet */
77 silc_server_packet_route(server, dst_sock, packet);
80 /* Parse the Notify Payload */
81 payload = silc_notify_payload_parse(buffer->data, silc_buffer_len(buffer));
83 SILC_LOG_DEBUG(("Marlformed notify payload"));
87 /* If we are router and this packet is not already broadcast packet
88 we will broadcast it. The sending socket really cannot be router or
89 the router is buggy. If this packet is coming from router then it must
90 have the broadcast flag set already and we won't do anything. */
91 if (server->server_type == SILC_ROUTER &&
92 idata->conn_type == SILC_CONN_SERVER &&
93 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
94 SILC_LOG_DEBUG(("Broadcasting received Notify packet"));
95 if (packet->dst_id_type == SILC_ID_CHANNEL) {
96 /* Packet is destined to channel */
97 if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
98 packet->dst_id_type, &channel_id,
99 sizeof(channel_id))) {
100 SILC_LOG_DEBUG(("Malformed destination ID in notify packet"));
104 silc_server_packet_send_dest(server, SILC_PRIMARY_ROUTE(server),
105 packet->type, packet->flags |
106 SILC_PACKET_FLAG_BROADCAST,
107 &channel_id, SILC_ID_CHANNEL,
108 buffer->data, silc_buffer_len(buffer));
109 silc_server_backup_send_dest(server, (SilcServerEntry)idata,
110 packet->type, packet->flags,
111 &channel_id, SILC_ID_CHANNEL,
112 buffer->data, silc_buffer_len(buffer),
115 /* Packet is destined to client or server */
116 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
118 packet->flags | SILC_PACKET_FLAG_BROADCAST,
119 buffer->data, silc_buffer_len(buffer));
120 silc_server_backup_send(server, (SilcServerEntry)idata,
121 packet->type, packet->flags,
122 buffer->data, silc_buffer_len(buffer),
127 type = silc_notify_get_type(payload);
128 args = silc_notify_get_args(payload);
130 SILC_LOG_DEBUG(("Notify doesn't have any arguments, drop it"));
135 case SILC_NOTIFY_TYPE_JOIN:
137 * Distribute the notify to local clients on the channel
139 SILC_LOG_DEBUG(("JOIN notify"));
142 if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL))
145 /* Get channel entry */
146 channel = silc_idlist_find_channel_by_id(server->global_list,
147 SILC_ID_GET_ID(id), NULL);
149 channel = silc_idlist_find_channel_by_id(server->local_list,
150 SILC_ID_GET_ID(id), NULL);
152 SILC_LOG_DEBUG(("Notify for unknown channel %s",
153 silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
159 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
162 /* If the the client is not in local list we check global list (ie. the
163 channel will be global channel) and if it does not exist then create
164 entry for the client. */
165 client = silc_idlist_find_client_by_id(server->global_list,
170 client = silc_idlist_find_client_by_id(server->local_list,
175 /* If router did not find the client the it is bogus */
176 if (server->server_type != SILC_SERVER)
180 silc_idlist_add_client(server->global_list, NULL, NULL, NULL,
181 silc_id_dup(SILC_ID_GET_ID(id),
183 (SilcServerEntry)idata, NULL);
185 SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
189 client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
193 /* Do not process the notify if the client is not registered */
194 if (!(client->data.status & SILC_IDLIST_STATUS_REGISTERED))
197 /* Do not add client to channel if it is there already */
198 if (silc_server_client_on_channel(client, channel, NULL)) {
199 SILC_LOG_DEBUG(("Client already on channel %s",
200 channel->channel_name));
204 /* Send to channel */
205 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
206 FALSE, TRUE, buffer->data,
207 silc_buffer_len(buffer));
209 if (server->server_type != SILC_ROUTER &&
210 idata->conn_type == SILC_CONN_ROUTER)
211 /* The channel is global now */
212 channel->global_users = TRUE;
214 SILC_LOG_DEBUG(("Joining to channel %s", channel->channel_name));
216 /* JOIN the global client to the channel (local clients (if router
217 created the channel) is joined in the pending JOIN command). */
218 chl = silc_calloc(1, sizeof(*chl));
221 chl->client = client;
222 chl->channel = channel;
224 if (server->server_type != SILC_ROUTER ||
225 idata->conn_type == SILC_CONN_ROUTER) {
226 /* If founder auth is set, first client is not automatically founder. */
227 if (!(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
228 /* If this is the first one on the channel then it is the founder of
229 the channel. This is done on normal server and on router if this
230 notify is coming from router */
231 if (!silc_hash_table_count(channel->user_list)) {
232 SILC_LOG_DEBUG(("Client %s is founder on channel",
233 silc_id_render(chl->client->id, SILC_ID_CLIENT)));
234 chl->mode = (SILC_CHANNEL_UMODE_CHANOP | SILC_CHANNEL_UMODE_CHANFO);
239 silc_hash_table_add(channel->user_list, client, chl);
240 silc_hash_table_add(client->channels, channel, chl);
241 channel->user_count++;
242 channel->disabled = FALSE;
244 /* Update statistics */
245 if (server->server_type == SILC_ROUTER) {
246 if (idata->conn_type != SILC_CONN_ROUTER)
247 server->stat.cell_chanclients++;
248 server->stat.chanclients++;
253 case SILC_NOTIFY_TYPE_LEAVE:
255 * Distribute the notify to local clients on the channel
257 SILC_LOG_DEBUG(("LEAVE notify"));
259 if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
260 packet->dst_id_type, &channel_id,
264 /* Get channel entry */
265 channel = silc_idlist_find_channel_by_id(server->global_list,
268 channel = silc_idlist_find_channel_by_id(server->local_list,
271 SILC_LOG_DEBUG(("Notify for unknown channel %s",
272 silc_id_render(&channel_id, SILC_ID_CHANNEL)));
278 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
281 /* Get client entry */
282 client = silc_idlist_find_client_by_id(server->global_list,
283 SILC_ID_GET_ID(id), TRUE, NULL);
285 client = silc_idlist_find_client_by_id(server->local_list,
286 SILC_ID_GET_ID(id), TRUE, NULL);
291 /* Check if on channel */
292 if (!silc_server_client_on_channel(client, channel, NULL))
295 /* Send the leave notify to channel */
296 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
297 FALSE, TRUE, buffer->data,
298 silc_buffer_len(buffer));
300 /* Remove the user from channel */
301 silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
304 case SILC_NOTIFY_TYPE_SIGNOFF:
306 * Distribute the notify to local clients on the channel
308 SILC_LOG_DEBUG(("SIGNOFF notify"));
311 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
314 /* Get client entry */
315 client = silc_idlist_find_client_by_id(server->global_list,
316 SILC_ID_GET_ID(id), TRUE, &cache);
318 client = silc_idlist_find_client_by_id(server->local_list,
319 SILC_ID_GET_ID(id), TRUE, &cache);
324 /* Get signoff message */
325 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
329 /* Update statistics */
330 assert(server->stat.clients > 0);
331 server->stat.clients--;
332 if (server->stat.cell_clients)
333 server->stat.cell_clients--;
334 SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
335 SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
336 silc_schedule_task_del_by_context(server->schedule, client);
338 /* Remove client's public key from repository, this will free it too. */
339 if (client->data.public_key) {
340 silc_skr_del_public_key(server->repository, client->data.public_key,
342 client->data.public_key = NULL;
345 /* Remove the client from all channels. */
346 silc_server_remove_from_channels(server, NULL, client, TRUE,
349 /* Check if anyone is watching this nickname */
350 if (server->server_type == SILC_ROUTER)
351 silc_server_check_watcher_list(server, client, NULL,
352 SILC_NOTIFY_TYPE_SIGNOFF);
354 /* Remove this client from watcher list if it is */
355 silc_server_del_from_watcher_list(server, client);
357 client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
359 client->router = NULL;
360 client->connection = NULL;
361 client->data.created = silc_time();
362 silc_dlist_del(server->expired_clients, client);
363 silc_dlist_add(server->expired_clients, client);
366 case SILC_NOTIFY_TYPE_TOPIC_SET:
368 * Distribute the notify to local clients on the channel
371 SILC_LOG_DEBUG(("TOPIC SET notify"));
374 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
377 /* Get client entry */
378 if (id.type == SILC_ID_CLIENT) {
379 client = silc_idlist_find_client_by_id(server->global_list,
380 SILC_ID_GET_ID(id), TRUE, &cache);
382 client = silc_idlist_find_client_by_id(server->local_list,
391 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
395 if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
396 packet->dst_id_type, &channel_id,
400 /* Get channel entry */
401 channel = silc_idlist_find_channel_by_id(server->global_list,
404 channel = silc_idlist_find_channel_by_id(server->local_list,
407 SILC_LOG_DEBUG(("Notify for unknown channel %s",
408 silc_id_render(&channel_id, SILC_ID_CHANNEL)));
413 if (channel->topic && !strcmp(channel->topic, tmp)) {
414 SILC_LOG_DEBUG(("Topic is already set and same"));
419 /* Get user's channel entry and check that topic set is allowed. */
420 if (!silc_server_client_on_channel(client, channel, &chl))
422 if (channel->mode & SILC_CHANNEL_MODE_TOPIC &&
423 !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
424 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
425 SILC_LOG_DEBUG(("Topic change is not allowed"));
430 /* Change the topic */
431 silc_free(channel->topic);
432 channel->topic = strdup(tmp);
434 /* Send the same notify to the channel */
435 silc_server_packet_send_to_channel(server, NULL, channel, packet->type,
436 FALSE, TRUE, buffer->data,
437 silc_buffer_len(buffer));
440 case SILC_NOTIFY_TYPE_NICK_CHANGE:
443 * Distribute the notify to local clients on the channel
446 SilcUInt32 nickname_len;
448 SILC_LOG_DEBUG(("NICK CHANGE notify"));
450 /* Get old client ID */
451 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
454 /* Get new client ID */
455 if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id2, NULL))
458 SILC_LOG_DEBUG(("Old Client ID id(%s)",
459 silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CLIENT)));
460 SILC_LOG_DEBUG(("New Client ID id(%s)",
461 silc_id_render(SILC_ID_GET_ID(id2), SILC_ID_CLIENT)));
463 /* From protocol version 1.1 we also get the new nickname */
464 nickname = silc_argument_get_arg_type(args, 3, &nickname_len);;
466 /* Replace the Client ID */
467 client = silc_idlist_replace_client_id(server,
470 SILC_ID_GET_ID(id2), nickname);
472 client = silc_idlist_replace_client_id(server,
475 SILC_ID_GET_ID(id2), nickname);
478 /* Send the NICK_CHANGE notify type to local clients on the channels
479 this client is joined to. */
480 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
481 tmp2 = silc_argument_get_arg_type(args, 2, &tmp2_len);
482 silc_server_send_notify_on_channels(server, client, client,
483 SILC_NOTIFY_TYPE_NICK_CHANGE, 3,
484 tmp, tmp_len, tmp2, tmp2_len,
492 case SILC_NOTIFY_TYPE_CMODE_CHANGE:
494 * Distribute the notify to local clients on the channel
497 SILC_LOG_DEBUG(("CMODE CHANGE notify"));
500 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
503 /* Get client entry */
504 if (id.type == SILC_ID_CLIENT) {
505 client = silc_idlist_find_client_by_id(server->global_list,
506 SILC_ID_GET_ID(id), TRUE, &cache);
508 client = silc_idlist_find_client_by_id(server->local_list,
516 if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
517 packet->dst_id_type, &channel_id,
521 /* Get channel entry */
522 channel = silc_idlist_find_channel_by_id(server->global_list,
525 channel = silc_idlist_find_channel_by_id(server->local_list,
528 SILC_LOG_DEBUG(("Notify for unknown channel %s",
529 silc_id_render(&channel_id, SILC_ID_CHANNEL)));
535 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
538 SILC_GET32_MSB(mode, tmp);
540 /* Check if mode changed */
541 if (channel->mode == mode) {
542 SILC_LOG_DEBUG(("Mode is changed already"));
544 /* If this mode change has founder mode then we'll enforce the
545 change so that the server gets the real founder public key */
546 if (server->server_type != SILC_SERVER &&
547 sock != SILC_PRIMARY_ROUTE(server) &&
548 mode & SILC_CHANNEL_MODE_FOUNDER_AUTH && channel->founder_key) {
549 SILC_LOG_DEBUG(("Sending founder public key to server"));
550 silc_server_send_notify_cmode(server, sock, FALSE, channel,
551 channel->mode, server->id,
552 SILC_ID_SERVER, channel->cipher,
555 channel->founder_key, NULL);
558 /* If we received same mode from our primary check whether founder
559 mode and key in the notify is set. We update the founder key
560 here since we may have wrong one */
561 if (server->server_type != SILC_ROUTER &&
562 sock == SILC_PRIMARY_ROUTE(server) &&
563 mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
564 SILC_LOG_DEBUG(("Founder public key received from router"));
565 tmp = silc_argument_get_arg_type(args, 6, &tmp_len);
569 if (channel->founder_key)
570 silc_pkcs_public_key_free(channel->founder_key);
571 channel->founder_key = NULL;
572 silc_public_key_payload_decode(tmp, tmp_len,
573 &channel->founder_key);
576 /* Check also for channel public key list */
577 if (server->server_type == SILC_SERVER &&
578 sock == SILC_PRIMARY_ROUTE(server) &&
579 mode & SILC_CHANNEL_MODE_CHANNEL_AUTH) {
582 unsigned char mask[4], ulimit[4];
584 SILC_LOG_DEBUG(("Channel public key list received from router"));
585 tmp = silc_argument_get_arg_type(args, 7, &tmp_len);
589 /* Set the router's list, and send the notify to channel too so that
590 channel gets the list */
591 silc_server_set_channel_pk_list(server, sock, channel, tmp, tmp_len);
592 chpklist = silc_server_get_channel_pk_list(server, channel,
596 sidp = silc_id_payload_encode(server->router->id, SILC_ID_SERVER);
597 SILC_PUT32_MSB(channel->mode, mask);
598 if (channel->mode & SILC_CHANNEL_MODE_ULIMIT)
599 SILC_PUT32_MSB(channel->user_limit, ulimit);
600 silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
601 SILC_NOTIFY_TYPE_CMODE_CHANGE, 8,
602 sidp->data, silc_buffer_len(sidp),
606 strlen(channel->cipher) : 0,
609 strlen(channel->hmac_name) : 0,
611 channel->passphrase ?
612 strlen(channel->passphrase) : 0,
615 silc_buffer_len(chpklist),
617 SILC_CHANNEL_MODE_ULIMIT ?
620 SILC_CHANNEL_MODE_ULIMIT ?
621 sizeof(ulimit) : 0));
622 silc_buffer_free(sidp);
623 silc_buffer_free(chpklist);
630 /* Get user's channel entry and check that mode change is allowed */
632 if (!silc_server_client_on_channel(client, channel, &chl))
634 if (!silc_server_check_cmode_rights(server, channel, chl, mode)) {
635 SILC_LOG_DEBUG(("CMODE change is not allowed"));
636 silc_server_send_notify_cmode(server, sock, FALSE, channel,
637 channel->mode, server->id,
638 SILC_ID_SERVER, channel->cipher,
641 channel->founder_key, NULL);
645 /* Assure that server is not removing founder mode from us */
646 if (server->server_type == SILC_ROUTER &&
647 sock != SILC_PRIMARY_ROUTE(server) &&
648 channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH &&
649 !(mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
650 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
651 silc_server_send_notify_cmode(server, sock, FALSE, channel,
652 channel->mode, server->id,
653 SILC_ID_SERVER, channel->cipher,
656 channel->founder_key, NULL);
660 /* If server is adding founder mode, check whether there is founder
661 on channel already and is not from this server */
662 if (server->server_type == SILC_ROUTER &&
663 sock != SILC_PRIMARY_ROUTE(server) &&
664 mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
665 silc_hash_table_list(channel->user_list, &htl);
666 while (silc_hash_table_get(&htl, NULL, (void *)&chl))
667 if (chl->mode & SILC_CHANNEL_UMODE_CHANFO &&
668 chl->client->router != (SilcServerEntry)idata) {
669 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
670 silc_server_send_notify_cmode(server, sock, FALSE, channel,
671 channel->mode, server->id,
672 SILC_ID_SERVER, channel->cipher,
675 channel->founder_key, NULL);
676 silc_hash_table_list_reset(&htl);
679 silc_hash_table_list_reset(&htl);
683 /* If the channel had private keys set and the mode was removed then
684 we must re-generate and re-distribute a new channel key */
685 if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY &&
686 !(mode & SILC_CHANNEL_MODE_PRIVKEY)) {
687 /* Re-generate channel key */
688 if (!silc_server_create_channel_key(server, channel, 0))
691 /* Send the channel key. This sends it to our local clients and if
692 we are normal server to our router as well. */
693 silc_server_send_channel_key(server, NULL, channel,
694 server->server_type == SILC_ROUTER ?
695 FALSE : !server->standalone);
699 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
701 unsigned char hash[SILC_HASH_MAXLEN];
704 silc_hmac_free(channel->hmac);
705 if (!silc_hmac_alloc(tmp, NULL, &channel->hmac))
708 /* Set the HMAC key out of current channel key. The client must do
710 silc_hash_make(silc_hmac_get_hash(channel->hmac), channel->key,
711 channel->key_len / 8, hash);
712 silc_hmac_set_key(channel->hmac, hash,
713 silc_hash_len(silc_hmac_get_hash(channel->hmac)));
714 memset(hash, 0, sizeof(hash));
717 /* Get the passphrase */
718 tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
720 silc_free(channel->passphrase);
721 channel->passphrase = silc_memdup(tmp, tmp_len);
724 /* Get founder public key */
725 tmp = silc_argument_get_arg_type(args, 6, &tmp_len);
726 if (tmp && mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
727 if (channel->founder_key)
728 silc_pkcs_public_key_free(channel->founder_key);
729 channel->founder_key = NULL;
730 SILC_LOG_DEBUG(("Founder public key received"));
731 if (!silc_public_key_payload_decode(tmp, tmp_len,
732 &channel->founder_key)) {
733 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
734 mode &= ~SILC_CHANNEL_MODE_FOUNDER_AUTH;
735 silc_server_send_notify_cmode(server, sock, FALSE, channel,
736 mode, server->id, SILC_ID_SERVER,
739 channel->passphrase, NULL, NULL);
740 if (channel->founder_key)
741 silc_pkcs_public_key_free(channel->founder_key);
742 channel->founder_key = NULL;
746 if (mode & SILC_CHANNEL_MODE_FOUNDER_AUTH && !channel->founder_key &&
747 server->server_type == SILC_ROUTER) {
748 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
749 mode &= ~SILC_CHANNEL_MODE_FOUNDER_AUTH;
750 silc_server_send_notify_cmode(server, sock, FALSE, channel,
751 mode, server->id, SILC_ID_SERVER,
754 channel->passphrase, NULL, NULL);
757 /* Process channel public key(s). */
758 tmp = silc_argument_get_arg_type(args, 7, &tmp_len);
759 if (tmp && mode & SILC_CHANNEL_MODE_CHANNEL_AUTH) {
761 SILC_LOG_DEBUG(("Channel public key list received from router"));
764 silc_server_set_channel_pk_list(server, sock, channel, tmp, tmp_len);
766 /* If list was set already we will enforce the same list to server. */
767 if (ret == SILC_STATUS_ERR_OPERATION_ALLOWED) {
768 SilcBuffer chpklist = silc_server_get_channel_pk_list(server, channel,
770 silc_server_send_notify_cmode(server, sock, FALSE, channel,
771 mode, server->id, SILC_ID_SERVER,
774 channel->passphrase, NULL,
776 silc_buffer_free(chpklist);
780 /* Get the user limit */
781 tmp = silc_argument_get_arg_type(args, 8, &tmp_len);
782 if (tmp && tmp_len == 4 && mode & SILC_CHANNEL_MODE_ULIMIT)
783 SILC_GET32_MSB(channel->user_limit, tmp);
785 /* Send the same notify to the channel */
786 silc_server_packet_send_to_channel(server, NULL, channel, packet->type,
787 FALSE, TRUE, buffer->data,
788 silc_buffer_len(buffer));
791 channel->mode = mode;
793 /* Cleanup if some modes are removed */
795 if (!(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) &&
796 channel->founder_key) {
797 silc_pkcs_public_key_free(channel->founder_key);
798 channel->founder_key = NULL;
801 if (!(channel->mode & SILC_CHANNEL_MODE_CHANNEL_AUTH) &&
802 channel->channel_pubkeys) {
803 silc_hash_table_free(channel->channel_pubkeys);
804 channel->channel_pubkeys = NULL;
809 case SILC_NOTIFY_TYPE_CUMODE_CHANGE:
812 * Distribute the notify to local clients on the channel
814 SilcChannelClientEntry chl2 = NULL;
815 SilcBool notify_sent = FALSE;
817 SILC_LOG_DEBUG(("CUMODE CHANGE notify"));
820 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
823 /* Get client entry */
824 if (id.type == SILC_ID_CLIENT) {
825 client = silc_idlist_find_client_by_id(server->global_list,
829 client = silc_idlist_find_client_by_id(server->local_list,
837 if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
838 packet->dst_id_type, &channel_id,
842 /* Get channel entry */
843 channel = silc_idlist_find_channel_by_id(server->global_list,
846 channel = silc_idlist_find_channel_by_id(server->local_list,
849 SILC_LOG_DEBUG(("Notify for unknown channel %s",
850 silc_id_render(&channel_id, SILC_ID_CHANNEL)));
856 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
860 SILC_GET32_MSB(mode, tmp);
862 /* Get target client */
863 if (!silc_argument_get_decoded(args, 3, SILC_ARGUMENT_ID, &id, NULL))
866 /* Get client entry */
867 client2 = silc_idlist_find_client_by_id(server->global_list,
868 SILC_ID_GET_ID(id), TRUE, NULL);
870 client2 = silc_idlist_find_client_by_id(server->local_list,
878 /* Check that sender is on channel */
879 if (!silc_server_client_on_channel(client, channel, &chl))
882 if (client != client2 && server->server_type == SILC_ROUTER) {
883 /* Sender must be operator */
884 if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
885 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
886 SILC_LOG_DEBUG(("CUMODE change is not allowed"));
890 if (!silc_server_client_on_channel(client2, channel, &chl))
893 /* If target is founder mode change is not allowed. */
894 if (chl->mode & SILC_CHANNEL_UMODE_CHANFO) {
895 SILC_LOG_DEBUG(("CUMODE change is not allowed"));
901 /* Get target channel user entry */
902 if (!silc_server_client_on_channel(client2, channel, &chl))
905 if (server->server_type == SILC_SERVER && chl->mode == mode) {
906 SILC_LOG_DEBUG(("Mode is changed already"));
910 /* Check whether to give founder rights to this user or not. The
911 problem here is that we get only the public key of the client,
912 but no authentication data. We must assume that server has
913 already authenticated the user (and thus we must trust the
915 if (mode & SILC_CHANNEL_UMODE_CHANFO &&
916 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO) &&
917 server->server_type == SILC_ROUTER &&
918 sock != SILC_PRIMARY_ROUTE(server)) {
919 SilcPublicKey founder_key = NULL;
921 /* If channel doesn't have founder auth mode then it's impossible
922 that someone would be getting founder rights with CUMODE command.
923 In that case there already either is founder or there isn't
924 founder at all on the channel (valid only when 'client' is
926 if (client && !(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
927 /* Force the mode to not have founder mode */
928 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
929 silc_server_force_cumode_change(server, sock, channel, chl, mode);
934 /* Get the founder of the channel and if found then this client
935 cannot be the founder since there already is one. */
936 silc_hash_table_list(channel->user_list, &htl);
937 while (silc_hash_table_get(&htl, NULL, (void *)&chl2))
938 if (chl2->mode & SILC_CHANNEL_UMODE_CHANFO) {
939 SILC_LOG_DEBUG(("Founder already on channel"));
940 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
941 silc_server_force_cumode_change(server, sock, channel,
946 silc_hash_table_list_reset(&htl);
947 if (!(mode & SILC_CHANNEL_UMODE_CHANFO))
950 /* Founder not found on the channel. Since the founder auth mode
951 is set on the channel now check whether this is the client that
952 originally set the mode. */
954 if (channel->founder_key) {
955 /* Get public key that must be present in notify */
956 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
957 if (!tmp || !silc_public_key_payload_decode(tmp, tmp_len,
959 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
960 SILC_LOG_DEBUG(("Founder public key not present"));
961 silc_server_force_cumode_change(server, sock, channel, chl, mode);
966 /* Now match the public key we have cached and public key sent.
968 if (!silc_pkcs_public_key_compare(channel->founder_key,
970 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
971 SILC_LOG_DEBUG(("Founder public key mismatch"));
972 silc_server_force_cumode_change(server, sock, channel, chl, mode);
978 /* There cannot be anyone else as founder on the channel now. This
979 client is definitely the founder due to this 'authentication'.
980 We trust the server did the actual signature verification
981 earlier (bad, yes). */
982 silc_hash_table_list(channel->user_list, &htl);
983 while (silc_hash_table_get(&htl, NULL, (void *)&chl2))
984 if (chl2->mode & SILC_CHANNEL_UMODE_CHANFO) {
985 chl2->mode &= ~SILC_CHANNEL_UMODE_CHANFO;
986 SILC_LOG_DEBUG(("Removing old founder rights, new authenticated"));
987 silc_server_force_cumode_change(server, NULL, channel, chl2,
991 silc_hash_table_list_reset(&htl);
994 silc_pkcs_public_key_free(founder_key);
997 if (server->server_type != SILC_SERVER && chl->mode == mode) {
998 SILC_LOG_DEBUG(("Mode is changed already"));
1002 SILC_LOG_DEBUG(("Changing %s channel user mode",
1003 chl->client->nickname ? chl->client->nickname :
1004 (unsigned char *)""));
1006 /* Change the mode */
1009 /* Send the same notify to the channel */
1011 silc_server_packet_send_to_channel(server, sock, channel,
1013 FALSE, TRUE, buffer->data,
1014 silc_buffer_len(buffer));
1019 case SILC_NOTIFY_TYPE_INVITE:
1021 if (packet->dst_id_type == SILC_ID_CLIENT)
1024 SILC_LOG_DEBUG(("INVITE notify"));
1026 /* Get Channel ID */
1027 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
1030 /* Get channel entry */
1031 channel = silc_idlist_find_channel_by_id(server->global_list,
1032 SILC_ID_GET_ID(id), NULL);
1034 channel = silc_idlist_find_channel_by_id(server->local_list,
1035 SILC_ID_GET_ID(id), NULL);
1037 SILC_LOG_DEBUG(("Notify for unknown channel %s",
1038 silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
1043 /* Get the invite action */
1044 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
1045 if (tmp && tmp_len == 1) {
1046 SilcUInt8 action = (SilcUInt8)tmp[0];
1047 SilcUInt16 iargc = 0;
1048 SilcArgumentPayload iargs;
1050 /* Get invite list */
1051 tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
1052 if (!tmp || tmp_len < 2)
1055 /* Parse the arguments to see they are constructed correctly */
1056 SILC_GET16_MSB(iargc, tmp);
1057 iargs = silc_argument_payload_parse(tmp + 2, tmp_len - 2, iargc);
1061 if (!channel->invite_list)
1062 channel->invite_list =
1063 silc_hash_table_alloc(0, silc_hash_ptr,
1065 silc_server_inviteban_destruct, channel, TRUE);
1067 /* Proces the invite action */
1068 if (!silc_server_inviteban_process(server, channel->invite_list, action,
1071 silc_argument_payload_free(iargs);
1073 /* If we are router we must send this notify to our local servers on
1074 the channel. Normal server does nothing. The notify is not
1076 if (server->server_type == SILC_ROUTER)
1077 silc_server_packet_send_to_channel(server, sock, channel,
1078 packet->type, FALSE, FALSE,
1080 silc_buffer_len(buffer));
1085 case SILC_NOTIFY_TYPE_CHANNEL_CHANGE:
1087 * Distribute to the local clients on the channel and change the
1091 SILC_LOG_DEBUG(("CHANNEL CHANGE"));
1093 if (idata->conn_type != SILC_CONN_ROUTER)
1096 /* Get the old Channel ID */
1097 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
1100 /* Get the channel entry */
1101 channel = silc_idlist_find_channel_by_id(server->local_list,
1102 SILC_ID_GET_ID(id), NULL);
1104 channel = silc_idlist_find_channel_by_id(server->global_list,
1105 SILC_ID_GET_ID(id), NULL);
1107 SILC_LOG_DEBUG(("Notify for unknown channel %s",
1108 silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
1113 /* Send the notify to the channel */
1114 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
1115 FALSE, TRUE, buffer->data,
1116 silc_buffer_len(buffer));
1118 /* Get the new Channel ID */
1119 if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id2, NULL))
1122 SILC_LOG_DEBUG(("Old Channel ID id(%s)",
1123 silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
1124 SILC_LOG_DEBUG(("New Channel ID id(%s)",
1125 silc_id_render(SILC_ID_GET_ID(id2), SILC_ID_CHANNEL)));
1127 /* Replace the Channel ID */
1129 if (!silc_idlist_replace_channel_id(server->local_list,
1131 SILC_ID_GET_ID(id2)))
1132 if (!silc_idlist_replace_channel_id(server->global_list,
1134 SILC_ID_GET_ID(id2)))
1138 SilcBuffer modes = NULL, users = NULL, users_modes = NULL;
1140 /* Re-announce this channel which ID was changed. */
1141 silc_server_send_new_channel(server, sock, FALSE, channel->channel_name,
1143 silc_id_get_len(channel->id,
1147 /* Re-announce our clients on the channel as the ID has changed now */
1148 silc_server_announce_get_channel_users(server, channel, &modes, &users,
1151 silc_buffer_push(users, users->data - users->head);
1152 silc_server_packet_send(server, sock,
1153 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1154 users->data, silc_buffer_len(users));
1155 silc_buffer_free(users);
1158 silc_buffer_push(modes, modes->data - modes->head);
1159 silc_server_packet_send_dest(server, sock,
1160 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1161 channel->id, SILC_ID_CHANNEL,
1162 modes->data, silc_buffer_len(modes));
1163 silc_buffer_free(modes);
1166 silc_buffer_push(users_modes, users_modes->data - users_modes->head);
1167 silc_server_packet_send_dest(server, sock,
1168 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1169 channel->id, SILC_ID_CHANNEL,
1171 silc_buffer_len(users_modes));
1172 silc_buffer_free(users_modes);
1175 /* Re-announce channel's topic */
1176 if (channel->topic) {
1177 silc_server_send_notify_topic_set(server, sock,
1178 server->server_type == SILC_ROUTER ?
1179 TRUE : FALSE, channel,
1180 server->id, SILC_ID_SERVER,
1187 case SILC_NOTIFY_TYPE_SERVER_SIGNOFF:
1189 * Remove the server entry and all clients that this server owns.
1192 SILC_LOG_DEBUG(("SERVER SIGNOFF notify"));
1194 /* Backup router shouldn't accept SERVER_SIGNOFF's from normal routers
1195 when the backup isn't acting as primary router. */
1196 if (idata->conn_type == SILC_CONN_SERVER &&
1197 server->backup_router && server->server_type == SILC_BACKUP_ROUTER)
1201 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
1204 /* If the ID is mine, this notify is not allowed. */
1205 if (SILC_ID_SERVER_COMPARE(SILC_ID_GET_ID(id), server->id)) {
1206 SILC_LOG_DEBUG(("Ignoring my own ID for SERVER_SIGNOFF"));
1210 /* Get server entry */
1211 server_entry = silc_idlist_find_server_by_id(server->global_list,
1215 if (!server_entry) {
1216 server_entry = silc_idlist_find_server_by_id(server->local_list,
1220 if (!server_entry) {
1221 /* If we are normal server then we might not have the server. Check
1222 whether router was kind enough to send the list of all clients
1223 that actually was to be removed. Remove them if the list is
1225 if (server->server_type != SILC_ROUTER &&
1226 silc_argument_get_arg_num(args) > 1) {
1229 for (i = 1; i < silc_argument_get_arg_num(args); i++) {
1231 if (!silc_argument_get_decoded(args, i + 1, SILC_ARGUMENT_ID,
1235 /* Get client entry */
1236 client = silc_idlist_find_client_by_id(server->global_list,
1237 SILC_ID_GET_ID(id2),
1241 client = silc_idlist_find_client_by_id(server->local_list,
1242 SILC_ID_GET_ID(id2),
1249 /* Update statistics */
1250 assert(server->stat.clients > 0);
1251 server->stat.clients--;
1252 if (server->stat.cell_clients)
1253 server->stat.cell_clients--;
1254 SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
1255 SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
1257 /* Remove the client from all channels. */
1258 silc_server_remove_from_channels(server, NULL, client,
1259 TRUE, NULL, FALSE, FALSE);
1261 /* Check if anyone is watching this nickname */
1262 if (server->server_type == SILC_ROUTER)
1263 silc_server_check_watcher_list(server, client, NULL,
1264 SILC_NOTIFY_TYPE_SERVER_SIGNOFF);
1266 /* Remove this client from watcher list if it is */
1268 silc_server_del_from_watcher_list(server, client);
1270 /* Remove the client */
1271 silc_dlist_del(server->expired_clients, client);
1272 silc_idlist_del_data(client);
1273 silc_idlist_del_client(local ? server->local_list :
1274 server->global_list, client);
1282 /* For local entrys SERVER_SIGNOFF is processed only on backup router.
1283 It is possible that router sends server signoff for a server. If
1284 backup router has it as local connection it will be closed. */
1285 if (SILC_IS_LOCAL(server_entry)) {
1286 if (server->server_type == SILC_BACKUP_ROUTER) {
1287 sock = server_entry->connection;
1288 SILC_LOG_DEBUG(("Closing connection after SERVER_SIGNOFF"));
1289 silc_server_free_sock_user_data(server, sock, NULL);
1290 silc_server_close_connection(server, sock);
1296 /* Remove all servers that are originated from this server, and
1297 remove the clients of those servers too. */
1298 silc_server_remove_servers_by_server(server, server_entry, TRUE);
1300 /* Remove the clients that this server owns as they will become
1302 silc_server_remove_clients_by_server(server, server_entry->router,
1303 server_entry, TRUE);
1304 silc_server_backup_del(server, server_entry);
1306 /* Remove the server entry */
1307 silc_idlist_del_server(local ? server->local_list :
1308 server->global_list, server_entry);
1310 /* Update statistics */
1311 if (server->server_type == SILC_ROUTER)
1312 server->stat.servers--;
1316 case SILC_NOTIFY_TYPE_KICKED:
1318 * Distribute the notify to local clients on the channel
1321 SILC_LOG_DEBUG(("KICKED notify"));
1323 if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
1324 packet->dst_id_type, &channel_id,
1325 sizeof(channel_id)))
1328 /* Get channel entry */
1329 channel = silc_idlist_find_channel_by_id(server->global_list,
1332 channel = silc_idlist_find_channel_by_id(server->local_list,
1335 SILC_LOG_DEBUG(("Notify for unknown channel %s",
1336 silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
1342 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
1345 /* If the the client is not in local list we check global list */
1346 client = silc_idlist_find_client_by_id(server->global_list,
1347 SILC_ID_GET_ID(id), TRUE, NULL);
1349 client = silc_idlist_find_client_by_id(server->local_list,
1350 SILC_ID_GET_ID(id), TRUE, NULL);
1355 /* If target is founder they cannot be kicked */
1356 if (!silc_server_client_on_channel(client, channel, &chl))
1358 if (chl->mode & SILC_CHANNEL_UMODE_CHANFO)
1361 /* Get the kicker's Client ID */
1362 if (!silc_argument_get_decoded(args, 3, SILC_ARGUMENT_ID, &id, NULL))
1365 /* If the the client is not in local list we check global list */
1366 client2 = silc_idlist_find_client_by_id(server->global_list,
1367 SILC_ID_GET_ID(id), TRUE, NULL);
1369 client2 = silc_idlist_find_client_by_id(server->local_list,
1370 SILC_ID_GET_ID(id), TRUE, NULL);
1375 /* Kicker must be operator on channel */
1376 if (!silc_server_client_on_channel(client2, channel, &chl))
1378 if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
1379 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
1380 SILC_LOG_DEBUG(("Kicking is not allowed"));
1384 /* Send to channel */
1385 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
1386 FALSE, TRUE, buffer->data,
1387 silc_buffer_len(buffer));
1389 /* Remove the client from channel's invite list */
1390 if (channel->invite_list && silc_hash_table_count(channel->invite_list)) {
1392 SilcArgumentPayload iargs;
1393 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1394 ab = silc_argument_payload_encode_one(NULL, tmp, tmp_len, 3);
1395 iargs = silc_argument_payload_parse(ab->data, silc_buffer_len(ab), 1);
1396 silc_server_inviteban_process(server, channel->invite_list, 1, iargs);
1397 silc_buffer_free(ab);
1398 silc_argument_payload_free(iargs);
1401 /* Remove the client from channel */
1402 silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
1406 case SILC_NOTIFY_TYPE_KILLED:
1409 * Distribute the notify to local clients on channels
1411 unsigned char *comment;
1412 SilcUInt32 comment_len;
1414 SILC_LOG_DEBUG(("KILLED notify"));
1417 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
1420 /* If the the client is not in local list we check global list */
1421 client = silc_idlist_find_client_by_id(server->global_list,
1422 SILC_ID_GET_ID(id), TRUE, &cache);
1424 client = silc_idlist_find_client_by_id(server->local_list,
1431 /* If the client is one of ours, then close the connection to the
1432 client now. This removes the client from all channels as well. */
1433 if (packet->dst_id_type == SILC_ID_CLIENT && client->connection) {
1434 sock = client->connection;
1435 silc_server_free_client_data(server, NULL, client, FALSE, NULL);
1436 silc_server_close_connection(server, sock);
1441 comment = silc_argument_get_arg_type(args, 2, &comment_len);
1442 if (comment_len > 128)
1445 /* Get the killer's Client ID */
1446 if (!silc_argument_get_decoded(args, 3, SILC_ARGUMENT_ID, &id, NULL))
1449 if (id.type == SILC_ID_CLIENT) {
1450 /* If the the client is not in local list we check global list */
1451 client2 = silc_idlist_find_client_by_id(server->global_list,
1455 client2 = silc_idlist_find_client_by_id(server->local_list,
1462 /* Killer must be router operator */
1463 if (server->server_type != SILC_SERVER &&
1464 !(client2->mode & SILC_UMODE_ROUTER_OPERATOR)) {
1465 SILC_LOG_DEBUG(("Killing is not allowed"));
1470 /* Send the notify to local clients on the channels except to the
1471 client who is killed. */
1472 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1473 tmp2 = silc_argument_get_arg_type(args, 3, &tmp2_len);
1474 silc_server_send_notify_on_channels(server, client, client,
1475 SILC_NOTIFY_TYPE_KILLED, 3,
1476 tmp, tmp_len, comment, comment_len,
1479 /* Remove the client from all channels */
1480 silc_server_remove_from_channels(server, NULL, client, FALSE, NULL,
1483 /* Check if anyone is watching this nickname */
1484 if (server->server_type == SILC_ROUTER)
1485 silc_server_check_watcher_list(server, client, NULL,
1486 SILC_NOTIFY_TYPE_KILLED);
1488 /* Remove client's public key from repository, this will free it too. */
1489 if (client->data.public_key) {
1490 silc_skr_del_public_key(server->repository, client->data.public_key,
1492 client->data.public_key = NULL;
1495 /* Update statistics */
1496 assert(server->stat.clients > 0);
1497 server->stat.clients--;
1498 if (server->stat.cell_clients)
1499 server->stat.cell_clients--;
1500 SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
1501 SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
1503 if (SILC_IS_LOCAL(client)) {
1504 server->stat.my_clients--;
1505 silc_schedule_task_del_by_context(server->schedule, client);
1506 silc_idlist_del_data(client);
1510 client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
1512 client->router = NULL;
1513 client->connection = NULL;
1514 client->data.created = silc_time();
1515 silc_dlist_del(server->expired_clients, client);
1516 silc_dlist_add(server->expired_clients, client);
1520 case SILC_NOTIFY_TYPE_UMODE_CHANGE:
1522 * Save the mode of the client.
1525 SILC_LOG_DEBUG(("UMODE_CHANGE notify"));
1528 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
1531 /* Get client entry */
1532 client = silc_idlist_find_client_by_id(server->global_list,
1533 SILC_ID_GET_ID(id), TRUE, NULL);
1535 client = silc_idlist_find_client_by_id(server->local_list,
1536 SILC_ID_GET_ID(id), TRUE, NULL);
1542 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1545 SILC_GET32_MSB(mode, tmp);
1547 /* Remove internal resumed flag if client is marked detached now */
1548 if (mode & SILC_UMODE_DETACHED)
1549 client->data.status &= ~SILC_IDLIST_STATUS_RESUMED;
1551 /* Update statistics */
1552 if (server->server_type == SILC_ROUTER) {
1553 if (mode & SILC_UMODE_GONE) {
1554 if (!(client->mode & SILC_UMODE_GONE))
1555 server->stat.aways++;
1557 if (client->mode & SILC_UMODE_GONE)
1558 server->stat.aways--;
1560 if (mode & SILC_UMODE_DETACHED) {
1561 if (!(client->mode & SILC_UMODE_DETACHED))
1562 server->stat.detached++;
1564 if (client->mode & SILC_UMODE_DETACHED)
1565 server->stat.detached--;
1568 SILC_UMODE_STATS_UPDATE(server, SILC_UMODE_SERVER_OPERATOR);
1569 SILC_UMODE_STATS_UPDATE(router, SILC_UMODE_ROUTER_OPERATOR);
1571 /* Change the mode */
1572 client->mode = mode;
1574 /* Check if anyone is watching this nickname */
1575 if (server->server_type == SILC_ROUTER)
1576 silc_server_check_watcher_list(server, client, NULL,
1577 SILC_NOTIFY_TYPE_UMODE_CHANGE);
1581 case SILC_NOTIFY_TYPE_BAN:
1586 SILC_LOG_DEBUG(("BAN notify"));
1588 /* Get Channel ID */
1589 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
1592 /* Get channel entry */
1593 channel = silc_idlist_find_channel_by_id(server->global_list,
1594 SILC_ID_GET_ID(id), NULL);
1596 channel = silc_idlist_find_channel_by_id(server->local_list,
1597 SILC_ID_GET_ID(id), NULL);
1599 SILC_LOG_DEBUG(("Notify for unknown channel %s",
1600 silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
1605 /* Get the ban action */
1606 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1607 if (tmp && tmp_len == 1) {
1608 SilcUInt8 action = (SilcUInt8)tmp[0];
1609 SilcUInt16 iargc = 0;
1610 SilcArgumentPayload iargs;
1613 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1614 if (!tmp || tmp_len < 2)
1617 /* Parse the arguments to see they are constructed correctly */
1618 SILC_GET16_MSB(iargc, tmp);
1619 iargs = silc_argument_payload_parse(tmp + 2, tmp_len - 2, iargc);
1623 if (!channel->ban_list)
1625 silc_hash_table_alloc(0, silc_hash_ptr,
1627 silc_server_inviteban_destruct, channel, TRUE);
1629 /* Proces the ban action */
1630 if (!silc_server_inviteban_process(server, channel->ban_list, action,
1633 silc_argument_payload_free(iargs);
1635 /* If we are router we must send this notify to our local servers on
1636 the channel. Normal server does nothing. The notify is not
1638 if (server->server_type == SILC_ROUTER)
1639 silc_server_packet_send_to_channel(server, sock, channel,
1640 packet->type, FALSE, FALSE,
1642 silc_buffer_len(buffer));
1646 case SILC_NOTIFY_TYPE_ERROR:
1653 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1654 if (!tmp && tmp_len != 1)
1656 error = (SilcStatus)tmp[0];
1658 SILC_LOG_DEBUG(("ERROR notify (%d)", error));
1660 if (error == SILC_STATUS_ERR_NO_SUCH_CLIENT_ID &&
1661 idata->conn_type == SILC_CONN_ROUTER) {
1662 if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL))
1665 SILC_LOG_DEBUG(("Received invalid client ID notification, deleting "
1666 "the entry from cache"));
1668 client = silc_idlist_find_client_by_id(server->global_list,
1674 silc_server_remove_from_channels(server, NULL, client, TRUE,
1676 silc_dlist_del(server->expired_clients, client);
1677 silc_idlist_del_data(client);
1678 silc_idlist_del_client(server->global_list, client);
1683 /* Ignore rest of the notify types for now */
1684 case SILC_NOTIFY_TYPE_NONE:
1685 case SILC_NOTIFY_TYPE_MOTD:
1689 SILC_LOG_DEBUG(("Unsupported notify %d", type));
1694 silc_notify_payload_free(payload);
1697 void silc_server_notify(SilcServer server,
1698 SilcPacketStream sock,
1701 silc_server_notify_process(server, sock, packet, &packet->buffer);
1702 silc_packet_free(packet);
1705 void silc_server_notify_list(SilcServer server,
1706 SilcPacketStream sock,
1709 SilcIDListData idata = silc_packet_get_context(sock);
1713 SILC_LOG_DEBUG(("Processing Notify List"));
1715 if (idata->conn_type == SILC_CONN_CLIENT ||
1716 packet->src_id_type != SILC_ID_SERVER)
1719 buffer = silc_buffer_alloc(1024);
1723 while (silc_buffer_len(&packet->buffer)) {
1724 SILC_GET16_MSB(len, packet->buffer.data + 2);
1725 if (len > silc_buffer_len(&packet->buffer))
1728 if (len > silc_buffer_truelen(buffer)) {
1729 silc_buffer_free(buffer);
1730 buffer = silc_buffer_alloc(1024 + len);
1733 silc_buffer_pull_tail(buffer, len);
1734 silc_buffer_put(buffer, packet->buffer.data, len);
1736 /* Process the Notify */
1737 silc_server_notify_process(server, sock, packet, buffer);
1739 silc_buffer_push_tail(buffer, len);
1740 silc_buffer_pull(&packet->buffer, len);
1743 silc_packet_free(packet);
1744 silc_buffer_free(buffer);
1747 /* Received private message. This resolves the destination of the message
1748 and sends the packet. This is used by both server and router. If the
1749 destination is our locally connected client this sends the packet to
1750 the client. This may also send the message for further routing if
1751 the destination is not in our server (or router). */
1753 void silc_server_private_message(SilcServer server,
1754 SilcPacketStream sock,
1757 SilcPacketStream dst_sock;
1758 SilcIDListData idata;
1759 SilcClientEntry client;
1760 SilcClientID client_id;
1762 SILC_LOG_DEBUG(("Start"));
1764 if (packet->src_id_type != SILC_ID_CLIENT ||
1765 packet->dst_id_type != SILC_ID_CLIENT || !packet->dst_id)
1768 /* Get the route to the client */
1769 dst_sock = silc_server_get_client_route(server, packet->dst_id,
1770 packet->dst_id_len, NULL,
1774 unsigned char error;
1776 if (client && client->mode & SILC_UMODE_DETACHED) {
1777 SILC_LOG_DEBUG(("Client is detached, discarding packet"));
1781 /* Send SILC_NOTIFY_TYPE_ERROR to indicate that such destination ID
1782 does not exist or is invalid. */
1783 idp = silc_id_payload_encode_data(packet->dst_id,
1785 packet->dst_id_type);
1789 error = SILC_STATUS_ERR_NO_SUCH_CLIENT_ID;
1790 if (packet->src_id_type == SILC_ID_CLIENT) {
1791 silc_id_str2id(packet->src_id, packet->src_id_len,
1792 packet->src_id_type, &client_id, sizeof(client_id));
1793 silc_server_send_notify_dest(server, sock, FALSE,
1794 &client_id, SILC_ID_CLIENT,
1795 SILC_NOTIFY_TYPE_ERROR, 2,
1797 idp->data, silc_buffer_len(idp));
1799 silc_server_send_notify(server, sock, FALSE,
1800 SILC_NOTIFY_TYPE_ERROR, 2,
1802 idp->data, silc_buffer_len(idp));
1805 silc_buffer_free(idp);
1809 /* Check whether destination client wishes to receive private messages */
1810 if (client && !(packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY) &&
1811 client->mode & SILC_UMODE_BLOCK_PRIVMSG) {
1812 SILC_LOG_DEBUG(("Client blocks private messages, discarding packet"));
1816 /* Send the private message */
1817 silc_server_packet_route(server, dst_sock, packet);
1820 silc_packet_free(packet);
1823 /* Received private message key packet.. This packet is never for us. It is to
1824 the client in the packet's destination ID. Sending of this sort of packet
1825 equals sending private message, ie. it is sent point to point from
1826 one client to another. */
1828 void silc_server_private_message_key(SilcServer server,
1829 SilcPacketStream sock,
1832 SilcPacketStream dst_sock;
1833 SilcIDListData idata;
1835 SILC_LOG_DEBUG(("Start"));
1837 if (packet->src_id_type != SILC_ID_CLIENT ||
1838 packet->dst_id_type != SILC_ID_CLIENT || !packet->dst_id) {
1839 silc_packet_free(packet);
1843 /* Get the route to the client */
1844 dst_sock = silc_server_get_client_route(server, packet->dst_id,
1845 packet->dst_id_len, NULL,
1848 silc_packet_free(packet);
1852 /* Relay the packet */
1853 silc_server_packet_route(server, dst_sock, packet);
1855 silc_packet_free(packet);
1858 /* Processes incoming command reply packet. The command reply packet may
1859 be destined to one of our clients or it may directly for us. We will
1860 call the command reply routine after processing the packet. */
1862 void silc_server_command_reply(SilcServer server,
1863 SilcPacketStream sock,
1866 SilcBuffer buffer = &packet->buffer;
1867 SilcClientEntry client = NULL;
1870 SILC_LOG_DEBUG(("Start"));
1872 if (packet->dst_id_type == SILC_ID_CHANNEL) {
1873 silc_packet_free(packet);
1877 if (packet->dst_id_type == SILC_ID_CLIENT) {
1878 /* Destination must be one of ours */
1879 if (!silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CLIENT,
1881 silc_packet_free(packet);
1884 client = silc_idlist_find_client_by_id(server->local_list, &id,
1887 SILC_LOG_ERROR(("Cannot process command reply to unknown client"));
1888 silc_packet_free(packet);
1893 if (packet->dst_id_type == SILC_ID_SERVER) {
1894 /* For now this must be for us */
1895 if (memcmp(packet->dst_id, server->id_string, server->id_string_len)) {
1896 SILC_LOG_ERROR(("Cannot process command reply to unknown server"));
1897 silc_packet_free(packet);
1902 /* Execute command reply locally for the command */
1903 silc_server_command_reply_process(server, sock, buffer);
1905 /* Relay the packet to the client */
1906 if (packet->dst_id_type == SILC_ID_CLIENT && client)
1907 silc_server_packet_route(server, client->connection, packet);
1909 silc_packet_free(packet);
1912 /* Process received channel message. The message can be originated from
1913 client or server. */
1915 void silc_server_channel_message(SilcServer server,
1916 SilcPacketStream sock,
1919 SilcChannelEntry channel = NULL;
1923 SilcClientEntry sender_entry = NULL;
1924 SilcIDListData idata;
1925 SilcChannelClientEntry chl;
1926 SilcBool local = TRUE;
1928 SILC_LOG_DEBUG(("Processing channel message"));
1931 if (packet->dst_id_type != SILC_ID_CHANNEL) {
1932 SILC_LOG_DEBUG(("Received bad message for channel, dropped"));
1936 /* Find channel entry */
1937 if (!silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CHANNEL,
1940 channel = silc_idlist_find_channel_by_id(server->local_list, &id, NULL);
1942 channel = silc_idlist_find_channel_by_id(server->global_list, &id, NULL);
1945 unsigned char error;
1947 /* Send SILC_NOTIFY_TYPE_ERROR to indicate that such destination ID
1948 does not exist or is invalid. */
1949 idp = silc_id_payload_encode_data(packet->dst_id,
1951 packet->dst_id_type);
1955 error = SILC_STATUS_ERR_NO_SUCH_CHANNEL_ID;
1956 if (packet->src_id_type == SILC_ID_CLIENT) {
1957 silc_id_str2id(packet->src_id, packet->src_id_len,
1958 packet->src_id_type, &cid, sizeof(cid));
1959 silc_server_send_notify_dest(server, sock, FALSE,
1960 &cid, SILC_ID_CLIENT,
1961 SILC_NOTIFY_TYPE_ERROR, 2,
1962 &error, 1, idp->data,
1963 silc_buffer_len(idp));
1965 silc_server_send_notify(server, sock, FALSE,
1966 SILC_NOTIFY_TYPE_ERROR, 2,
1967 &error, 1, idp->data, silc_buffer_len(idp));
1970 silc_buffer_free(idp);
1975 /* See that this client is on the channel. If the original sender is
1976 not client (as it can be server as well) we don't do the check. */
1977 if (!silc_id_str2id2(packet->src_id, packet->src_id_len,
1978 packet->src_id_type, &sid))
1980 if (sid.type == SILC_ID_CLIENT) {
1981 sender_entry = silc_idlist_find_client_by_id(server->local_list,
1982 SILC_ID_GET_ID(sid),
1984 if (!sender_entry) {
1986 sender_entry = silc_idlist_find_client_by_id(server->global_list,
1987 SILC_ID_GET_ID(sid),
1990 if (!sender_entry || !silc_server_client_on_channel(sender_entry,
1992 SILC_LOG_DEBUG(("Client not on channel"));
1996 /* If channel is moderated check that client is allowed to send
1998 if (channel->mode & SILC_CHANNEL_MODE_SILENCE_USERS &&
1999 !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
2000 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
2001 SILC_LOG_DEBUG(("Channel is silenced from normal users"));
2004 if (channel->mode & SILC_CHANNEL_MODE_SILENCE_OPERS &&
2005 chl->mode & SILC_CHANNEL_UMODE_CHANOP &&
2006 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
2007 SILC_LOG_DEBUG(("Channel is silenced from operators"));
2010 if (chl->mode & SILC_CHANNEL_UMODE_QUIET) {
2011 SILC_LOG_DEBUG(("Sender is quieted on the channel"));
2015 /* If the packet is coming from router, but the client entry is local
2016 entry to us then some router is rerouting this to us and it is not
2017 allowed. When the client is local to us it means that we've routed
2018 this packet to network, and now someone is routing it back to us. */
2019 idata = silc_packet_get_context(sock);
2020 if (server->server_type == SILC_ROUTER &&
2021 idata->conn_type == SILC_CONN_ROUTER && local) {
2022 SILC_LOG_DEBUG(("Channel message rerouted to the sender, drop it"));
2027 /* Distribute the packet to our local clients. This will send the
2028 packet for further routing as well, if needed. */
2029 silc_server_packet_relay_to_channel(server, sock, channel,
2030 SILC_ID_GET_ID(sid), sid.type,
2031 sender_entry, packet->buffer.data,
2032 silc_buffer_len(&packet->buffer));
2035 silc_packet_free(packet);
2038 /* Received channel key packet. We distribute the key to all of our locally
2039 connected clients on the channel. */
2041 void silc_server_channel_key(SilcServer server,
2042 SilcPacketStream sock,
2045 SilcBuffer buffer = &packet->buffer;
2046 SilcIDListData idata = silc_packet_get_context(sock);
2047 SilcChannelEntry channel;
2049 if (packet->src_id_type != SILC_ID_SERVER ||
2050 (server->server_type == SILC_ROUTER && !server->backup_router &&
2051 idata->conn_type == SILC_CONN_ROUTER)) {
2052 silc_packet_free(packet);
2056 /* Save the channel key */
2057 channel = silc_server_save_channel_key(server, buffer, NULL);
2059 SILC_LOG_ERROR(("Bad channel key from %s", idata->sconn->remote_host));
2060 silc_packet_free(packet);
2064 /* Distribute the key to everybody who is on the channel. If we are router
2065 we will also send it to locally connected servers. */
2066 silc_server_send_channel_key(server, sock, channel, FALSE);
2068 if (server->server_type != SILC_BACKUP_ROUTER)
2069 /* Distribute to local cell backup routers. */
2070 silc_server_backup_send(server, (SilcServerEntry)idata,
2071 SILC_PACKET_CHANNEL_KEY, 0,
2072 buffer->data, silc_buffer_len(buffer),
2075 silc_packet_free(packet);
2078 /* Received New Client packet and processes it. Creates Client ID for the
2079 client. Client becomes registered after calling this functions. */
2081 SilcClientEntry silc_server_new_client(SilcServer server,
2082 SilcPacketStream sock,
2085 SilcBuffer buffer = &packet->buffer;
2086 SilcIDListData idata = silc_packet_get_context(sock);
2087 SilcClientEntry client;
2088 SilcClientID *client_id;
2089 char *username = NULL, *realname = NULL;
2090 SilcUInt16 username_len, nickname_len;
2091 SilcUInt32 id_len, tmp_len;
2093 char *host, *nickname = NULL, *nicknamec;
2094 const char *hostname, *ip;
2096 SILC_LOG_DEBUG(("Creating new client"));
2098 if (idata->conn_type != SILC_CONN_CLIENT) {
2099 silc_packet_free(packet);
2103 /* Take client entry */
2104 client = (SilcClientEntry)idata;
2105 silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
2106 NULL, &hostname, &ip, NULL);
2108 SILC_LOG_DEBUG(("%s %s", ip, hostname));
2110 /* Make sure this client hasn't registered already */
2111 if (idata->status & SILC_IDLIST_STATUS_REGISTERED) {
2112 silc_packet_free(packet);
2116 /* Parse incoming packet */
2117 ret = silc_buffer_unformat(buffer,
2119 SILC_STR_UI16_NSTRING_ALLOC(&username,
2121 SILC_STR_UI16_STRING_ALLOC(&realname),
2124 silc_free(username);
2125 silc_free(realname);
2126 SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
2127 "connection", hostname, ip));
2128 silc_server_disconnect_remote(server, sock,
2129 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2131 silc_server_free_sock_user_data(server, sock, NULL);
2132 silc_packet_free(packet);
2137 silc_free(username);
2138 silc_free(realname);
2139 SILC_LOG_ERROR(("Client %s (%s) did not send its username, closing "
2140 "connection", hostname, ip));
2141 silc_server_disconnect_remote(server, sock,
2142 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2144 silc_server_free_sock_user_data(server, sock, NULL);
2145 silc_packet_free(packet);
2149 if (username_len > 128) {
2151 username[username_len - 1] = '\0';
2154 /* Take nickname from NEW_CLIENT packet, if present */
2155 if (silc_buffer_unformat(buffer,
2156 SILC_STR_UI16_NSTRING_ALLOC(&nickname,
2158 SILC_STR_END) >= 0) {
2159 if (nickname_len > 128) {
2161 nickname[nickname_len - 1] = '\0';
2165 /* Nickname is initially same as username, if not present in NEW_CLIENT */
2167 nickname = strdup(username);
2168 nickname_len = strlen(nickname);
2171 /* Check for valid username string */
2172 nicknamec = silc_identifier_check(nickname, nickname_len,
2173 SILC_STRING_UTF8, 128, &tmp_len);
2175 silc_free(username);
2176 silc_free(realname);
2177 silc_free(nickname);
2178 SILC_LOG_ERROR(("Client %s (%s) sent bad username string '%s', closing "
2179 "connection", hostname, ip, username));
2180 silc_server_disconnect_remote(server, sock,
2181 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2183 silc_server_free_sock_user_data(server, sock, NULL);
2184 silc_packet_free(packet);
2188 /* Make sanity checks for the hostname of the client. If the hostname
2189 is provided in the `username' check that it is the same than the
2190 resolved hostname, or if not resolved the hostname that appears in
2191 the client's public key. If the hostname is not present then put
2192 it from the resolved name or from the public key. */
2193 if (strchr(username, '@')) {
2194 SilcSILCPublicKey silc_pubkey;
2195 int tlen = strcspn(username, "@");
2196 char *phostname = NULL;
2198 host = silc_memdup(username + tlen + 1, strlen(username) - tlen - 1);
2200 if (strcmp(hostname, ip) && strcmp(hostname, host)) {
2201 silc_free(nickname);
2202 silc_free(username);
2204 silc_free(realname);
2205 SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
2206 "connection", hostname, ip));
2207 silc_server_disconnect_remote(server, sock,
2208 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2210 silc_server_free_sock_user_data(server, sock, NULL);
2211 silc_packet_free(packet);
2215 silc_pubkey = silc_pkcs_get_context(SILC_PKCS_SILC,
2216 client->data.public_key);
2217 phostname = strdup(silc_pubkey->identifier.host);
2218 if (!strcmp(hostname, ip) && phostname && strcmp(phostname, host)) {
2219 silc_free(nickname);
2220 silc_free(username);
2222 silc_free(phostname);
2223 silc_free(realname);
2224 SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
2225 "connection", hostname, ip));
2226 silc_server_disconnect_remote(server, sock,
2227 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2229 silc_server_free_sock_user_data(server, sock, NULL);
2230 silc_packet_free(packet);
2234 silc_free(phostname);
2236 /* The hostname is not present, add it. */
2238 newusername = silc_calloc(strlen(username) + strlen(hostname) + 2,
2239 sizeof(*newusername));
2240 strncat(newusername, username, strlen(username));
2241 strncat(newusername, "@", 1);
2242 strncat(newusername, hostname, strlen(hostname));
2243 silc_free(username);
2244 username = newusername;
2247 SILC_LOG_DEBUG(("%s %s", ip, hostname));
2249 /* Create Client ID */
2250 if (!silc_id_create_client_id(server, server->id, server->rng,
2251 server->md5hash, nicknamec,
2252 strlen(nicknamec), &client_id)) {
2253 silc_server_disconnect_remote(server, sock,
2254 SILC_STATUS_ERR_BAD_NICKNAME, NULL);
2255 silc_server_free_sock_user_data(server, sock, NULL);
2256 silc_packet_free(packet);
2260 /* If client marked as anonymous, scramble the username and hostname */
2261 if (client->mode & SILC_UMODE_ANONYMOUS) {
2264 if (strlen(username) >= 2) {
2265 username[0] = silc_rng_get_byte_fast(server->rng);
2266 username[1] = silc_rng_get_byte_fast(server->rng);
2269 scramble = silc_hash_babbleprint(server->sha1hash, username,
2273 memcpy(&scramble[16], ".silc", 5);
2274 scramble[21] = '\0';
2275 silc_free(username);
2276 username = scramble;
2279 /* Update client entry */
2280 idata->status |= SILC_IDLIST_STATUS_REGISTERED;
2281 client->nickname = nickname;
2282 client->username = username;
2283 client->userinfo = realname ? realname : strdup(username);
2284 client->id = client_id;
2285 id_len = silc_id_get_len(client_id, SILC_ID_CLIENT);
2286 silc_idcache_update_by_context(server->local_list->clients, client,
2287 client_id, nicknamec, TRUE);
2289 /* Notify our router about new client on the SILC network */
2290 silc_server_send_new_id(server, SILC_PRIMARY_ROUTE(server),
2291 SILC_BROADCAST(server), client->id,
2292 SILC_ID_CLIENT, id_len);
2294 /* Distribute to backup routers */
2295 if (server->server_type == SILC_ROUTER) {
2296 SilcBuffer idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
2297 silc_server_backup_send(server, NULL, SILC_PACKET_NEW_ID, 0,
2298 idp->data, silc_buffer_len(idp), FALSE, TRUE);
2299 silc_buffer_free(idp);
2302 /* Send the new client ID to the client. */
2303 silc_server_send_new_id(server, sock, FALSE, client->id, SILC_ID_CLIENT,
2304 silc_id_get_len(client->id, SILC_ID_CLIENT));
2306 /* Send some nice info to the client */
2307 silc_server_send_connect_notifys(server, sock, client);
2309 /* Check if anyone is watching this nickname */
2310 if (server->server_type == SILC_ROUTER)
2311 silc_server_check_watcher_list(server, client, NULL, 0);
2313 silc_packet_free(packet);
2317 /* Create new server. This processes received New Server packet and
2318 saves the received Server ID. The server is our locally connected
2319 server thus we save all the information and save it to local list.
2320 This funtion can be used by both normal server and router server.
2321 If normal server uses this it means that its router has connected
2322 to the server. If router uses this it means that one of the cell's
2323 servers is connected to the router. */
2325 SilcServerEntry silc_server_new_server(SilcServer server,
2326 SilcPacketStream sock,
2329 SilcBuffer buffer = &packet->buffer;
2330 SilcIDListData idata = silc_packet_get_context(sock);
2331 SilcServerEntry new_server, server_entry;
2332 SilcServerID server_id;
2333 unsigned char *server_name, *server_namec, *id_string;
2334 SilcUInt16 id_len, name_len;
2336 SilcBool local = TRUE;
2337 const char *hostname, *ip;
2339 SILC_LOG_DEBUG(("Creating new server"));
2341 if (idata->conn_type != SILC_CONN_SERVER &&
2342 idata->conn_type != SILC_CONN_ROUTER) {
2343 silc_packet_free(packet);
2347 /* Take server entry */
2348 new_server = (SilcServerEntry)idata;
2349 silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
2350 NULL, &hostname, &ip, NULL);
2353 if (server->server_type == SILC_ROUTER)
2354 server->stat.cell_servers++;
2356 /* Remove the old cache entry */
2357 if (!silc_idcache_del_by_context(server->local_list->servers, new_server,
2359 if (!silc_idcache_del_by_context(server->global_list->servers,
2360 new_server, NULL)) {
2361 SILC_LOG_INFO(("Unauthenticated %s attempted to register to "
2362 "network", (idata->conn_type == SILC_CONN_SERVER ?
2363 "server" : "router")));
2364 silc_server_disconnect_remote(server, sock,
2365 SILC_STATUS_ERR_NOT_AUTHENTICATED, NULL);
2366 silc_server_free_sock_user_data(server, sock, NULL);
2372 /* Make sure this server hasn't registered already */
2373 if (idata->status & SILC_IDLIST_STATUS_REGISTERED) {
2374 silc_server_disconnect_remote(server, sock,
2375 SILC_STATUS_ERR_OPERATION_ALLOWED,
2376 "Too many registrations");
2377 silc_server_free_sock_user_data(server, sock, NULL);
2381 /* Parse the incoming packet */
2382 ret = silc_buffer_unformat(buffer,
2383 SILC_STR_UI16_NSTRING_ALLOC(&id_string, &id_len),
2384 SILC_STR_UI16_NSTRING_ALLOC(&server_name,
2388 silc_free(id_string);
2389 silc_free(server_name);
2390 silc_server_disconnect_remote(server, sock,
2391 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2393 silc_server_free_sock_user_data(server, sock, NULL);
2397 if (id_len > silc_buffer_len(buffer)) {
2398 silc_free(id_string);
2399 silc_free(server_name);
2400 silc_server_disconnect_remote(server, sock,
2401 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2403 silc_server_free_sock_user_data(server, sock, NULL);
2407 if (name_len > 256) {
2408 server_name[256] = '\0';
2413 if (!silc_id_str2id(id_string, id_len, SILC_ID_SERVER, &server_id,
2414 sizeof(server_id))) {
2415 silc_free(id_string);
2416 silc_free(server_name);
2417 silc_server_disconnect_remote(server, sock,
2418 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2420 silc_server_free_sock_user_data(server, sock, NULL);
2423 silc_free(id_string);
2425 /* Check for valid server ID */
2426 if (!silc_id_is_valid_server_id(server, &server_id, sock)) {
2427 SILC_LOG_INFO(("Invalid server ID sent by %s (%s)",
2429 silc_server_disconnect_remote(server, sock,
2430 SILC_STATUS_ERR_BAD_SERVER_ID, NULL);
2431 silc_server_free_sock_user_data(server, sock, NULL);
2432 silc_free(server_name);
2436 /* Check that we do not have this ID already */
2437 server_entry = silc_idlist_find_server_by_id(server->local_list,
2438 &server_id, TRUE, NULL);
2440 if (SILC_IS_LOCAL(server_entry)) {
2441 SILC_LOG_ERROR(("Too many registrations from %s (%s)",
2443 silc_server_disconnect_remote(server, sock,
2444 SILC_STATUS_ERR_OPERATION_ALLOWED,
2445 "Too many registrations");
2446 silc_server_free_sock_user_data(server, sock, NULL);
2449 silc_idcache_del_by_context(server->local_list->servers, server_entry,
2453 server_entry = silc_idlist_find_server_by_id(server->global_list,
2454 &server_id, TRUE, NULL);
2456 if (SILC_IS_LOCAL(server_entry)) {
2457 SILC_LOG_ERROR(("Too many registrations from %s (%s)",
2459 silc_server_disconnect_remote(server, sock,
2460 SILC_STATUS_ERR_OPERATION_ALLOWED,
2461 "Too many registrations");
2462 silc_server_free_sock_user_data(server, sock, NULL);
2465 silc_idcache_del_by_context(server->global_list->servers,
2466 server_entry, NULL);
2471 /* Check server name */
2472 server_namec = silc_identifier_check(server_name, strlen(server_name),
2473 SILC_STRING_UTF8, 256, NULL);
2474 if (!server_namec) {
2475 SILC_LOG_ERROR(("Malformed server name from %s (%s)",
2477 silc_server_disconnect_remote(server, sock,
2478 SILC_STATUS_ERR_OPERATION_ALLOWED,
2479 "Malfromed server name");
2480 silc_server_free_sock_user_data(server, sock, NULL);
2484 /* Update server entry */
2485 idata->status |= SILC_IDLIST_STATUS_REGISTERED;
2486 new_server->server_name = server_name;
2487 new_server->id = silc_id_dup(&server_id, SILC_ID_SERVER);
2489 SILC_LOG_DEBUG(("New server id(%s)",
2490 silc_id_render(&server_id, SILC_ID_SERVER)));
2492 /* Add again the entry to the ID cache. */
2493 silc_idcache_add(local ? server->local_list->servers :
2494 server->global_list->servers, server_namec,
2495 new_server->id, new_server);
2497 /* Distribute the information about new server in the SILC network
2498 to our router. If we are normal server we won't send anything
2499 since this connection must be our router connection. */
2500 if (server->server_type == SILC_ROUTER && !server->standalone &&
2501 SILC_PRIMARY_ROUTE(server) != sock)
2502 silc_server_send_new_id(server, SILC_PRIMARY_ROUTE(server),
2503 TRUE, new_server->id, SILC_ID_SERVER,
2504 silc_id_get_len(&server_id, SILC_ID_SERVER));
2506 if (server->server_type == SILC_ROUTER) {
2507 /* Distribute to backup routers */
2508 SilcBuffer idp = silc_id_payload_encode(new_server->id, SILC_ID_SERVER);
2509 silc_server_backup_send(server, NULL, SILC_PACKET_NEW_ID, 0, idp->data,
2510 silc_buffer_len(idp), FALSE, TRUE);
2511 silc_buffer_free(idp);
2514 /* Check whether this router connection has been replaced by an
2515 backup router. If it has been then we'll disable the server and will
2516 ignore everything it will send until the backup router resuming
2517 protocol has been completed. */
2518 if (idata->conn_type == SILC_CONN_ROUTER &&
2519 silc_server_backup_replaced_get(server, &server_id, NULL)) {
2520 /* Send packet to the router indicating that it cannot use this
2521 connection as it has been replaced by backup router. */
2522 SILC_LOG_DEBUG(("Remote router has been replaced by backup router, "
2523 "disabling its connection"));
2525 silc_server_backup_send_replaced(server, sock);
2527 /* Mark the router disabled. The data sent earlier will go but nothing
2528 after this goes to this connection. */
2529 idata->status |= SILC_IDLIST_STATUS_DISABLED;
2531 /* If it is router announce our stuff to it. */
2532 if (idata->conn_type == SILC_CONN_ROUTER &&
2533 server->server_type == SILC_ROUTER) {
2534 silc_server_announce_servers(server, FALSE, 0, sock);
2535 silc_server_announce_clients(server, 0, sock);
2536 silc_server_announce_channels(server, 0, sock);
2539 /* Announce our information to backup router */
2540 if (new_server->server_type == SILC_BACKUP_ROUTER &&
2541 idata->conn_type == SILC_CONN_SERVER &&
2542 server->server_type == SILC_ROUTER) {
2543 silc_server_announce_servers(server, TRUE, 0, sock);
2544 silc_server_announce_clients(server, 0, sock);
2545 silc_server_announce_channels(server, 0, sock);
2548 /* If backup router, mark it as one of ours. This server is considered
2549 to be backup router after this setting. */
2550 if (new_server->server_type == SILC_BACKUP_ROUTER) {
2551 SilcServerConfigRouter *backup;
2552 backup = silc_server_config_find_backup_conn(server, (char *)ip);
2554 backup = silc_server_config_find_backup_conn(server, (char *)hostname);
2556 /* Add as our backup router */
2557 silc_server_backup_add(server, new_server, backup->backup_replace_ip,
2558 backup->backup_replace_port,
2559 backup->backup_local);
2563 /* By default the servers connected to backup router are disabled
2564 until backup router has become the primary */
2565 if (server->server_type == SILC_BACKUP_ROUTER &&
2566 idata->conn_type == SILC_CONN_SERVER)
2567 idata->status |= SILC_IDLIST_STATUS_DISABLED;
2573 /* Processes incoming New ID packet. New ID Payload is used to distribute
2574 information about newly registered clients and servers. */
2576 static void silc_server_new_id_real(SilcServer server,
2577 SilcPacketStream sock,
2582 SilcIDListData idata = silc_packet_get_context(sock);
2584 SilcServerEntry router, server_entry;
2585 SilcPacketStream router_sock;
2588 SilcServerID sender_id;
2589 const char *hostname, *ip;
2591 SILC_LOG_DEBUG(("Processing new ID"));
2593 if (idata->conn_type == SILC_CONN_CLIENT ||
2594 server->server_type == SILC_SERVER ||
2595 packet->src_id_type != SILC_ID_SERVER)
2598 idp = silc_id_payload_parse(buffer->data, silc_buffer_len(buffer));
2602 id_type = silc_id_payload_get_type(idp);
2604 silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
2605 NULL, &hostname, &ip, NULL);
2607 /* Normal server cannot have other normal server connections */
2608 server_entry = (SilcServerEntry)idata;
2609 if (id_type == SILC_ID_SERVER && idata->conn_type == SILC_CONN_SERVER &&
2610 server_entry->server_type == SILC_SERVER)
2613 /* If the packet is coming from server then use the sender as the
2614 origin of the the packet. If it came from router then check the real
2615 sender of the packet and use that as the origin. */
2616 if (idata->conn_type == SILC_CONN_SERVER) {
2617 id_list = server->local_list;
2619 router = server_entry;
2621 /* If the sender is backup router and ID is server (and we are not
2622 backup router) then switch the entry to global list. */
2623 if (server_entry->server_type == SILC_BACKUP_ROUTER &&
2624 id_type == SILC_ID_SERVER &&
2625 server->id_entry->server_type != SILC_BACKUP_ROUTER) {
2626 id_list = server->global_list;
2627 router_sock = server->router ? SILC_PRIMARY_ROUTE(server) : sock;
2630 silc_id_str2id(packet->src_id, packet->src_id_len,
2631 packet->src_id_type, &sender_id, sizeof(sender_id));
2632 router = silc_idlist_find_server_by_id(server->global_list,
2633 &sender_id, TRUE, NULL);
2635 router = silc_idlist_find_server_by_id(server->local_list,
2636 &sender_id, TRUE, NULL);
2638 id_list = server->global_list;
2645 case SILC_ID_CLIENT:
2647 SilcClientEntry entry;
2650 if (!silc_id_payload_get_id(idp, &id, sizeof(id)))
2653 /* Check that we do not have this client already */
2654 entry = silc_idlist_find_client_by_id(server->global_list,
2655 &id, server->server_type,
2658 entry = silc_idlist_find_client_by_id(server->local_list,
2659 &id, server->server_type,
2662 SILC_LOG_DEBUG(("Ignoring client that we already have"));
2666 SILC_LOG_DEBUG(("New client id(%s) from [%s] %s",
2667 silc_id_render(&id, SILC_ID_CLIENT),
2668 idata->conn_type == SILC_CONN_SERVER ?
2669 "Server" : "Router", hostname));
2671 /* As a router we keep information of all global information in our
2672 global list. Cell wide information however is kept in the local
2674 entry = silc_idlist_add_client(id_list, NULL, NULL, NULL,
2675 silc_id_dup(&id, SILC_ID_CLIENT),
2678 SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
2680 /* Inform the sender that the ID is not usable */
2681 silc_server_send_notify_signoff(server, sock, FALSE, &id, NULL);
2684 entry->nickname = NULL;
2685 entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
2687 if (idata->conn_type == SILC_CONN_SERVER)
2688 server->stat.cell_clients++;
2689 server->stat.clients++;
2691 /* Check if anyone is watching this nickname */
2692 if (server->server_type == SILC_ROUTER && id_list == server->local_list)
2693 silc_server_check_watcher_list(server, entry, NULL, 0);
2695 if (server->server_type == SILC_ROUTER) {
2696 /* Add the client's public key to repository or get the key with
2698 if (entry->data.public_key) {
2699 if (!silc_server_get_public_key_by_client(server, entry, NULL))
2700 silc_skr_add_public_key_simple(server->repository,
2701 entry->data.public_key,
2702 SILC_SKR_USAGE_IDENTIFICATION,
2705 silc_server_send_command(server, router_sock,
2706 SILC_COMMAND_GETKEY, ++server->cmd_ident,
2708 silc_buffer_len(buffer));
2714 case SILC_ID_SERVER:
2716 SilcServerEntry entry;
2719 if (!silc_id_payload_get_id(idp, &id, sizeof(id)))
2722 /* If the ID is mine, ignore it. */
2723 if (SILC_ID_SERVER_COMPARE(&id, server->id)) {
2724 SILC_LOG_DEBUG(("Ignoring my own ID as new ID"));
2728 /* If the ID is the sender's ID, ignore it (we have it already) */
2729 if (SILC_ID_SERVER_COMPARE(&id, router->id)) {
2730 SILC_LOG_DEBUG(("Ignoring sender's own ID"));
2734 /* Check that we do not have this server already */
2735 entry = silc_idlist_find_server_by_id(server->global_list,
2736 &id, server->server_type,
2739 entry = silc_idlist_find_server_by_id(server->local_list,
2740 &id, server->server_type,
2743 SILC_LOG_DEBUG(("Ignoring server that we already have"));
2747 SILC_LOG_DEBUG(("New server id(%s) from [%s] %s",
2748 silc_id_render(&id, SILC_ID_SERVER),
2749 idata->conn_type == SILC_CONN_SERVER ?
2750 "Server" : "Router", hostname));
2752 /* As a router we keep information of all global information in our
2753 global list. Cell wide information however is kept in the local
2755 entry = silc_idlist_add_server(id_list, NULL, 0,
2756 silc_id_dup(&id, SILC_ID_SERVER), router,
2759 SILC_LOG_ERROR(("Could not add new server to the ID Cache"));
2762 entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
2764 if (idata->conn_type == SILC_CONN_SERVER)
2765 server->stat.cell_servers++;
2766 server->stat.servers++;
2770 case SILC_ID_CHANNEL:
2771 SILC_LOG_ERROR(("Channel cannot be registered with NEW_ID packet"));
2780 /* If the sender of this packet is server and we are router we need to
2781 broadcast this packet to other routers in the network. */
2782 if (broadcast && server->server_type == SILC_ROUTER &&
2783 idata->conn_type == SILC_CONN_SERVER &&
2784 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2785 SILC_LOG_DEBUG(("Broadcasting received New ID packet"));
2786 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
2788 packet->flags | SILC_PACKET_FLAG_BROADCAST,
2789 buffer->data, silc_buffer_len(buffer));
2790 silc_server_backup_send(server, (SilcServerEntry)idata,
2791 packet->type, packet->flags,
2792 packet->buffer.data,
2793 silc_buffer_len(&packet->buffer),
2798 silc_id_payload_free(idp);
2802 /* Processes incoming New ID packet. New ID Payload is used to distribute
2803 information about newly registered clients and servers. */
2805 void silc_server_new_id(SilcServer server, SilcPacketStream sock,
2808 silc_server_new_id_real(server, sock, packet, &packet->buffer, TRUE);
2809 silc_packet_free(packet);
2812 /* Receoved New Id List packet, list of New ID payloads inside one
2813 packet. Process the New ID payloads one by one. */
2815 void silc_server_new_id_list(SilcServer server, SilcPacketStream sock,
2818 SilcIDListData idata = silc_packet_get_context(sock);
2822 SILC_LOG_DEBUG(("Processing New ID List"));
2824 if (idata->conn_type == SILC_CONN_CLIENT ||
2825 packet->src_id_type != SILC_ID_SERVER) {
2826 silc_packet_free(packet);
2830 /* If the sender of this packet is server and we are router we need to
2831 broadcast this packet to other routers in the network. Broadcast
2832 this list packet instead of multiple New ID packets. */
2833 if (server->server_type == SILC_ROUTER &&
2834 idata->conn_type == SILC_CONN_SERVER &&
2835 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2836 SILC_LOG_DEBUG(("Broadcasting received New ID List packet"));
2837 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
2839 packet->flags | SILC_PACKET_FLAG_BROADCAST,
2840 packet->buffer.data,
2841 silc_buffer_len(&packet->buffer));
2842 silc_server_backup_send(server, (SilcServerEntry)idata,
2843 packet->type, packet->flags,
2844 packet->buffer.data,
2845 silc_buffer_len(&packet->buffer),
2849 idp = silc_buffer_alloc(256);
2851 silc_packet_free(packet);
2855 while (silc_buffer_len(&packet->buffer)) {
2856 SILC_GET16_MSB(id_len, packet->buffer.data + 2);
2857 if ((id_len > silc_buffer_len(&packet->buffer)) ||
2858 (id_len > silc_buffer_truelen(idp)))
2861 silc_buffer_pull_tail(idp, 4 + id_len);
2862 silc_buffer_put(idp, packet->buffer.data, 4 + id_len);
2864 /* Process the New ID */
2865 silc_server_new_id_real(server, sock, packet, idp, FALSE);
2867 silc_buffer_push_tail(idp, 4 + id_len);
2868 silc_buffer_pull(&packet->buffer, 4 + id_len);
2871 silc_buffer_free(idp);
2872 silc_packet_free(packet);
2875 /* Received New Channel packet. Information about new channels in the
2876 network are distributed using this packet. Save the information about
2877 the new channel. This usually comes from router but also normal server
2878 can send this to notify channels it has when it connects to us. */
2880 static void silc_server_new_channel_process(SilcServer server,
2881 SilcPacketStream sock,
2885 SilcIDListData idata = silc_packet_get_context(sock);
2886 SilcChannelPayload payload;
2887 SilcChannelID channel_id;
2888 char *channel_name, *channel_namec = NULL;
2889 SilcUInt32 name_len;
2890 unsigned char *id, cid[32];
2891 SilcUInt32 id_len, cipher_len;
2892 SilcServerEntry server_entry;
2893 SilcChannelEntry channel;
2896 if (idata->conn_type == SILC_CONN_CLIENT ||
2897 packet->src_id_type != SILC_ID_SERVER ||
2898 server->server_type == SILC_SERVER)
2901 /* Parse the channel payload */
2902 payload = silc_channel_payload_parse(buffer->data, silc_buffer_len(buffer));
2906 /* Get the channel ID */
2907 if (!silc_channel_get_id_parse(payload, &channel_id)) {
2908 silc_channel_payload_free(payload);
2912 channel_name = silc_channel_get_name(payload, &name_len);
2913 if (name_len > 256) {
2914 channel_name[256] = '\0';
2918 /* Check channel name */
2919 channel_namec = silc_channel_name_check(channel_name, strlen(channel_name),
2920 SILC_STRING_UTF8, 256, NULL);
2924 id = silc_channel_get_id(payload, &id_len);
2926 server_entry = (SilcServerEntry)idata;
2928 if (idata->conn_type == SILC_CONN_ROUTER) {
2929 /* Add the channel to global list as it is coming from router. It
2930 cannot be our own channel as it is coming from router. */
2932 /* Check that we don't already have this channel */
2933 channel = silc_idlist_find_channel_by_name(server->local_list,
2934 channel_namec, NULL);
2936 channel = silc_idlist_find_channel_by_name(server->global_list,
2937 channel_namec, NULL);
2939 SILC_LOG_DEBUG(("New channel id(%s) from [Router] %s",
2940 silc_id_render(&channel_id, SILC_ID_CHANNEL),
2941 idata->sconn->remote_host));
2944 silc_idlist_add_channel(server->global_list, strdup(channel_name),
2945 0, silc_id_dup(&channel_id, SILC_ID_CHANNEL),
2946 (SilcServerEntry)idata, NULL, NULL, NULL);
2948 silc_channel_payload_free(payload);
2951 channel->disabled = TRUE; /* Disabled until someone JOINs */
2953 server->stat.channels++;
2954 if (server->server_type == SILC_ROUTER)
2955 channel->users_resolved = TRUE;
2958 /* The channel is coming from our server, thus it is in our cell
2959 we will add it to our local list. */
2962 SILC_LOG_DEBUG(("Channel id(%s) from [Server] %s",
2963 silc_id_render(&channel_id, SILC_ID_CHANNEL),
2964 idata->sconn->remote_host));
2966 /* Check that we don't already have this channel */
2967 channel = silc_idlist_find_channel_by_name(server->local_list,
2968 channel_namec, NULL);
2970 channel = silc_idlist_find_channel_by_name(server->global_list,
2971 channel_namec, NULL);
2973 /* If the channel does not exist, then create it. This creates a new
2974 key to the channel as well that we will send to the server. */
2976 SILC_LOG_DEBUG(("Channel is new to us"));
2978 /* The protocol says that the Channel ID's IP address must be based
2979 on the router's IP address. Check whether the ID is based in our
2980 IP and if it is not then create a new ID and enforce the server
2981 to switch the ID. */
2982 if (server_entry->server_type != SILC_BACKUP_ROUTER &&
2983 !SILC_ID_COMPARE(&channel_id, server->id, server->id->ip.data_len)) {
2985 SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
2986 if (silc_id_create_channel_id(server, server->id, server->rng, &tmp)) {
2987 silc_server_send_notify_channel_change(server, sock, FALSE,
2989 silc_channel_payload_free(payload);
2993 /* Wait that server re-announces this channel */
2997 /* Create the channel with the provided Channel ID */
2999 silc_server_create_new_channel_with_id(
3002 silc_id_dup(&channel_id, SILC_ID_CHANNEL),
3005 silc_channel_payload_free(payload);
3008 channel->disabled = TRUE; /* Disabled until someone JOINs */
3010 #if 0 /* We assume that CMODE_CHANGE notify is sent to us after this. */
3012 /* XXX Dunno if this is supposed to be set in any server type. If set
3013 here the CMODE_CHANGE that may follow sets mode that we already
3014 have, and we may loose data from the CMODE_CHANGE notify. */
3015 if (server_entry->server_type != SILC_BACKUP_ROUTER)
3016 channel->mode = silc_channel_get_mode(payload);
3019 /* Send the new channel key to the server */
3020 silc_id_id2str(channel->id, SILC_ID_CHANNEL, cid, sizeof(cid),
3022 cipher = silc_cipher_get_name(channel->send_key);
3023 cipher_len = strlen(cipher);
3024 chk = silc_channel_key_payload_encode(id_len, cid,
3026 channel->key_len / 8,
3028 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
3029 chk->data, silc_buffer_len(chk));
3030 silc_buffer_free(chk);
3032 /* The channel exist by that name, check whether the ID's match.
3033 If they don't then we'll force the server to use the ID we have.
3034 We also create a new key for the channel. */
3035 SilcBuffer modes = NULL, users = NULL, users_modes = NULL;
3037 SILC_LOG_DEBUG(("Channel already exists"));
3039 if (!SILC_ID_CHANNEL_COMPARE(&channel_id, channel->id)) {
3040 /* They don't match, send CHANNEL_CHANGE notify to the server to
3041 force the ID change. */
3042 SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
3043 silc_server_send_notify_channel_change(server, sock, FALSE,
3044 &channel_id, channel->id);
3045 silc_channel_payload_free(payload);
3047 /* Wait that server re-announces this channel */
3051 #if 0 /* We will announce our CMODE anyway for this channel, so no need
3052 to check it (implicit enforce). */
3054 /* If the mode is different from what we have then enforce the
3056 mode = silc_channel_get_mode(payload);
3057 if (channel->mode != mode) {
3058 SILC_LOG_DEBUG(("Forcing the server to change channel mode"));
3059 silc_server_send_notify_cmode(server, sock, FALSE, channel,
3060 channel->mode, server->id,
3061 SILC_ID_SERVER, channel->cipher,
3063 channel->passphrase,
3064 channel->founder_key);
3068 /* Create new key for the channel and send it to the server and
3069 everybody else possibly on the channel. */
3070 if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
3072 if (silc_hash_table_count(channel->user_list)) {
3073 if (!silc_server_create_channel_key(server, channel, 0)) {
3074 silc_channel_payload_free(payload);
3078 /* Send to the channel */
3079 silc_server_send_channel_key(server, sock, channel, FALSE);
3082 /* Send to the server */
3083 silc_id_id2str(channel->id, SILC_ID_CHANNEL, cid, sizeof(cid),
3085 cipher = silc_cipher_get_name(channel->send_key);
3086 cipher_len = strlen(cipher);
3087 chk = silc_channel_key_payload_encode(id_len, cid,
3089 channel->key_len / 8,
3091 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
3092 chk->data, silc_buffer_len(chk));
3093 silc_buffer_free(chk);
3096 /* Since the channel is coming from server and we also know about it
3097 then send the JOIN notify to the server so that it see's our
3098 users on the channel "joining" the channel. */
3099 silc_server_announce_get_channel_users(server, channel, &modes, &users,
3102 silc_buffer_push(users, users->data - users->head);
3103 silc_server_packet_send(server, sock,
3104 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
3105 users->data, silc_buffer_len(users));
3106 silc_buffer_free(users);
3109 silc_buffer_push(modes, modes->data - modes->head);
3110 silc_server_packet_send_dest(server, sock,
3111 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
3112 channel->id, SILC_ID_CHANNEL,
3113 modes->data, silc_buffer_len(modes));
3114 silc_buffer_free(modes);
3117 silc_buffer_push(users_modes, users_modes->data - users_modes->head);
3118 silc_server_packet_send_dest(server, sock,
3119 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
3120 channel->id, SILC_ID_CHANNEL,
3122 silc_buffer_len(users_modes));
3123 silc_buffer_free(users_modes);
3125 if (channel->topic) {
3126 silc_server_send_notify_topic_set(server, sock,
3127 server->server_type == SILC_ROUTER ?
3128 TRUE : FALSE, channel,
3129 server->id, SILC_ID_SERVER,
3135 /* If the sender of this packet is server and we are router we need to
3136 broadcast this packet to other routers in the network. Broadcast
3137 this list packet instead of multiple New Channel packets. */
3138 if (server->server_type == SILC_ROUTER &&
3139 idata->conn_type == SILC_CONN_SERVER &&
3140 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
3141 SILC_LOG_DEBUG(("Broadcasting received New Channel packet"));
3142 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3144 packet->flags | SILC_PACKET_FLAG_BROADCAST,
3145 buffer->data, silc_buffer_len(buffer));
3146 silc_server_backup_send(server, (SilcServerEntry)idata,
3147 packet->type, packet->flags,
3148 buffer->data, silc_buffer_len(buffer),
3152 silc_free(channel_namec);
3153 silc_channel_payload_free(payload);
3156 /* Received New Channel packet. Information about new channels in the
3157 network are distributed using this packet. Save the information about
3158 the new channel. This usually comes from router but also normal server
3159 can send this to notify channels it has when it connects to us. */
3161 void silc_server_new_channel(SilcServer server,
3162 SilcPacketStream sock,
3165 silc_server_new_channel_process(server, sock, packet, &packet->buffer);
3166 silc_packet_free(packet);
3169 /* Received New Channel List packet, list of New Channel List payloads inside
3170 one packet. Process the New Channel payloads one by one. */
3172 void silc_server_new_channel_list(SilcServer server,
3173 SilcPacketStream sock,
3176 SilcIDListData idata = silc_packet_get_context(sock);
3178 SilcUInt16 len1, len2;
3180 SILC_LOG_DEBUG(("Processing New Channel List"));
3182 if (idata->conn_type == SILC_CONN_CLIENT ||
3183 packet->src_id_type != SILC_ID_SERVER ||
3184 server->server_type == SILC_SERVER) {
3185 silc_packet_free(packet);
3189 buffer = silc_buffer_alloc(512);
3191 silc_packet_free(packet);
3195 while (silc_buffer_len(&packet->buffer)) {
3196 SILC_GET16_MSB(len1, packet->buffer.data);
3197 if ((len1 > silc_buffer_len(&packet->buffer)) ||
3198 (len1 > silc_buffer_truelen(buffer)))
3201 SILC_GET16_MSB(len2, packet->buffer.data + 2 + len1);
3202 if ((len2 > silc_buffer_len(&packet->buffer)) ||
3203 (len2 > silc_buffer_truelen(buffer)))
3206 silc_buffer_pull_tail(buffer, 8 + len1 + len2);
3207 silc_buffer_put(buffer, packet->buffer.data, 8 + len1 + len2);
3209 /* Process the New Channel */
3210 silc_server_new_channel_process(server, sock, packet, buffer);
3212 silc_buffer_push_tail(buffer, 8 + len1 + len2);
3213 silc_buffer_pull(&packet->buffer, 8 + len1 + len2);
3216 silc_buffer_free(buffer);
3217 silc_packet_free(packet);
3220 /* Received key agreement packet. This packet is never for us. It is to
3221 the client in the packet's destination ID. Sending of this sort of packet
3222 equals sending private message, ie. it is sent point to point from
3223 one client to another. */
3225 void silc_server_key_agreement(SilcServer server,
3226 SilcPacketStream sock,
3229 SilcPacketStream dst_sock;
3230 SilcIDListData idata;
3232 SILC_LOG_DEBUG(("Start"));
3234 if (packet->src_id_type != SILC_ID_CLIENT ||
3235 packet->dst_id_type != SILC_ID_CLIENT || !packet->dst_id) {
3236 silc_packet_free(packet);
3240 /* Get the route to the client */
3241 dst_sock = silc_server_get_client_route(server, packet->dst_id,
3242 packet->dst_id_len, NULL,
3245 silc_packet_free(packet);
3249 /* Relay the packet */
3250 silc_server_packet_route(server, dst_sock, packet);
3251 silc_packet_free(packet);
3254 /* Received connection auth request packet that is used during connection
3255 phase to resolve the mandatory authentication method. This packet can
3256 actually be received at anytime but usually it is used only during
3257 the connection authentication phase. Now, protocol says that this packet
3258 can come from client or server, however, we support only this coming
3259 from client and expect that server always knows what authentication
3262 void silc_server_connection_auth_request(SilcServer server,
3263 SilcPacketStream sock,
3266 SilcServerConfigClient *client = NULL;
3267 SilcUInt16 conn_type;
3269 SilcAuthMethod auth_meth = SILC_AUTH_NONE;
3270 const char *hostname, *ip;
3272 if (packet->src_id_type && packet->src_id_type != SILC_ID_CLIENT) {
3273 SILC_LOG_DEBUG(("Request not from client"));
3274 silc_packet_free(packet);
3278 silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
3279 NULL, &hostname, &ip, NULL);
3281 /* Parse the payload */
3282 ret = silc_buffer_unformat(&packet->buffer,
3283 SILC_STR_UI_SHORT(&conn_type),
3284 SILC_STR_UI_SHORT(NULL),
3286 if (ret == -1 || conn_type != SILC_CONN_CLIENT) {
3287 silc_packet_free(packet);
3291 /* Get the authentication method for the client */
3292 auth_meth = SILC_AUTH_NONE;
3293 client = silc_server_config_find_client(server, (char *)ip);
3295 client = silc_server_config_find_client(server, (char *)hostname);
3297 if (client->passphrase) {
3298 if (client->publickeys && !server->config->prefer_passphrase_auth)
3299 auth_meth = SILC_AUTH_PUBLIC_KEY;
3301 auth_meth = SILC_AUTH_PASSWORD;
3302 } else if (client->publickeys)
3303 auth_meth = SILC_AUTH_PUBLIC_KEY;
3306 SILC_LOG_DEBUG(("Authentication method is [%s]",
3307 (auth_meth == SILC_AUTH_NONE ? "None" :
3308 auth_meth == SILC_AUTH_PASSWORD ? "Passphrase" :
3309 "Digital signatures")));
3311 /* Send it back to the client */
3312 silc_server_send_connection_auth_request(server, sock, conn_type, auth_meth);
3313 silc_packet_free(packet);
3316 /* Received file transger packet. This packet is never for us. It is to
3317 the client in the packet's destination ID. Sending of this sort of packet
3318 equals sending private message, ie. it is sent point to point from
3319 one client to another. */
3321 void silc_server_ftp(SilcServer server,
3322 SilcPacketStream sock,
3325 SilcPacketStream dst_sock;
3326 SilcIDListData idata;
3328 SILC_LOG_DEBUG(("Start"));
3330 if (packet->src_id_type != SILC_ID_CLIENT ||
3331 packet->dst_id_type != SILC_ID_CLIENT || !packet->dst_id) {
3332 silc_packet_free(packet);
3336 /* Get the route to the client */
3337 dst_sock = silc_server_get_client_route(server, packet->dst_id,
3338 packet->dst_id_len, NULL,
3341 silc_packet_free(packet);
3345 /* Relay the packet */
3346 silc_server_packet_route(server, dst_sock, packet);
3347 silc_packet_free(packet);
3352 SilcPacketStream sock;
3354 SilcClientID client_id;
3355 } *SilcServerResumeResolve;
3357 SILC_SERVER_CMD_FUNC(resume_resolve)
3359 SilcServerResumeResolve r = (SilcServerResumeResolve)context;
3360 SilcServer server = r->server;
3361 SilcPacketStream sock = r->sock;
3362 SilcServerCommandReplyContext reply = context2;
3363 SilcClientEntry client;
3364 const char *hostname, *ip;
3366 SILC_LOG_DEBUG(("Start"));
3368 silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
3369 NULL, &hostname, &ip, NULL);
3371 if (!reply || !silc_command_get_status(reply->payload, NULL, NULL)) {
3372 SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
3373 "closing connection", hostname, ip));
3374 silc_server_disconnect_remote(server, sock,
3375 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3376 "Resuming not possible");
3377 silc_server_free_sock_user_data(server, sock, NULL);
3381 if (reply && silc_command_get(reply->payload) == SILC_COMMAND_WHOIS) {
3382 /* Get entry to the client, and resolve it if we don't have it. */
3383 client = silc_idlist_find_client_by_id(server->local_list,
3384 &r->client_id, TRUE, NULL);
3386 client = silc_idlist_find_client_by_id(server->global_list,
3387 &r->client_id, TRUE, NULL);
3389 SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
3390 "closing connection", hostname, ip));
3391 silc_server_disconnect_remote(server, sock,
3392 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3393 "Resuming not possible");
3394 silc_server_free_sock_user_data(server, sock, NULL);
3399 if (!(client->mode & SILC_UMODE_DETACHED)) {
3400 SILC_LOG_ERROR(("Client %s (%s) tried to resume un-detached client, "
3401 "closing connection", hostname, ip));
3402 silc_server_disconnect_remote(server, sock,
3403 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3404 "Resuming not possible");
3405 silc_server_free_sock_user_data(server, sock, NULL);
3409 client->data.status |= SILC_IDLIST_STATUS_RESUME_RES;
3412 /* Reprocess the packet */
3413 silc_server_resume_client(server, sock, r->packet);
3416 silc_packet_stream_unref(r->sock);
3420 /* Received client resuming packet. This is used to resume detached
3421 client session. It can be sent by the client who wishes to resume
3422 but this is also sent by servers and routers to notify other routers
3423 that the client is not detached anymore. */
3425 void silc_server_resume_client(SilcServer server,
3426 SilcPacketStream sock,
3429 SilcBuffer buffer = &packet->buffer, buf;
3430 SilcIDListData idata = silc_packet_get_context(sock);
3431 SilcIDCacheEntry id_cache = NULL;
3432 SilcClientEntry detached_client;
3433 SilcClientID client_id;
3434 unsigned char *id_string, *auth = NULL, *nicknamec = NULL;
3435 unsigned char cid[32];
3437 SilcUInt16 id_len, auth_len = 0;
3438 SilcBool resolved, local, nick_change = FALSE, resolve = FALSE;
3439 SilcChannelEntry channel;
3440 SilcHashTableList htl;
3441 SilcChannelClientEntry chl;
3442 SilcServerResumeResolve r;
3443 SilcPublicKey public_key;
3444 const char *cipher, *hostname, *ip;
3446 SILC_LOG_DEBUG(("Resuming client"));
3448 silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
3449 NULL, &hostname, &ip, NULL);
3451 if (silc_buffer_unformat(buffer,
3452 SILC_STR_UI16_NSTRING(&id_string, &id_len),
3453 SILC_STR_END) < 0) {
3454 if (idata->conn_type == SILC_CONN_CLIENT) {
3455 SILC_LOG_ERROR(("Client %s (%s) sent incomplete resume information, "
3456 "closing connection", hostname, ip));
3457 silc_server_disconnect_remote(server, sock,
3458 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3459 "Resuming not possible");
3460 silc_server_free_sock_user_data(server, sock, NULL);
3465 silc_id_str2id(id_string, id_len, SILC_ID_CLIENT, &client_id,
3468 if (idata->conn_type == SILC_CONN_CLIENT) {
3469 /* Client send this and is attempting to resume to old client session */
3470 SilcClientEntry client;
3473 silc_buffer_pull(buffer, 2 + id_len);
3474 auth = buffer->data;
3475 auth_len = silc_buffer_len(buffer);
3476 silc_buffer_push(buffer, 2 + id_len);
3478 if (auth_len < 128) {
3479 SILC_LOG_ERROR(("Client %s (%s) sent incomplete resume information, "
3480 "closing connection", hostname, ip));
3481 silc_server_disconnect_remote(server, sock,
3482 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3483 "Resuming not possible");
3484 silc_server_free_sock_user_data(server, sock, NULL);
3488 /* Take client entry of this connection */
3489 client = (SilcClientEntry)idata;
3491 /* Get entry to the client, and resolve it if we don't have it. */
3492 detached_client = silc_server_query_client(server, &client_id, FALSE,
3494 if (!detached_client) {
3496 /* The client info is being resolved. Reprocess this packet after
3497 receiving the reply to the query. */
3498 SILC_LOG_DEBUG(("Resolving client"));
3499 r = silc_calloc(1, sizeof(*r));
3502 silc_packet_stream_ref(sock);
3506 r->client_id = client_id;
3507 silc_server_command_pending(server, SILC_COMMAND_WHOIS,
3509 silc_server_command_resume_resolve, r);
3512 SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
3513 "closing connection", hostname, ip));
3514 silc_server_disconnect_remote(server, sock,
3515 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3516 "Resuming not possible");
3517 silc_server_free_sock_user_data(server, sock, NULL);
3522 if (detached_client->data.status & SILC_IDLIST_STATUS_RESUMED) {
3523 SILC_LOG_ERROR(("Client %s (%s) tried to attach more than once, "
3524 "closing connection", hostname, ip));
3525 silc_server_disconnect_remote(server, sock,
3526 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3527 "Resuming not possible");
3528 silc_server_free_sock_user_data(server, sock, NULL);
3532 if (detached_client->resuming_client &&
3533 detached_client->resuming_client != client) {
3534 SILC_LOG_ERROR(("Client %s (%s) tried to attach more than once, "
3535 "closing connection", hostname, ip));
3536 silc_server_disconnect_remote(server, sock,
3537 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3538 "Resuming not possible");
3539 silc_server_free_sock_user_data(server, sock, NULL);
3543 if (!detached_client->resuming_client)
3544 detached_client->resuming_client = client;
3546 if (!(detached_client->mode & SILC_UMODE_DETACHED))
3548 if (!silc_hash_table_count(detached_client->channels) &&
3549 detached_client->router)
3551 if (!detached_client->nickname)
3553 if (detached_client->data.status & SILC_IDLIST_STATUS_RESUME_RES)
3557 if (server->server_type == SILC_SERVER && !server->standalone) {
3558 /* The client info is being resolved. Reprocess this packet after
3559 receiving the reply to the query. */
3560 SILC_LOG_DEBUG(("Resolving client info"));
3561 silc_server_query_client(server, &client_id, TRUE, NULL);
3562 r = silc_calloc(1, sizeof(*r));
3565 silc_packet_stream_ref(sock);
3569 r->client_id = client_id;
3570 silc_server_command_pending(server, SILC_COMMAND_WHOIS,
3572 silc_server_command_resume_resolve, r);
3575 if (server->server_type == SILC_SERVER) {
3576 SILC_LOG_ERROR(("Client %s (%s) tried to resume un-detached client, "
3577 "closing connection", hostname, ip));
3578 silc_server_disconnect_remote(server, sock,
3579 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3580 "Resuming not possible");
3581 silc_server_free_sock_user_data(server, sock, NULL);
3586 /* Check that we have the public key of the client, if not then we must
3587 resolve it first. */
3588 if (!detached_client->data.public_key) {
3589 if (server->server_type == SILC_SERVER && server->standalone) {
3590 SILC_LOG_ERROR(("Detached client's public key not present, "
3591 "closing connection"));
3592 silc_server_disconnect_remote(server, sock,
3593 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3594 "Resuming not possible");
3595 silc_server_free_sock_user_data(server, sock, NULL);
3598 /* We must retrieve the detached client's public key by sending
3599 GETKEY command. Reprocess this packet after receiving the key */
3600 SilcBuffer idp = silc_id_payload_encode(&client_id, SILC_ID_CLIENT);
3601 SilcPacketStream dest_sock =
3602 silc_server_get_client_route(server, NULL, 0, &client_id,
3605 SILC_LOG_DEBUG(("Resolving client public key"));
3607 silc_server_send_command(server, dest_sock ? dest_sock :
3608 SILC_PRIMARY_ROUTE(server),
3609 SILC_COMMAND_GETKEY, ++server->cmd_ident,
3610 1, 1, idp->data, silc_buffer_len(idp));
3612 r = silc_calloc(1, sizeof(*r));
3615 silc_packet_stream_ref(sock);
3619 r->client_id = client_id;
3620 silc_server_command_pending(server, SILC_COMMAND_GETKEY,
3622 silc_server_command_resume_resolve, r);
3624 silc_buffer_free(idp);
3627 } else if (!silc_pkcs_public_key_compare(detached_client->data.public_key,
3628 idata->public_key)) {
3629 /* We require that the connection and resuming authentication data
3630 must be using same key pair. */
3631 SILC_LOG_ERROR(("Resuming attempted with wrong public key, "
3632 "closing connection"));
3633 silc_server_disconnect_remote(server, sock,
3634 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3635 "Resuming not possible");
3636 silc_server_free_sock_user_data(server, sock, NULL);
3640 /* Verify the authentication payload. This has to be successful in
3641 order to allow the resuming */
3643 !silc_auth_verify_data(auth, auth_len, SILC_AUTH_PUBLIC_KEY,
3644 detached_client->data.public_key, 0,
3645 idata->hash, detached_client->id,
3647 SILC_LOG_ERROR(("Client %s (%s) resume authentication failed, "
3648 "closing connection", hostname, ip));
3649 silc_server_disconnect_remote(server, sock,
3650 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3651 "Resuming not possible");
3652 silc_server_free_sock_user_data(server, sock, NULL);
3656 /* Check nickname */
3657 nicknamec = silc_identifier_check(detached_client->nickname,
3658 strlen(detached_client->nickname),
3659 SILC_STRING_UTF8, 128, NULL);
3661 silc_server_disconnect_remote(server, sock,
3662 SILC_STATUS_ERR_BAD_NICKNAME,
3663 "Malformed nickname, cannot resume");
3664 silc_server_free_sock_user_data(server, sock, NULL);
3668 /* If the ID is not based in our ID then change it */
3669 if (!SILC_ID_COMPARE(detached_client->id, server->id,
3670 server->id->ip.data_len)) {
3671 SilcClientID *new_id;
3672 if (!silc_id_create_client_id(server, server->id, server->rng,
3673 server->md5hash, nicknamec,
3674 strlen(nicknamec), &new_id)) {
3675 silc_server_disconnect_remote(server, sock,
3676 SILC_STATUS_ERR_BAD_NICKNAME,
3677 "Resuming not possible");
3678 silc_server_free_sock_user_data(server, sock, NULL);
3682 client_id = *new_id;
3686 /* Now resume the client to the network */
3688 silc_schedule_task_del_by_context(server->schedule, detached_client);
3689 silc_packet_set_context(sock, detached_client);
3690 detached_client->connection = sock;
3692 if (detached_client->data.public_key) {
3693 /* Delete the detached client's public key from repository */
3694 silc_skr_del_public_key(server->repository,
3695 detached_client->data.public_key,
3697 detached_client->data.public_key = NULL;
3700 if (idata->public_key) {
3701 /* Delete the resuming client's public key from repository. It will
3702 be added later again. */
3703 public_key = silc_pkcs_public_key_copy(idata->public_key);
3704 silc_skr_del_public_key(server->repository, idata->public_key, idata);
3705 idata->public_key = public_key;
3708 /* Take new keys and stuff into use in the old entry */
3709 silc_idlist_del_data(detached_client);
3710 silc_idlist_add_data(detached_client, idata);
3711 idata->public_key = NULL;
3713 if (detached_client->data.public_key) {
3714 /* Add the resumed client's public key back to repository. */
3715 if (!silc_server_get_public_key_by_client(server, detached_client, NULL))
3716 silc_skr_add_public_key_simple(server->repository,
3717 detached_client->data.public_key,
3718 SILC_SKR_USAGE_IDENTIFICATION,
3719 detached_client, NULL);
3722 detached_client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
3723 detached_client->data.status |= SILC_IDLIST_STATUS_RESUMED;
3724 detached_client->data.status |= SILC_IDLIST_STATUS_LOCAL;
3725 detached_client->data.status &= ~SILC_IDLIST_STATUS_RESUME_RES;
3726 detached_client->mode &= ~SILC_UMODE_DETACHED;
3727 server->stat.my_detached--;
3728 silc_dlist_del(server->expired_clients, detached_client);
3730 /* We are finished - reset resuming client */
3731 detached_client->resuming_client = NULL;
3733 /* Check if anyone is watching this client */
3734 if (server->server_type == SILC_ROUTER)
3735 silc_server_check_watcher_list(server, detached_client, NULL,
3736 SILC_NOTIFY_TYPE_UMODE_CHANGE);
3738 /* Delete this current client entry since we're resuming to old one. */
3739 server->stat.my_clients--;
3740 assert(server->stat.clients > 0);
3741 server->stat.clients--;
3742 if (server->stat.cell_clients)
3743 server->stat.cell_clients--;
3744 silc_server_remove_from_channels(server, NULL, client, FALSE,
3745 NULL, FALSE, FALSE);
3746 silc_server_del_from_watcher_list(server, client);
3747 silc_dlist_del(server->expired_clients, client);
3748 if (!silc_idlist_del_client(server->local_list, client))
3749 silc_idlist_del_client(server->global_list, client);
3750 client = detached_client;
3751 silc_free(client->servername);
3752 client->servername = strdup(server->server_name);
3754 /* Send the RESUME_CLIENT packet to our primary router so that others
3755 know this client isn't detached anymore. */
3756 buf = silc_buffer_alloc_size(2 + id_len);
3757 silc_buffer_format(buf,
3758 SILC_STR_UI_SHORT(id_len),
3759 SILC_STR_UI_XNSTRING(id_string, id_len),
3762 /* Send to primary router */
3763 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3764 SILC_PACKET_RESUME_CLIENT, 0,
3765 buf->data, silc_buffer_len(buf));
3766 silc_server_backup_send(server, client->router,
3767 SILC_PACKET_RESUME_CLIENT, 0,
3768 buf->data, silc_buffer_len(buf), TRUE, TRUE);
3770 /* As router we must deliver this packet directly to the original
3771 server whom this client was earlier. */
3772 if (server->server_type == SILC_ROUTER && client->router &&
3773 client->router->server_type != SILC_ROUTER)
3774 silc_server_packet_send(server, client->router->connection,
3775 SILC_PACKET_RESUME_CLIENT, 0,
3776 buf->data, silc_buffer_len(buf));
3777 silc_buffer_free(buf);
3778 client->router = NULL;
3781 /* Notify about Client ID change, nickname doesn't actually change. */
3782 silc_server_send_notify_nick_change(server, SILC_PRIMARY_ROUTE(server),
3783 SILC_BROADCAST(server),
3784 client->id, &client_id,
3788 /* Resolve users on those channels that client has joined but we
3789 haven't resolved user list yet. */
3790 if (server->server_type == SILC_SERVER && !server->standalone) {
3791 silc_hash_table_list(client->channels, &htl);
3792 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
3793 channel = chl->channel;
3794 SILC_LOG_DEBUG(("Resolving users for %s channel",
3795 channel->channel_name));
3796 if (channel->disabled || !channel->users_resolved) {
3797 silc_server_send_command(server, SILC_PRIMARY_ROUTE(server),
3798 SILC_COMMAND_USERS, ++server->cmd_ident,
3799 1, 2, channel->channel_name,
3800 strlen(channel->channel_name));
3803 silc_hash_table_list_reset(&htl);
3806 /* Send the new client ID to the client. After this client may start
3807 receiving other packets, and may start sending packets too. */
3808 silc_server_send_new_id(server, sock, FALSE, &client_id, SILC_ID_CLIENT,
3809 silc_id_get_len(&client_id, SILC_ID_CLIENT));
3812 /* Send NICK change notify to channels as well. */
3813 SilcBuffer oidp, nidp;
3814 oidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
3815 nidp = silc_id_payload_encode(&client_id, SILC_ID_CLIENT);
3816 silc_server_send_notify_on_channels(server, NULL, client,
3817 SILC_NOTIFY_TYPE_NICK_CHANGE, 3,
3818 oidp->data, silc_buffer_len(oidp),
3819 nidp->data, silc_buffer_len(nidp),
3821 strlen(client->nickname));
3822 silc_buffer_free(oidp);
3823 silc_buffer_free(nidp);
3827 if (!silc_idcache_update_by_context(server->local_list->clients, client,
3828 &client_id, NULL, FALSE))
3829 silc_idcache_update_by_context(server->global_list->clients, client,
3830 &client_id, NULL, FALSE);
3832 /* Move entry to local list if it is in global list */
3833 if (silc_idcache_find_by_context(server->global_list->clients, client,
3835 silc_idcache_move(server->global_list->clients,
3836 server->local_list->clients, id_cache);
3838 /* Send some nice info to the client */
3839 silc_server_send_connect_notifys(server, sock, client);
3841 /* Send all channel keys of channels the client has joined */
3842 silc_hash_table_list(client->channels, &htl);
3843 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
3844 SilcBool created = FALSE;
3845 channel = chl->channel;
3847 if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY)
3850 /* If we don't have channel key, then create one */
3851 if (!channel->send_key) {
3852 if (!silc_server_create_channel_key(server, channel, 0))
3857 silc_id_id2str(channel->id, SILC_ID_CHANNEL, cid, sizeof(cid),
3859 cipher = silc_cipher_get_name(channel->send_key);
3861 silc_channel_key_payload_encode(cid_len, cid,
3862 strlen(cipher), cipher,
3863 channel->key_len / 8, channel->key);
3865 /* Send the channel key to the client */
3866 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
3867 keyp->data, silc_buffer_len(keyp));
3869 /* Distribute the channel key to channel */
3871 silc_server_send_channel_key(server, NULL, channel,
3872 server->server_type == SILC_ROUTER ?
3873 FALSE : !server->standalone);
3874 silc_server_backup_send(server, NULL, SILC_PACKET_CHANNEL_KEY, 0,
3875 keyp->data, silc_buffer_len(keyp),
3879 silc_buffer_free(keyp);
3881 silc_hash_table_list_reset(&htl);
3883 } else if (idata->conn_type != SILC_CONN_CLIENT) {
3884 /* Server or router sent this to us to notify that that a client has
3886 SilcServerEntry server_entry;
3887 SilcServerID server_id;
3889 /* Get entry to the client, and resolve it if we don't have it. */
3890 detached_client = silc_idlist_find_client_by_id(server->local_list,
3893 if (!detached_client) {
3894 detached_client = silc_idlist_find_client_by_id(server->global_list,
3897 if (!detached_client) {
3898 SILC_LOG_DEBUG(("Resuming client is unknown"));
3903 /* Check that the client has not been resumed already because it is
3904 protocol error to attempt to resume more than once. The client
3905 will be killed if this protocol error occurs. */
3906 if (detached_client->data.status & SILC_IDLIST_STATUS_RESUMED &&
3907 !(detached_client->mode & SILC_UMODE_DETACHED)) {
3908 /* The client is clearly attempting to resume more than once and
3909 perhaps playing around by resuming from several different places
3910 at the same time. */
3911 SILC_LOG_DEBUG(("Attempting to re-resume client, killing both"));
3912 silc_server_kill_client(server, detached_client, NULL,
3913 server->id, SILC_ID_SERVER);
3917 /* Check whether client is detached at all */
3918 if (!(detached_client->mode & SILC_UMODE_DETACHED)) {
3919 SILC_LOG_DEBUG(("Client is not detached"));
3923 /* Check nickname */
3924 if (detached_client->nickname) {
3925 nicknamec = silc_identifier_check(detached_client->nickname,
3926 strlen(detached_client->nickname),
3927 SILC_STRING_UTF8, 128, NULL);
3932 SILC_LOG_DEBUG(("Resuming detached client"));
3934 /* If the sender of this packet is server and we are router we need to
3935 broadcast this packet to other routers in the network. */
3936 if (server->server_type == SILC_ROUTER &&
3937 idata->conn_type == SILC_CONN_SERVER &&
3938 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
3939 SILC_LOG_DEBUG(("Broadcasting received Resume Client packet"));
3940 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3942 packet->flags | SILC_PACKET_FLAG_BROADCAST,
3943 buffer->data, silc_buffer_len(buffer));
3944 silc_server_backup_send(server, (SilcServerEntry)idata,
3945 packet->type, packet->flags,
3946 packet->buffer.data,
3947 silc_buffer_len(&packet->buffer),
3951 /* Client is detached, and now it is resumed. Remove the detached
3952 mode and mark that it is resumed. */
3954 if (detached_client->data.public_key) {
3955 /* Delete the detached client's public key from repository */
3956 silc_skr_del_public_key(server->repository,
3957 detached_client->data.public_key,
3959 detached_client->data.public_key = NULL;
3962 silc_idlist_del_data(detached_client);
3963 detached_client->mode &= ~SILC_UMODE_DETACHED;
3964 detached_client->data.status |= SILC_IDLIST_STATUS_RESUMED;
3965 detached_client->data.status &= ~SILC_IDLIST_STATUS_LOCAL;
3966 silc_dlist_del(server->expired_clients, detached_client);
3968 /* Check if anyone is watching this client */
3969 if (server->server_type == SILC_ROUTER)
3970 silc_server_check_watcher_list(server, detached_client, NULL,
3971 SILC_NOTIFY_TYPE_UMODE_CHANGE);
3973 silc_schedule_task_del_by_context(server->schedule, detached_client);
3975 /* Get the new owner of the resumed client */
3976 if (!silc_id_str2id(packet->src_id, packet->src_id_len,
3977 packet->src_id_type, &server_id, sizeof(server_id)))
3980 /* Get server entry */
3981 server_entry = silc_idlist_find_server_by_id(server->global_list,
3982 &server_id, TRUE, NULL);
3984 if (!server_entry) {
3985 server_entry = silc_idlist_find_server_by_id(server->local_list,
3986 &server_id, TRUE, NULL);
3992 if (server->server_type == SILC_ROUTER &&
3993 idata->conn_type == SILC_CONN_ROUTER &&
3994 server_entry->server_type == SILC_ROUTER)
3997 /* Move entry to correct list */
3998 if (local && server->server_type == SILC_ROUTER) {
3999 if (silc_idcache_find_by_context(server->global_list->clients,
4000 detached_client, &id_cache))
4001 silc_idcache_move(server->global_list->clients,
4002 server->local_list->clients, id_cache);
4004 if (silc_idcache_find_by_context(server->local_list->clients,
4005 detached_client, &id_cache))
4006 silc_idcache_move(server->local_list->clients,
4007 server->global_list->clients, id_cache);
4010 /* Change the owner of the client */
4011 detached_client->router = server_entry;
4013 /* Update channel information regarding global clients on channel. */
4014 if (server->server_type != SILC_ROUTER) {
4015 silc_hash_table_list(detached_client->channels, &htl);
4016 while (silc_hash_table_get(&htl, NULL, (void *)&chl))
4017 chl->channel->global_users =
4018 silc_server_channel_has_global(chl->channel);
4019 silc_hash_table_list_reset(&htl);
4024 silc_packet_free(packet);