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"
24 /* Received notify packet. Server can receive notify packets from router.
25 Server then relays the notify messages to clients if needed. */
27 static void silc_server_notify_process(SilcServer server,
28 SilcPacketStream sock,
32 SilcIDListData idata = silc_packet_get_context(sock);
33 SilcNotifyPayload payload;
35 SilcArgumentPayload args;
36 SilcChannelID channel_id;
38 SilcChannelEntry channel = NULL;
39 SilcClientEntry client = NULL, client2 = NULL;
40 SilcServerEntry server_entry = NULL;
41 SilcChannelClientEntry chl;
42 SilcIDCacheEntry cache = NULL;
43 SilcHashTableList htl;
45 unsigned char *tmp, *tmp2;
46 SilcUInt32 tmp_len, tmp2_len;
49 if (idata->conn_type == SILC_CONN_CLIENT) {
50 SILC_LOG_DEBUG(("Notify received from client, drop it"));
54 if (packet->src_id_type != SILC_ID_SERVER){
55 SILC_LOG_DEBUG(("Bad notify packet received"));
59 if (!packet->dst_id) {
60 SILC_LOG_DEBUG(("Bad notify packet received"));
64 /* If the packet is destined directly to a client then relay the packet
65 before processing it. */
66 if (packet->dst_id_type == SILC_ID_CLIENT) {
68 SilcPacketStream dst_sock;
70 /* Get the route to the client */
71 dst_sock = silc_server_get_client_route(server, packet->dst_id,
72 packet->dst_id_len, NULL,
75 /* Relay the packet */
76 silc_server_packet_route(server, dst_sock, packet);
79 /* Parse the Notify Payload */
80 payload = silc_notify_payload_parse(buffer->data, silc_buffer_len(buffer));
82 SILC_LOG_DEBUG(("Marlformed notify payload"));
86 /* If we are router and this packet is not already broadcast packet
87 we will broadcast it. The sending socket really cannot be router or
88 the router is buggy. If this packet is coming from router then it must
89 have the broadcast flag set already and we won't do anything. */
90 if (server->server_type == SILC_ROUTER &&
91 idata->conn_type == SILC_CONN_SERVER &&
92 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
93 SILC_LOG_DEBUG(("Broadcasting received Notify packet"));
94 if (packet->dst_id_type == SILC_ID_CHANNEL) {
95 /* Packet is destined to channel */
96 if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
97 packet->dst_id_type, &channel_id,
98 sizeof(channel_id))) {
99 SILC_LOG_DEBUG(("Malformed destination ID in notify packet"));
103 silc_server_packet_send_dest(server, SILC_PRIMARY_ROUTE(server),
104 packet->type, packet->flags |
105 SILC_PACKET_FLAG_BROADCAST,
106 &channel_id, SILC_ID_CHANNEL,
107 buffer->data, silc_buffer_len(buffer));
108 silc_server_backup_send_dest(server, (SilcServerEntry)idata,
109 packet->type, packet->flags,
110 &channel_id, SILC_ID_CHANNEL,
111 buffer->data, silc_buffer_len(buffer),
114 /* Packet is destined to client or server */
115 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
117 packet->flags | SILC_PACKET_FLAG_BROADCAST,
118 buffer->data, silc_buffer_len(buffer));
119 silc_server_backup_send(server, (SilcServerEntry)idata,
120 packet->type, packet->flags,
121 buffer->data, silc_buffer_len(buffer),
126 type = silc_notify_get_type(payload);
127 args = silc_notify_get_args(payload);
129 SILC_LOG_DEBUG(("Notify doesn't have any arguments, drop it"));
134 case SILC_NOTIFY_TYPE_JOIN:
136 * Distribute the notify to local clients on the channel
138 SILC_LOG_DEBUG(("JOIN notify"));
141 if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL))
144 /* Get channel entry */
145 channel = silc_idlist_find_channel_by_id(server->global_list,
146 SILC_ID_GET_ID(id), NULL);
148 channel = silc_idlist_find_channel_by_id(server->local_list,
149 SILC_ID_GET_ID(id), NULL);
151 SILC_LOG_DEBUG(("Notify for unknown channel %s",
152 silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
158 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
161 /* If the the client is not in local list we check global list (ie. the
162 channel will be global channel) and if it does not exist then create
163 entry for the client. */
164 client = silc_idlist_find_client_by_id(server->global_list,
169 client = silc_idlist_find_client_by_id(server->local_list,
174 /* If router did not find the client the it is bogus */
175 if (server->server_type != SILC_SERVER)
179 silc_idlist_add_client(server->global_list, NULL, NULL, NULL,
180 silc_id_dup(SILC_ID_GET_ID(id),
182 (SilcServerEntry)idata, NULL);
184 SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
188 client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
192 /* Do not process the notify if the client is not registered */
193 if (!(client->data.status & SILC_IDLIST_STATUS_REGISTERED))
196 /* Do not add client to channel if it is there already */
197 if (silc_server_client_on_channel(client, channel, NULL)) {
198 SILC_LOG_DEBUG(("Client already on channel %s",
199 channel->channel_name));
203 /* Send to channel */
204 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
205 FALSE, TRUE, buffer->data,
206 silc_buffer_len(buffer));
208 if (server->server_type != SILC_ROUTER &&
209 idata->conn_type == SILC_CONN_ROUTER)
210 /* The channel is global now */
211 channel->global_users = TRUE;
213 SILC_LOG_DEBUG(("Joining to channel %s", channel->channel_name));
215 /* JOIN the global client to the channel (local clients (if router
216 created the channel) is joined in the pending JOIN command). */
217 chl = silc_calloc(1, sizeof(*chl));
220 chl->client = client;
221 chl->channel = channel;
223 if (server->server_type != SILC_ROUTER ||
224 idata->conn_type == SILC_CONN_ROUTER) {
225 /* If founder auth is set, first client is not automatically founder. */
226 if (!(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
227 /* If this is the first one on the channel then it is the founder of
228 the channel. This is done on normal server and on router if this
229 notify is coming from router */
230 if (!silc_hash_table_count(channel->user_list)) {
231 SILC_LOG_DEBUG(("Client %s is founder on channel",
232 silc_id_render(chl->client->id, SILC_ID_CLIENT)));
233 chl->mode = (SILC_CHANNEL_UMODE_CHANOP | SILC_CHANNEL_UMODE_CHANFO);
238 silc_hash_table_add(channel->user_list, client, chl);
239 silc_hash_table_add(client->channels, channel, chl);
240 channel->user_count++;
241 channel->disabled = FALSE;
243 /* Update statistics */
244 if (server->server_type == SILC_ROUTER) {
245 if (idata->conn_type != SILC_CONN_ROUTER)
246 server->stat.cell_chanclients++;
247 server->stat.chanclients++;
252 case SILC_NOTIFY_TYPE_LEAVE:
254 * Distribute the notify to local clients on the channel
256 SILC_LOG_DEBUG(("LEAVE notify"));
258 if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
259 packet->dst_id_type, &channel_id,
263 /* Get channel entry */
264 channel = silc_idlist_find_channel_by_id(server->global_list,
267 channel = silc_idlist_find_channel_by_id(server->local_list,
270 SILC_LOG_DEBUG(("Notify for unknown channel %s",
271 silc_id_render(&channel_id, SILC_ID_CHANNEL)));
277 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
280 /* Get client entry */
281 client = silc_idlist_find_client_by_id(server->global_list,
282 SILC_ID_GET_ID(id), TRUE, NULL);
284 client = silc_idlist_find_client_by_id(server->local_list,
285 SILC_ID_GET_ID(id), TRUE, NULL);
290 /* Check if on channel */
291 if (!silc_server_client_on_channel(client, channel, NULL))
294 /* Send the leave notify to channel */
295 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
296 FALSE, TRUE, buffer->data,
297 silc_buffer_len(buffer));
299 /* Remove the user from channel */
300 silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
303 case SILC_NOTIFY_TYPE_SIGNOFF:
305 * Distribute the notify to local clients on the channel
307 SILC_LOG_DEBUG(("SIGNOFF notify"));
310 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
313 /* Get client entry */
314 client = silc_idlist_find_client_by_id(server->global_list,
315 SILC_ID_GET_ID(id), TRUE, &cache);
317 client = silc_idlist_find_client_by_id(server->local_list,
318 SILC_ID_GET_ID(id), TRUE, &cache);
323 /* Get signoff message */
324 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
328 /* Update statistics */
329 SILC_VERIFY(server->stat.clients > 0);
330 server->stat.clients--;
331 if (server->stat.cell_clients)
332 server->stat.cell_clients--;
333 SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
334 SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
335 silc_schedule_task_del_by_context(server->schedule, client);
337 /* Remove client's public key from repository, this will free it too. */
338 if (client->data.public_key) {
339 silc_skr_del_public_key(server->repository, client->data.public_key,
341 client->data.public_key = NULL;
344 /* Remove the client from all channels. */
345 silc_server_remove_from_channels(server, NULL, client, TRUE,
348 /* Check if anyone is watching this nickname */
349 if (server->server_type == SILC_ROUTER)
350 silc_server_check_watcher_list(server, client, NULL,
351 SILC_NOTIFY_TYPE_SIGNOFF);
353 /* Remove this client from watcher list if it is */
354 silc_server_del_from_watcher_list(server, client);
356 client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
358 client->router = NULL;
359 client->connection = NULL;
360 client->data.created = silc_time();
361 silc_dlist_del(server->expired_clients, client);
362 silc_dlist_add(server->expired_clients, client);
365 case SILC_NOTIFY_TYPE_TOPIC_SET:
367 * Distribute the notify to local clients on the channel
370 SILC_LOG_DEBUG(("TOPIC SET notify"));
373 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
376 /* Get client entry */
377 if (id.type == SILC_ID_CLIENT) {
378 client = silc_idlist_find_client_by_id(server->global_list,
379 SILC_ID_GET_ID(id), TRUE, &cache);
381 client = silc_idlist_find_client_by_id(server->local_list,
390 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
394 if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
395 packet->dst_id_type, &channel_id,
399 /* Get channel entry */
400 channel = silc_idlist_find_channel_by_id(server->global_list,
403 channel = silc_idlist_find_channel_by_id(server->local_list,
406 SILC_LOG_DEBUG(("Notify for unknown channel %s",
407 silc_id_render(&channel_id, SILC_ID_CHANNEL)));
412 if (channel->topic && !strcmp(channel->topic, tmp)) {
413 SILC_LOG_DEBUG(("Topic is already set and same"));
418 /* Get user's channel entry and check that topic set is allowed. */
419 if (!silc_server_client_on_channel(client, channel, &chl))
421 if (channel->mode & SILC_CHANNEL_MODE_TOPIC &&
422 !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
423 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
424 SILC_LOG_DEBUG(("Topic change is not allowed"));
429 /* Change the topic */
430 silc_free(channel->topic);
431 channel->topic = strdup(tmp);
433 /* Send the same notify to the channel */
434 silc_server_packet_send_to_channel(server, NULL, channel, packet->type,
435 FALSE, TRUE, buffer->data,
436 silc_buffer_len(buffer));
439 case SILC_NOTIFY_TYPE_NICK_CHANGE:
442 * Distribute the notify to local clients on the channel
445 SilcUInt32 nickname_len;
447 SILC_LOG_DEBUG(("NICK CHANGE notify"));
449 /* Get old client ID */
450 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
453 /* Get new client ID */
454 if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id2, NULL))
457 SILC_LOG_DEBUG(("Old Client ID id(%s)",
458 silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CLIENT)));
459 SILC_LOG_DEBUG(("New Client ID id(%s)",
460 silc_id_render(SILC_ID_GET_ID(id2), SILC_ID_CLIENT)));
462 /* From protocol version 1.1 we also get the new nickname */
463 nickname = silc_argument_get_arg_type(args, 3, &nickname_len);;
465 /* Replace the Client ID */
466 client = silc_idlist_replace_client_id(server,
469 SILC_ID_GET_ID(id2), nickname);
471 client = silc_idlist_replace_client_id(server,
474 SILC_ID_GET_ID(id2), nickname);
477 /* Send the NICK_CHANGE notify type to local clients on the channels
478 this client is joined to. */
479 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
480 tmp2 = silc_argument_get_arg_type(args, 2, &tmp2_len);
481 silc_server_send_notify_on_channels(server, client, client,
482 SILC_NOTIFY_TYPE_NICK_CHANGE, 3,
483 tmp, tmp_len, tmp2, tmp2_len,
491 case SILC_NOTIFY_TYPE_CMODE_CHANGE:
493 * Distribute the notify to local clients on the channel
496 SILC_LOG_DEBUG(("CMODE CHANGE notify"));
499 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
502 /* Get client entry */
503 if (id.type == SILC_ID_CLIENT) {
504 client = silc_idlist_find_client_by_id(server->global_list,
505 SILC_ID_GET_ID(id), TRUE, &cache);
507 client = silc_idlist_find_client_by_id(server->local_list,
515 if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
516 packet->dst_id_type, &channel_id,
520 /* Get channel entry */
521 channel = silc_idlist_find_channel_by_id(server->global_list,
524 channel = silc_idlist_find_channel_by_id(server->local_list,
527 SILC_LOG_DEBUG(("Notify for unknown channel %s",
528 silc_id_render(&channel_id, SILC_ID_CHANNEL)));
534 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
537 SILC_GET32_MSB(mode, tmp);
539 /* Check if mode changed */
540 if (channel->mode == mode) {
541 SILC_LOG_DEBUG(("Mode is changed already"));
543 /* If this mode change has founder mode then we'll enforce the
544 change so that the server gets the real founder public key */
545 if (server->server_type != SILC_SERVER &&
546 sock != SILC_PRIMARY_ROUTE(server) &&
547 mode & SILC_CHANNEL_MODE_FOUNDER_AUTH && channel->founder_key) {
548 SILC_LOG_DEBUG(("Sending founder public key to server"));
549 silc_server_send_notify_cmode(server, sock, FALSE, channel,
550 channel->mode, server->id,
551 SILC_ID_SERVER, channel->cipher,
554 channel->founder_key, NULL);
557 /* If we received same mode from our primary check whether founder
558 mode and key in the notify is set. We update the founder key
559 here since we may have wrong one */
560 if (server->server_type != SILC_ROUTER &&
561 sock == SILC_PRIMARY_ROUTE(server) &&
562 mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
563 SILC_LOG_DEBUG(("Founder public key received from router"));
564 tmp = silc_argument_get_arg_type(args, 6, &tmp_len);
568 if (channel->founder_key)
569 silc_pkcs_public_key_free(channel->founder_key);
570 channel->founder_key = NULL;
571 silc_public_key_payload_decode(tmp, tmp_len,
572 &channel->founder_key);
575 /* Check also for channel public key list */
576 if (server->server_type == SILC_SERVER &&
577 sock == SILC_PRIMARY_ROUTE(server) &&
578 mode & SILC_CHANNEL_MODE_CHANNEL_AUTH) {
581 unsigned char mask[4], ulimit[4];
583 SILC_LOG_DEBUG(("Channel public key list received from router"));
584 tmp = silc_argument_get_arg_type(args, 7, &tmp_len);
588 /* Set the router's list, and send the notify to channel too so that
589 channel gets the list */
590 silc_server_set_channel_pk_list(server, sock, channel, tmp, tmp_len);
591 chpklist = silc_server_get_channel_pk_list(server, channel,
595 sidp = silc_id_payload_encode(server->router->id, SILC_ID_SERVER);
596 SILC_PUT32_MSB(channel->mode, mask);
597 if (channel->mode & SILC_CHANNEL_MODE_ULIMIT)
598 SILC_PUT32_MSB(channel->user_limit, ulimit);
599 silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
600 SILC_NOTIFY_TYPE_CMODE_CHANGE, 8,
601 sidp->data, silc_buffer_len(sidp),
605 strlen(channel->cipher) : 0,
608 strlen(channel->hmac_name) : 0,
610 channel->passphrase ?
611 strlen(channel->passphrase) : 0,
614 silc_buffer_len(chpklist),
616 SILC_CHANNEL_MODE_ULIMIT ?
619 SILC_CHANNEL_MODE_ULIMIT ?
620 sizeof(ulimit) : 0));
621 silc_buffer_free(sidp);
622 silc_buffer_free(chpklist);
629 /* Get user's channel entry and check that mode change is allowed */
631 if (!silc_server_client_on_channel(client, channel, &chl))
633 if (!silc_server_check_cmode_rights(server, channel, chl, mode)) {
634 SILC_LOG_DEBUG(("CMODE change is not allowed"));
635 silc_server_send_notify_cmode(server, sock, FALSE, channel,
636 channel->mode, server->id,
637 SILC_ID_SERVER, channel->cipher,
640 channel->founder_key, NULL);
644 /* Assure that server is not removing founder mode from us */
645 if (server->server_type == SILC_ROUTER &&
646 sock != SILC_PRIMARY_ROUTE(server) &&
647 channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH &&
648 !(mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
649 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
650 silc_server_send_notify_cmode(server, sock, FALSE, channel,
651 channel->mode, server->id,
652 SILC_ID_SERVER, channel->cipher,
655 channel->founder_key, NULL);
659 /* If server is adding founder mode, check whether there is founder
660 on channel already and is not from this server */
661 if (server->server_type == SILC_ROUTER &&
662 sock != SILC_PRIMARY_ROUTE(server) &&
663 mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
664 silc_hash_table_list(channel->user_list, &htl);
665 while (silc_hash_table_get(&htl, NULL, (void *)&chl))
666 if (chl->mode & SILC_CHANNEL_UMODE_CHANFO &&
667 chl->client->router != (SilcServerEntry)idata) {
668 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
669 silc_server_send_notify_cmode(server, sock, FALSE, channel,
670 channel->mode, server->id,
671 SILC_ID_SERVER, channel->cipher,
674 channel->founder_key, NULL);
675 silc_hash_table_list_reset(&htl);
678 silc_hash_table_list_reset(&htl);
682 /* If the channel had private keys set and the mode was removed then
683 we must re-generate and re-distribute a new channel key */
684 if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY &&
685 !(mode & SILC_CHANNEL_MODE_PRIVKEY)) {
686 /* Re-generate channel key */
687 if (!silc_server_create_channel_key(server, channel, 0))
690 /* Send the channel key. This sends it to our local clients and if
691 we are normal server to our router as well. */
692 silc_server_send_channel_key(server, NULL, channel,
693 server->server_type == SILC_ROUTER ?
694 FALSE : !server->standalone);
698 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
700 unsigned char hash[SILC_HASH_MAXLEN];
703 silc_hmac_free(channel->hmac);
704 if (!silc_hmac_alloc(tmp, NULL, &channel->hmac))
707 /* Set the HMAC key out of current channel key. The client must do
709 silc_hash_make(silc_hmac_get_hash(channel->hmac), channel->key,
710 channel->key_len / 8, hash);
711 silc_hmac_set_key(channel->hmac, hash,
712 silc_hash_len(silc_hmac_get_hash(channel->hmac)));
713 memset(hash, 0, sizeof(hash));
716 /* Get the passphrase */
717 tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
719 silc_free(channel->passphrase);
720 channel->passphrase = silc_memdup(tmp, tmp_len);
723 /* Get founder public key */
724 tmp = silc_argument_get_arg_type(args, 6, &tmp_len);
725 if (tmp && mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
726 if (channel->founder_key)
727 silc_pkcs_public_key_free(channel->founder_key);
728 channel->founder_key = NULL;
729 SILC_LOG_DEBUG(("Founder public key received"));
730 if (!silc_public_key_payload_decode(tmp, tmp_len,
731 &channel->founder_key)) {
732 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
733 mode &= ~SILC_CHANNEL_MODE_FOUNDER_AUTH;
734 silc_server_send_notify_cmode(server, sock, FALSE, channel,
735 mode, server->id, SILC_ID_SERVER,
738 channel->passphrase, NULL, NULL);
739 if (channel->founder_key)
740 silc_pkcs_public_key_free(channel->founder_key);
741 channel->founder_key = NULL;
745 if (mode & SILC_CHANNEL_MODE_FOUNDER_AUTH && !channel->founder_key &&
746 server->server_type == SILC_ROUTER) {
747 SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
748 mode &= ~SILC_CHANNEL_MODE_FOUNDER_AUTH;
749 silc_server_send_notify_cmode(server, sock, FALSE, channel,
750 mode, server->id, SILC_ID_SERVER,
753 channel->passphrase, NULL, NULL);
756 /* Process channel public key(s). */
757 tmp = silc_argument_get_arg_type(args, 7, &tmp_len);
758 if (tmp && mode & SILC_CHANNEL_MODE_CHANNEL_AUTH) {
760 SILC_LOG_DEBUG(("Channel public key list received from router"));
763 silc_server_set_channel_pk_list(server, sock, channel, tmp, tmp_len);
765 /* If list was set already we will enforce the same list to server. */
766 if (ret == SILC_STATUS_ERR_OPERATION_ALLOWED) {
767 SilcBuffer chpklist = silc_server_get_channel_pk_list(server, channel,
769 silc_server_send_notify_cmode(server, sock, FALSE, channel,
770 mode, server->id, SILC_ID_SERVER,
773 channel->passphrase, NULL,
775 silc_buffer_free(chpklist);
779 /* Get the user limit */
780 tmp = silc_argument_get_arg_type(args, 8, &tmp_len);
781 if (tmp && tmp_len == 4 && mode & SILC_CHANNEL_MODE_ULIMIT)
782 SILC_GET32_MSB(channel->user_limit, tmp);
784 /* Send the same notify to the channel */
785 silc_server_packet_send_to_channel(server, NULL, channel, packet->type,
786 FALSE, TRUE, buffer->data,
787 silc_buffer_len(buffer));
790 channel->mode = mode;
792 /* Cleanup if some modes are removed */
794 if (!(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) &&
795 channel->founder_key) {
796 silc_pkcs_public_key_free(channel->founder_key);
797 channel->founder_key = NULL;
800 if (!(channel->mode & SILC_CHANNEL_MODE_CHANNEL_AUTH) &&
801 channel->channel_pubkeys) {
802 silc_hash_table_free(channel->channel_pubkeys);
803 channel->channel_pubkeys = NULL;
808 case SILC_NOTIFY_TYPE_CUMODE_CHANGE:
811 * Distribute the notify to local clients on the channel
813 SilcChannelClientEntry chl2 = NULL;
814 SilcBool notify_sent = FALSE;
816 SILC_LOG_DEBUG(("CUMODE CHANGE notify"));
819 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
822 /* Get client entry */
823 if (id.type == SILC_ID_CLIENT) {
824 client = silc_idlist_find_client_by_id(server->global_list,
828 client = silc_idlist_find_client_by_id(server->local_list,
836 if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
837 packet->dst_id_type, &channel_id,
841 /* Get channel entry */
842 channel = silc_idlist_find_channel_by_id(server->global_list,
845 channel = silc_idlist_find_channel_by_id(server->local_list,
848 SILC_LOG_DEBUG(("Notify for unknown channel %s",
849 silc_id_render(&channel_id, SILC_ID_CHANNEL)));
855 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
859 SILC_GET32_MSB(mode, tmp);
861 /* Get target client */
862 if (!silc_argument_get_decoded(args, 3, SILC_ARGUMENT_ID, &id, NULL))
865 /* Get client entry */
866 client2 = silc_idlist_find_client_by_id(server->global_list,
867 SILC_ID_GET_ID(id), TRUE, NULL);
869 client2 = silc_idlist_find_client_by_id(server->local_list,
877 /* Check that sender is on channel */
878 if (!silc_server_client_on_channel(client, channel, &chl))
881 if (client != client2 && server->server_type == SILC_ROUTER) {
882 /* Sender must be operator */
883 if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
884 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
885 SILC_LOG_DEBUG(("CUMODE change is not allowed"));
889 if (!silc_server_client_on_channel(client2, channel, &chl))
892 /* If target is founder mode change is not allowed. */
893 if (chl->mode & SILC_CHANNEL_UMODE_CHANFO) {
894 SILC_LOG_DEBUG(("CUMODE change is not allowed"));
900 /* Get target channel user entry */
901 if (!silc_server_client_on_channel(client2, channel, &chl))
904 if (server->server_type == SILC_SERVER && chl->mode == mode) {
905 SILC_LOG_DEBUG(("Mode is changed already"));
909 /* Check whether to give founder rights to this user or not. The
910 problem here is that we get only the public key of the client,
911 but no authentication data. We must assume that server has
912 already authenticated the user (and thus we must trust the
914 if (mode & SILC_CHANNEL_UMODE_CHANFO &&
915 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO) &&
916 server->server_type == SILC_ROUTER &&
917 sock != SILC_PRIMARY_ROUTE(server)) {
918 SilcPublicKey founder_key = NULL;
920 /* If channel doesn't have founder auth mode then it's impossible
921 that someone would be getting founder rights with CUMODE command.
922 In that case there already either is founder or there isn't
923 founder at all on the channel (valid only when 'client' is
925 if (client && !(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
926 /* Force the mode to not have founder mode */
927 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
928 silc_server_force_cumode_change(server, sock, channel, chl, mode);
933 /* Get the founder of the channel and if found then this client
934 cannot be the founder since there already is one. */
935 silc_hash_table_list(channel->user_list, &htl);
936 while (silc_hash_table_get(&htl, NULL, (void *)&chl2))
937 if (chl2->mode & SILC_CHANNEL_UMODE_CHANFO) {
938 SILC_LOG_DEBUG(("Founder already on channel"));
939 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
940 silc_server_force_cumode_change(server, sock, channel,
945 silc_hash_table_list_reset(&htl);
946 if (!(mode & SILC_CHANNEL_UMODE_CHANFO))
949 /* Founder not found on the channel. Since the founder auth mode
950 is set on the channel now check whether this is the client that
951 originally set the mode. */
953 if (channel->founder_key) {
954 /* Get public key that must be present in notify */
955 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
956 if (!tmp || !silc_public_key_payload_decode(tmp, tmp_len,
958 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
959 SILC_LOG_DEBUG(("Founder public key not present"));
960 silc_server_force_cumode_change(server, sock, channel, chl, mode);
965 /* Now match the public key we have cached and public key sent.
967 if (!silc_pkcs_public_key_compare(channel->founder_key,
969 chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
970 SILC_LOG_DEBUG(("Founder public key mismatch"));
971 silc_server_force_cumode_change(server, sock, channel, chl, mode);
977 /* There cannot be anyone else as founder on the channel now. This
978 client is definitely the founder due to this 'authentication'.
979 We trust the server did the actual signature verification
980 earlier (bad, yes). */
981 silc_hash_table_list(channel->user_list, &htl);
982 while (silc_hash_table_get(&htl, NULL, (void *)&chl2))
983 if (chl2->mode & SILC_CHANNEL_UMODE_CHANFO) {
984 chl2->mode &= ~SILC_CHANNEL_UMODE_CHANFO;
985 SILC_LOG_DEBUG(("Removing old founder rights, new authenticated"));
986 silc_server_force_cumode_change(server, NULL, channel, chl2,
990 silc_hash_table_list_reset(&htl);
993 silc_pkcs_public_key_free(founder_key);
996 if (server->server_type != SILC_SERVER && chl->mode == mode) {
997 SILC_LOG_DEBUG(("Mode is changed already"));
1001 SILC_LOG_DEBUG(("Changing %s channel user mode",
1002 chl->client->nickname ? chl->client->nickname :
1003 (unsigned char *)""));
1005 /* Change the mode */
1008 /* Send the same notify to the channel */
1010 silc_server_packet_send_to_channel(server, sock, channel,
1012 FALSE, TRUE, buffer->data,
1013 silc_buffer_len(buffer));
1018 case SILC_NOTIFY_TYPE_INVITE:
1020 if (packet->dst_id_type == SILC_ID_CLIENT)
1023 SILC_LOG_DEBUG(("INVITE notify"));
1025 /* Get Channel ID */
1026 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
1029 /* Get channel entry */
1030 channel = silc_idlist_find_channel_by_id(server->global_list,
1031 SILC_ID_GET_ID(id), NULL);
1033 channel = silc_idlist_find_channel_by_id(server->local_list,
1034 SILC_ID_GET_ID(id), NULL);
1036 SILC_LOG_DEBUG(("Notify for unknown channel %s",
1037 silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
1042 /* Get the invite action */
1043 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
1044 if (tmp && tmp_len == 1) {
1045 SilcUInt8 action = (SilcUInt8)tmp[0];
1046 SilcUInt16 iargc = 0;
1047 SilcArgumentPayload iargs;
1049 /* Get invite list */
1050 tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
1051 if (!tmp || tmp_len < 2)
1054 /* Parse the arguments to see they are constructed correctly */
1055 SILC_GET16_MSB(iargc, tmp);
1056 iargs = silc_argument_payload_parse(tmp + 2, tmp_len - 2, iargc);
1060 if (!channel->invite_list)
1061 channel->invite_list =
1062 silc_hash_table_alloc(0, silc_hash_ptr,
1064 silc_server_inviteban_destruct, channel, TRUE);
1066 /* Proces the invite action */
1067 if (!silc_server_inviteban_process(server, channel->invite_list, action,
1070 silc_argument_payload_free(iargs);
1072 /* If we are router we must send this notify to our local servers on
1073 the channel. Normal server does nothing. The notify is not
1075 if (server->server_type == SILC_ROUTER)
1076 silc_server_packet_send_to_channel(server, sock, channel,
1077 packet->type, FALSE, FALSE,
1079 silc_buffer_len(buffer));
1084 case SILC_NOTIFY_TYPE_CHANNEL_CHANGE:
1086 * Distribute to the local clients on the channel and change the
1090 SILC_LOG_DEBUG(("CHANNEL CHANGE"));
1092 if (idata->conn_type != SILC_CONN_ROUTER)
1095 /* Get the old Channel ID */
1096 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
1099 /* Get the channel entry */
1100 channel = silc_idlist_find_channel_by_id(server->local_list,
1101 SILC_ID_GET_ID(id), NULL);
1103 channel = silc_idlist_find_channel_by_id(server->global_list,
1104 SILC_ID_GET_ID(id), NULL);
1106 SILC_LOG_DEBUG(("Notify for unknown channel %s",
1107 silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
1112 /* Send the notify to the channel */
1113 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
1114 FALSE, TRUE, buffer->data,
1115 silc_buffer_len(buffer));
1117 /* Get the new Channel ID */
1118 if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id2, NULL))
1121 SILC_LOG_DEBUG(("Old Channel ID id(%s)",
1122 silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
1123 SILC_LOG_DEBUG(("New Channel ID id(%s)",
1124 silc_id_render(SILC_ID_GET_ID(id2), SILC_ID_CHANNEL)));
1126 /* Replace the Channel ID */
1128 if (!silc_idlist_replace_channel_id(server->local_list,
1130 SILC_ID_GET_ID(id2)))
1131 if (!silc_idlist_replace_channel_id(server->global_list,
1133 SILC_ID_GET_ID(id2)))
1137 SilcBuffer modes = NULL, users = NULL, users_modes = NULL;
1139 /* Re-announce this channel which ID was changed. */
1140 silc_server_send_new_channel(server, sock, FALSE, channel->channel_name,
1142 silc_id_get_len(channel->id,
1146 /* Re-announce our clients on the channel as the ID has changed now */
1147 silc_server_announce_get_channel_users(server, channel, &modes, &users,
1150 silc_buffer_push(users, users->data - users->head);
1151 silc_server_packet_send(server, sock,
1152 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1153 users->data, silc_buffer_len(users));
1154 silc_buffer_free(users);
1157 silc_buffer_push(modes, modes->data - modes->head);
1158 silc_server_packet_send_dest(server, sock,
1159 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1160 channel->id, SILC_ID_CHANNEL,
1161 modes->data, silc_buffer_len(modes));
1162 silc_buffer_free(modes);
1165 silc_buffer_push(users_modes, users_modes->data - users_modes->head);
1166 silc_server_packet_send_dest(server, sock,
1167 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1168 channel->id, SILC_ID_CHANNEL,
1170 silc_buffer_len(users_modes));
1171 silc_buffer_free(users_modes);
1174 /* Re-announce channel's topic */
1175 if (channel->topic) {
1176 silc_server_send_notify_topic_set(server, sock,
1177 server->server_type == SILC_ROUTER ?
1178 TRUE : FALSE, channel,
1179 server->id, SILC_ID_SERVER,
1186 case SILC_NOTIFY_TYPE_SERVER_SIGNOFF:
1188 * Remove the server entry and all clients that this server owns.
1191 SILC_LOG_DEBUG(("SERVER SIGNOFF notify"));
1193 /* Backup router shouldn't accept SERVER_SIGNOFF's from normal routers
1194 when the backup isn't acting as primary router. */
1195 if (idata->conn_type == SILC_CONN_SERVER &&
1196 server->backup_router && server->server_type == SILC_BACKUP_ROUTER)
1200 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
1203 /* If the ID is mine, this notify is not allowed. */
1204 if (SILC_ID_SERVER_COMPARE(SILC_ID_GET_ID(id), server->id)) {
1205 SILC_LOG_DEBUG(("Ignoring my own ID for SERVER_SIGNOFF"));
1209 /* Get server entry */
1210 server_entry = silc_idlist_find_server_by_id(server->global_list,
1214 if (!server_entry) {
1215 server_entry = silc_idlist_find_server_by_id(server->local_list,
1219 if (!server_entry) {
1220 /* If we are normal server then we might not have the server. Check
1221 whether router was kind enough to send the list of all clients
1222 that actually was to be removed. Remove them if the list is
1224 if (server->server_type != SILC_ROUTER &&
1225 silc_argument_get_arg_num(args) > 1) {
1228 for (i = 1; i < silc_argument_get_arg_num(args); i++) {
1230 if (!silc_argument_get_decoded(args, i + 1, SILC_ARGUMENT_ID,
1234 /* Get client entry */
1235 client = silc_idlist_find_client_by_id(server->global_list,
1236 SILC_ID_GET_ID(id2),
1240 client = silc_idlist_find_client_by_id(server->local_list,
1241 SILC_ID_GET_ID(id2),
1248 /* Update statistics */
1249 SILC_VERIFY(server->stat.clients > 0);
1250 server->stat.clients--;
1251 if (server->stat.cell_clients)
1252 server->stat.cell_clients--;
1253 SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
1254 SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
1256 /* Remove the client from all channels. */
1257 silc_server_remove_from_channels(server, NULL, client,
1258 TRUE, NULL, FALSE, FALSE);
1260 /* Check if anyone is watching this nickname */
1261 if (server->server_type == SILC_ROUTER)
1262 silc_server_check_watcher_list(server, client, NULL,
1263 SILC_NOTIFY_TYPE_SERVER_SIGNOFF);
1265 /* Remove this client from watcher list if it is */
1267 silc_server_del_from_watcher_list(server, client);
1269 /* Remove the client */
1270 silc_dlist_del(server->expired_clients, client);
1271 silc_idlist_del_data(client);
1272 silc_idlist_del_client(local ? server->local_list :
1273 server->global_list, client);
1281 /* For local entrys SERVER_SIGNOFF is processed only on backup router.
1282 It is possible that router sends server signoff for a server. If
1283 backup router has it as local connection it will be closed. */
1284 if (SILC_IS_LOCAL(server_entry)) {
1285 if (server->server_type == SILC_BACKUP_ROUTER) {
1286 sock = server_entry->connection;
1287 SILC_LOG_DEBUG(("Closing connection after SERVER_SIGNOFF"));
1288 silc_server_free_sock_user_data(server, sock, NULL);
1289 silc_server_close_connection(server, sock);
1295 /* Remove all servers that are originated from this server, and
1296 remove the clients of those servers too. */
1297 silc_server_remove_servers_by_server(server, server_entry, TRUE);
1299 /* Remove the clients that this server owns as they will become
1301 silc_server_remove_clients_by_server(server, server_entry->router,
1302 server_entry, TRUE);
1303 silc_server_backup_del(server, server_entry);
1305 /* Remove the server entry */
1306 silc_idlist_del_server(local ? server->local_list :
1307 server->global_list, server_entry);
1309 /* Update statistics */
1310 if (server->server_type == SILC_ROUTER)
1311 server->stat.servers--;
1315 case SILC_NOTIFY_TYPE_KICKED:
1317 * Distribute the notify to local clients on the channel
1320 SILC_LOG_DEBUG(("KICKED notify"));
1322 if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
1323 packet->dst_id_type, &channel_id,
1324 sizeof(channel_id)))
1327 /* Get channel entry */
1328 channel = silc_idlist_find_channel_by_id(server->global_list,
1331 channel = silc_idlist_find_channel_by_id(server->local_list,
1334 SILC_LOG_DEBUG(("Notify for unknown channel %s",
1335 silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
1341 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
1344 /* If the the client is not in local list we check global list */
1345 client = silc_idlist_find_client_by_id(server->global_list,
1346 SILC_ID_GET_ID(id), TRUE, NULL);
1348 client = silc_idlist_find_client_by_id(server->local_list,
1349 SILC_ID_GET_ID(id), TRUE, NULL);
1354 /* If target is founder they cannot be kicked */
1355 if (!silc_server_client_on_channel(client, channel, &chl))
1357 if (chl->mode & SILC_CHANNEL_UMODE_CHANFO)
1360 /* Get the kicker's Client ID */
1361 if (!silc_argument_get_decoded(args, 3, SILC_ARGUMENT_ID, &id, NULL))
1364 /* If the the client is not in local list we check global list */
1365 client2 = silc_idlist_find_client_by_id(server->global_list,
1366 SILC_ID_GET_ID(id), TRUE, NULL);
1368 client2 = silc_idlist_find_client_by_id(server->local_list,
1369 SILC_ID_GET_ID(id), TRUE, NULL);
1374 /* Kicker must be operator on channel */
1375 if (!silc_server_client_on_channel(client2, channel, &chl))
1377 if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
1378 !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
1379 SILC_LOG_DEBUG(("Kicking is not allowed"));
1383 /* Send to channel */
1384 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
1385 FALSE, TRUE, buffer->data,
1386 silc_buffer_len(buffer));
1388 /* Remove the client from channel's invite list */
1389 if (channel->invite_list && silc_hash_table_count(channel->invite_list)) {
1391 SilcArgumentPayload iargs;
1392 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1393 ab = silc_argument_payload_encode_one(NULL, tmp, tmp_len, 3);
1394 iargs = silc_argument_payload_parse(ab->data, silc_buffer_len(ab), 1);
1395 silc_server_inviteban_process(server, channel->invite_list, 1, iargs);
1396 silc_buffer_free(ab);
1397 silc_argument_payload_free(iargs);
1400 /* Remove the client from channel */
1401 silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
1405 case SILC_NOTIFY_TYPE_KILLED:
1408 * Distribute the notify to local clients on channels
1410 unsigned char *comment;
1411 SilcUInt32 comment_len;
1413 SILC_LOG_DEBUG(("KILLED notify"));
1416 if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
1419 /* If the the client is not in local list we check global list */
1420 client = silc_idlist_find_client_by_id(server->global_list,
1421 SILC_ID_GET_ID(id), TRUE, &cache);
1423 client = silc_idlist_find_client_by_id(server->local_list,
1430 /* If the client is one of ours, then close the connection to the
1431 client now. This removes the client from all channels as well. */
1432 if (packet->dst_id_type == SILC_ID_CLIENT && client->connection) {
1433 sock = client->connection;
1434 silc_server_free_client_data(server, NULL, client, FALSE, NULL);
1435 silc_server_close_connection(server, sock);
1440 comment = silc_argument_get_arg_type(args, 2, &comment_len);
1441 if (comment_len > 128)
1444 /* Get the killer's Client ID */
1445 if (!silc_argument_get_decoded(args, 3, SILC_ARGUMENT_ID, &id, NULL))
1448 if (id.type == SILC_ID_CLIENT) {
1449 /* If the the client is not in local list we check global list */
1450 client2 = silc_idlist_find_client_by_id(server->global_list,
1454 client2 = silc_idlist_find_client_by_id(server->local_list,
1461 /* Killer must be router operator */
1462 if (server->server_type != SILC_SERVER &&
1463 !(client2->mode & SILC_UMODE_ROUTER_OPERATOR)) {
1464 SILC_LOG_DEBUG(("Killing is not allowed"));
1469 /* Send the notify to local clients on the channels except to the
1470 client who is killed. */
1471 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1472 tmp2 = silc_argument_get_arg_type(args, 3, &tmp2_len);
1473 silc_server_send_notify_on_channels(server, client, client,
1474 SILC_NOTIFY_TYPE_KILLED, 3,
1475 tmp, tmp_len, comment, comment_len,
1478 /* Remove the client from all channels */
1479 silc_server_remove_from_channels(server, NULL, client, FALSE, NULL,
1482 /* Check if anyone is watching this nickname */
1483 if (server->server_type == SILC_ROUTER)
1484 silc_server_check_watcher_list(server, client, NULL,
1485 SILC_NOTIFY_TYPE_KILLED);
1487 /* Remove client's public key from repository, this will free it too. */
1488 if (client->data.public_key) {
1489 silc_skr_del_public_key(server->repository, client->data.public_key,
1491 client->data.public_key = NULL;
1494 /* Update statistics */
1495 SILC_VERIFY(server->stat.clients > 0);
1496 server->stat.clients--;
1497 if (server->stat.cell_clients)
1498 server->stat.cell_clients--;
1499 SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
1500 SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
1502 if (SILC_IS_LOCAL(client)) {
1503 if (!client->local_detached)
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 We decrement clients/cell_clients as we are getting rid of the
3740 current client and replacing it with the detached one. We keep the
3741 server user count as-is (incremented by the current client entry) as
3742 we decremented the count already during detach, thus we'd be undoing
3744 detached_client->local_detached = FALSE;
3745 SILC_VERIFY(server->stat.clients > 0);
3746 server->stat.clients--;
3747 if (server->stat.cell_clients)
3748 server->stat.cell_clients--;
3749 silc_server_remove_from_channels(server, NULL, client, FALSE,
3750 NULL, FALSE, FALSE);
3751 silc_server_del_from_watcher_list(server, client);
3752 silc_dlist_del(server->expired_clients, client);
3753 if (!silc_idlist_del_client(server->local_list, client))
3754 silc_idlist_del_client(server->global_list, client);
3755 client = detached_client;
3756 silc_free(client->servername);
3757 client->servername = strdup(server->server_name);
3759 /* Send the RESUME_CLIENT packet to our primary router so that others
3760 know this client isn't detached anymore. */
3761 buf = silc_buffer_alloc_size(2 + id_len);
3762 silc_buffer_format(buf,
3763 SILC_STR_UI_SHORT(id_len),
3764 SILC_STR_UI_XNSTRING(id_string, id_len),
3767 /* Send to primary router */
3768 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3769 SILC_PACKET_RESUME_CLIENT, 0,
3770 buf->data, silc_buffer_len(buf));
3771 silc_server_backup_send(server, client->router,
3772 SILC_PACKET_RESUME_CLIENT, 0,
3773 buf->data, silc_buffer_len(buf), TRUE, TRUE);
3775 /* As router we must deliver this packet directly to the original
3776 server whom this client was earlier. */
3777 if (server->server_type == SILC_ROUTER && client->router &&
3778 client->router->server_type != SILC_ROUTER)
3779 silc_server_packet_send(server, client->router->connection,
3780 SILC_PACKET_RESUME_CLIENT, 0,
3781 buf->data, silc_buffer_len(buf));
3782 silc_buffer_free(buf);
3783 client->router = NULL;
3786 /* Notify about Client ID change, nickname doesn't actually change. */
3787 silc_server_send_notify_nick_change(server, SILC_PRIMARY_ROUTE(server),
3788 SILC_BROADCAST(server),
3789 client->id, &client_id,
3793 /* Resolve users on those channels that client has joined but we
3794 haven't resolved user list yet. */
3795 if (server->server_type == SILC_SERVER && !server->standalone) {
3796 silc_hash_table_list(client->channels, &htl);
3797 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
3798 channel = chl->channel;
3799 SILC_LOG_DEBUG(("Resolving users for %s channel",
3800 channel->channel_name));
3801 if (channel->disabled || !channel->users_resolved) {
3802 silc_server_send_command(server, SILC_PRIMARY_ROUTE(server),
3803 SILC_COMMAND_USERS, ++server->cmd_ident,
3804 1, 2, channel->channel_name,
3805 strlen(channel->channel_name));
3808 silc_hash_table_list_reset(&htl);
3811 /* Send the new client ID to the client. After this client may start
3812 receiving other packets, and may start sending packets too. */
3813 silc_server_send_new_id(server, sock, FALSE, &client_id, SILC_ID_CLIENT,
3814 silc_id_get_len(&client_id, SILC_ID_CLIENT));
3817 /* Send NICK change notify to channels as well. */
3818 SilcBuffer oidp, nidp;
3819 oidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
3820 nidp = silc_id_payload_encode(&client_id, SILC_ID_CLIENT);
3821 silc_server_send_notify_on_channels(server, NULL, client,
3822 SILC_NOTIFY_TYPE_NICK_CHANGE, 3,
3823 oidp->data, silc_buffer_len(oidp),
3824 nidp->data, silc_buffer_len(nidp),
3826 strlen(client->nickname));
3827 silc_buffer_free(oidp);
3828 silc_buffer_free(nidp);
3832 if (!silc_idcache_update_by_context(server->local_list->clients, client,
3833 &client_id, NULL, FALSE))
3834 silc_idcache_update_by_context(server->global_list->clients, client,
3835 &client_id, NULL, FALSE);
3837 /* Move entry to local list if it is in global list */
3838 if (silc_idcache_find_by_context(server->global_list->clients, client,
3840 silc_idcache_move(server->global_list->clients,
3841 server->local_list->clients, id_cache);
3843 /* Send some nice info to the client */
3844 silc_server_send_connect_notifys(server, sock, client);
3846 /* Send all channel keys of channels the client has joined */
3847 silc_hash_table_list(client->channels, &htl);
3848 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
3849 SilcBool created = FALSE;
3850 channel = chl->channel;
3852 if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY)
3855 /* If we don't have channel key, then create one */
3856 if (!channel->send_key) {
3857 if (!silc_server_create_channel_key(server, channel, 0))
3862 silc_id_id2str(channel->id, SILC_ID_CHANNEL, cid, sizeof(cid),
3864 cipher = silc_cipher_get_name(channel->send_key);
3866 silc_channel_key_payload_encode(cid_len, cid,
3867 strlen(cipher), cipher,
3868 channel->key_len / 8, channel->key);
3870 /* Send the channel key to the client */
3871 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
3872 keyp->data, silc_buffer_len(keyp));
3874 /* Distribute the channel key to channel */
3876 silc_server_send_channel_key(server, NULL, channel,
3877 server->server_type == SILC_ROUTER ?
3878 FALSE : !server->standalone);
3879 silc_server_backup_send(server, NULL, SILC_PACKET_CHANNEL_KEY, 0,
3880 keyp->data, silc_buffer_len(keyp),
3884 silc_buffer_free(keyp);
3886 silc_hash_table_list_reset(&htl);
3888 } else if (idata->conn_type != SILC_CONN_CLIENT) {
3889 /* Server or router sent this to us to notify that that a client has
3891 SilcServerEntry server_entry;
3892 SilcServerID server_id;
3894 /* Get entry to the client, and resolve it if we don't have it. */
3895 detached_client = silc_idlist_find_client_by_id(server->local_list,
3898 if (!detached_client) {
3899 detached_client = silc_idlist_find_client_by_id(server->global_list,
3902 if (!detached_client) {
3903 SILC_LOG_DEBUG(("Resuming client is unknown"));
3908 /* Check that the client has not been resumed already because it is
3909 protocol error to attempt to resume more than once. The client
3910 will be killed if this protocol error occurs. */
3911 if (detached_client->data.status & SILC_IDLIST_STATUS_RESUMED &&
3912 !(detached_client->mode & SILC_UMODE_DETACHED)) {
3913 /* The client is clearly attempting to resume more than once and
3914 perhaps playing around by resuming from several different places
3915 at the same time. */
3916 SILC_LOG_DEBUG(("Attempting to re-resume client, killing both"));
3917 silc_server_kill_client(server, detached_client, NULL,
3918 server->id, SILC_ID_SERVER);
3922 /* Check whether client is detached at all */
3923 if (!(detached_client->mode & SILC_UMODE_DETACHED)) {
3924 SILC_LOG_DEBUG(("Client is not detached"));
3928 /* Check nickname */
3929 if (detached_client->nickname) {
3930 nicknamec = silc_identifier_check(detached_client->nickname,
3931 strlen(detached_client->nickname),
3932 SILC_STRING_UTF8, 128, NULL);
3937 SILC_LOG_DEBUG(("Resuming detached client"));
3939 /* If the sender of this packet is server and we are router we need to
3940 broadcast this packet to other routers in the network. */
3941 if (server->server_type == SILC_ROUTER &&
3942 idata->conn_type == SILC_CONN_SERVER &&
3943 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
3944 SILC_LOG_DEBUG(("Broadcasting received Resume Client packet"));
3945 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3947 packet->flags | SILC_PACKET_FLAG_BROADCAST,
3948 buffer->data, silc_buffer_len(buffer));
3949 silc_server_backup_send(server, (SilcServerEntry)idata,
3950 packet->type, packet->flags,
3951 packet->buffer.data,
3952 silc_buffer_len(&packet->buffer),
3956 /* If the client has a locally-connected previous owner, then we
3957 will need to notify them that the resume has completed. Note
3958 that if the previous owner was a router, this case is already
3959 handled above by the broadcast, so we shouldn't attempt to
3960 send another notification in that case. Additionally, if
3961 the previous owner was the server that sent the packet, then
3962 we'll not send the notification as it will have already done
3963 the necessary work locally. */
3964 if (server->server_type == SILC_ROUTER &&
3965 idata->conn_type == SILC_CONN_SERVER &&
3966 detached_client->router &&
3967 SILC_IS_LOCAL(detached_client->router) &&
3968 detached_client->router->server_type != SILC_ROUTER)
3969 silc_server_packet_send(server, detached_client->router->connection,
3970 SILC_PACKET_RESUME_CLIENT, 0,
3971 buffer->data, silc_buffer_len(buffer));
3973 /* Client is detached, and now it is resumed. Remove the detached
3974 mode and mark that it is resumed. */
3976 if (detached_client->data.public_key) {
3977 /* Delete the detached client's public key from repository */
3978 silc_skr_del_public_key(server->repository,
3979 detached_client->data.public_key,
3981 detached_client->data.public_key = NULL;
3984 silc_idlist_del_data(detached_client);
3985 detached_client->mode &= ~SILC_UMODE_DETACHED;
3986 detached_client->data.status |= SILC_IDLIST_STATUS_RESUMED;
3987 detached_client->data.status &= ~SILC_IDLIST_STATUS_LOCAL;
3988 silc_dlist_del(server->expired_clients, detached_client);
3990 /* Check if anyone is watching this client */
3991 if (server->server_type == SILC_ROUTER)
3992 silc_server_check_watcher_list(server, detached_client, NULL,
3993 SILC_NOTIFY_TYPE_UMODE_CHANGE);
3995 silc_schedule_task_del_by_context(server->schedule, detached_client);
3997 /* Get the new owner of the resumed client */
3998 if (!silc_id_str2id(packet->src_id, packet->src_id_len,
3999 packet->src_id_type, &server_id, sizeof(server_id)))
4002 /* Get server entry */
4003 server_entry = silc_idlist_find_server_by_id(server->global_list,
4004 &server_id, TRUE, NULL);
4006 if (!server_entry) {
4007 server_entry = silc_idlist_find_server_by_id(server->local_list,
4008 &server_id, TRUE, NULL);
4014 if (server->server_type == SILC_ROUTER &&
4015 idata->conn_type == SILC_CONN_ROUTER &&
4016 server_entry->server_type == SILC_ROUTER)
4019 /* Move entry to correct list */
4020 if (local && server->server_type == SILC_ROUTER) {
4021 if (silc_idcache_find_by_context(server->global_list->clients,
4022 detached_client, &id_cache))
4023 silc_idcache_move(server->global_list->clients,
4024 server->local_list->clients, id_cache);
4026 if (silc_idcache_find_by_context(server->local_list->clients,
4027 detached_client, &id_cache))
4028 silc_idcache_move(server->local_list->clients,
4029 server->global_list->clients, id_cache);
4032 /* We don't own this client anymore, if we ever did, as we were just
4033 * told that someone else resumed it. Thus, it is most definitely no
4034 * a detached client.*/
4035 detached_client->local_detached = FALSE;
4036 /* Change the owner of the client */
4037 detached_client->router = server_entry;
4039 /* Update channel information regarding global clients on channel. */
4040 if (server->server_type != SILC_ROUTER) {
4041 silc_hash_table_list(detached_client->channels, &htl);
4042 while (silc_hash_table_get(&htl, NULL, (void *)&chl))
4043 chl->channel->global_users =
4044 silc_server_channel_has_global(chl->channel);
4045 silc_hash_table_list_reset(&htl);
4050 silc_packet_free(packet);