5 Author: Pekka Riikonen <priikone@silcnet.org>
7 Copyright (C) 1997 - 2002 Pekka Riikonen
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
21 * Server packet routines to handle received packets.
25 #include "serverincludes.h"
26 #include "server_internal.h"
28 extern char *server_version;
30 /* Received notify packet. Server can receive notify packets from router.
31 Server then relays the notify messages to clients if needed. */
33 void silc_server_notify(SilcServer server,
34 SilcSocketConnection sock,
35 SilcPacketContext *packet)
37 SilcNotifyPayload payload;
39 SilcArgumentPayload args;
40 SilcChannelID *channel_id = NULL, *channel_id2;
41 SilcClientID *client_id, *client_id2;
42 SilcServerID *server_id;
44 SilcChannelEntry channel = NULL;
45 SilcClientEntry client = NULL, client2 = NULL;
46 SilcServerEntry server_entry = NULL;
47 SilcChannelClientEntry chl;
48 SilcIDCacheEntry cache;
49 SilcHashTableList htl;
55 SILC_LOG_DEBUG(("Start"));
57 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
58 packet->src_id_type != SILC_ID_SERVER)
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 SilcSocketConnection 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, &idata);
74 /* Relay the packet */
75 silc_server_relay_packet(server, dst_sock, idata->send_key,
76 idata->hmac_send, idata->psn_send++,
80 /* Parse the Notify Payload */
81 payload = silc_notify_payload_parse(packet->buffer->data,
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->standalone && server->server_type == SILC_ROUTER &&
91 sock->type == SILC_SOCKET_TYPE_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 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
101 silc_server_packet_send_dest(server, server->router->connection,
103 packet->flags | SILC_PACKET_FLAG_BROADCAST,
104 channel_id, SILC_ID_CHANNEL,
105 packet->buffer->data, packet->buffer->len,
107 silc_server_backup_send_dest(server, (SilcServerEntry)sock->user_data,
108 packet->type, packet->flags,
109 channel_id, SILC_ID_CHANNEL,
110 packet->buffer->data, packet->buffer->len,
113 /* Packet is destined to client or server */
114 silc_server_packet_send(server, server->router->connection,
116 packet->flags | SILC_PACKET_FLAG_BROADCAST,
117 packet->buffer->data, packet->buffer->len,
119 silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
120 packet->type, packet->flags,
121 packet->buffer->data, packet->buffer->len,
126 type = silc_notify_get_type(payload);
127 args = silc_notify_get_args(payload);
132 case SILC_NOTIFY_TYPE_JOIN:
134 * Distribute the notify to local clients on the channel
136 SILC_LOG_DEBUG(("JOIN notify"));
139 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
142 channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
146 /* Get channel entry */
147 channel = silc_idlist_find_channel_by_id(server->global_list,
150 channel = silc_idlist_find_channel_by_id(server->local_list,
153 silc_free(channel_id);
157 silc_free(channel_id);
160 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
163 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
167 /* If the the client is not in local list we check global list (ie. the
168 channel will be global channel) and if it does not exist then create
169 entry for the client. */
170 client = silc_idlist_find_client_by_id(server->global_list,
171 client_id, server->server_type,
174 client = silc_idlist_find_client_by_id(server->local_list,
175 client_id, server->server_type,
178 /* If router did not find the client the it is bogus */
179 if (server->server_type != SILC_SERVER)
183 silc_idlist_add_client(server->global_list, NULL, NULL, NULL,
184 silc_id_dup(client_id, SILC_ID_CLIENT),
185 sock->user_data, NULL, 0);
187 SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
188 silc_free(client_id);
192 client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
196 /* Do not process the notify if the client is not registered */
197 if (!(client->data.status & SILC_IDLIST_STATUS_REGISTERED))
200 /* Do not add client to channel if it is there already */
201 if (silc_server_client_on_channel(client, channel, NULL)) {
202 SILC_LOG_DEBUG(("Client already on channel"));
206 /* Send to channel */
207 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
208 FALSE, packet->buffer->data,
209 packet->buffer->len, FALSE);
211 if (server->server_type != SILC_ROUTER &&
212 sock->type == SILC_SOCKET_TYPE_ROUTER)
213 /* The channel is global now */
214 channel->global_users = TRUE;
216 SILC_LOG_DEBUG(("Joining to channel %s", channel->channel_name));
218 /* JOIN the global client to the channel (local clients (if router
219 created the channel) is joined in the pending JOIN command). */
220 chl = silc_calloc(1, sizeof(*chl));
221 chl->client = client;
222 chl->channel = channel;
224 /* If this is the first one on the channel then it is the founder of
226 if (!silc_hash_table_count(channel->user_list))
227 chl->mode = (SILC_CHANNEL_UMODE_CHANOP | SILC_CHANNEL_UMODE_CHANFO);
229 silc_hash_table_add(channel->user_list, client, chl);
230 silc_hash_table_add(client->channels, channel, chl);
231 silc_free(client_id);
232 channel->user_count++;
236 case SILC_NOTIFY_TYPE_LEAVE:
238 * Distribute the notify to local clients on the channel
240 SILC_LOG_DEBUG(("LEAVE notify"));
243 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
244 packet->dst_id_type);
249 /* Get channel entry */
250 channel = silc_idlist_find_channel_by_id(server->global_list,
253 channel = silc_idlist_find_channel_by_id(server->local_list,
256 silc_free(channel_id);
262 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
264 silc_free(channel_id);
267 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
269 silc_free(channel_id);
273 /* Get client entry */
274 client = silc_idlist_find_client_by_id(server->global_list,
275 client_id, TRUE, NULL);
277 client = silc_idlist_find_client_by_id(server->local_list,
278 client_id, TRUE, NULL);
280 silc_free(client_id);
281 silc_free(channel_id);
285 silc_free(client_id);
287 /* Check if on channel */
288 if (!silc_server_client_on_channel(client, channel, NULL))
291 /* Send the leave notify to channel */
292 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
293 FALSE, packet->buffer->data,
294 packet->buffer->len, FALSE);
296 /* Remove the user from channel */
297 silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
300 case SILC_NOTIFY_TYPE_SIGNOFF:
302 * Distribute the notify to local clients on the channel
304 SILC_LOG_DEBUG(("SIGNOFF notify"));
307 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
310 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
314 /* Get client entry */
315 client = silc_idlist_find_client_by_id(server->global_list,
316 client_id, TRUE, &cache);
318 client = silc_idlist_find_client_by_id(server->local_list,
319 client_id, TRUE, &cache);
321 silc_free(client_id);
325 silc_free(client_id);
327 /* Get signoff message */
328 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
332 /* Update statistics */
333 server->stat.clients--;
334 if (server->server_type == SILC_ROUTER)
335 server->stat.cell_clients--;
336 SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
337 SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
339 /* Remove the client from all channels. */
340 silc_server_remove_from_channels(server, NULL, client, TRUE, tmp, FALSE);
342 client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
343 cache->expire = SILC_ID_CACHE_EXPIRE_DEF;
346 case SILC_NOTIFY_TYPE_TOPIC_SET:
348 * Distribute the notify to local clients on the channel
351 SILC_LOG_DEBUG(("TOPIC SET notify"));
354 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
357 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
361 /* Get client entry */
362 client = silc_idlist_find_client_by_id(server->global_list,
363 client_id, TRUE, &cache);
365 client = silc_idlist_find_client_by_id(server->local_list,
366 client_id, TRUE, &cache);
368 silc_free(client_id);
372 silc_free(client_id);
375 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
377 silc_free(channel_id);
382 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
383 packet->dst_id_type);
388 /* Get channel entry */
389 channel = silc_idlist_find_channel_by_id(server->global_list,
392 channel = silc_idlist_find_channel_by_id(server->local_list,
395 silc_free(channel_id);
400 if (channel->topic && !strcmp(channel->topic, tmp))
403 /* Get user's channel entry and check that topic set is allowed. */
404 if (!silc_server_client_on_channel(client, channel, &chl))
406 if (chl->mode == SILC_CHANNEL_UMODE_NONE &&
407 channel->mode & SILC_CHANNEL_MODE_TOPIC) {
408 SILC_LOG_DEBUG(("Topic change is not allowed"));
412 /* Change the topic */
413 silc_free(channel->topic);
414 channel->topic = strdup(tmp);
416 /* Send the same notify to the channel */
417 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
418 FALSE, packet->buffer->data,
419 packet->buffer->len, FALSE);
420 silc_free(channel_id);
423 case SILC_NOTIFY_TYPE_NICK_CHANGE:
426 * Distribute the notify to local clients on the channel
428 unsigned char *id, *id2;
430 SILC_LOG_DEBUG(("NICK CHANGE notify"));
432 /* Get old client ID */
433 id = silc_argument_get_arg_type(args, 1, &tmp_len);
436 client_id = silc_id_payload_parse_id(id, tmp_len, NULL);
440 /* Get new client ID */
441 id2 = silc_argument_get_arg_type(args, 2, &tmp_len);
444 client_id2 = silc_id_payload_parse_id(id2, tmp_len, NULL);
448 SILC_LOG_DEBUG(("Old Client ID id(%s)",
449 silc_id_render(client_id, SILC_ID_CLIENT)));
450 SILC_LOG_DEBUG(("New Client ID id(%s)",
451 silc_id_render(client_id2, SILC_ID_CLIENT)));
453 /* Replace the Client ID */
454 client = silc_idlist_replace_client_id(server->global_list, client_id,
457 client = silc_idlist_replace_client_id(server->local_list, client_id,
461 /* The nickname is not valid anymore, set it NULL. This causes that
462 the nickname will be queried if someone wants to know it. */
463 if (client->nickname)
464 silc_free(client->nickname);
465 client->nickname = NULL;
467 /* Send the NICK_CHANGE notify type to local clients on the channels
468 this client is joined to. */
469 silc_server_send_notify_on_channels(server, NULL, client,
470 SILC_NOTIFY_TYPE_NICK_CHANGE, 2,
475 silc_free(client_id);
477 silc_free(client_id2);
481 case SILC_NOTIFY_TYPE_CMODE_CHANGE:
483 * Distribute the notify to local clients on the channel
486 SILC_LOG_DEBUG(("CMODE CHANGE notify"));
489 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
492 client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
496 /* Get client entry */
497 if (id_type == SILC_ID_CLIENT) {
498 client = silc_idlist_find_client_by_id(server->global_list,
499 client_id, TRUE, &cache);
501 client = silc_idlist_find_client_by_id(server->local_list,
502 client_id, TRUE, &cache);
504 silc_free(client_id);
508 silc_free(client_id);
512 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
513 packet->dst_id_type);
518 /* Get channel entry */
519 channel = silc_idlist_find_channel_by_id(server->global_list,
522 channel = silc_idlist_find_channel_by_id(server->local_list,
525 silc_free(channel_id);
529 silc_free(channel_id);
532 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
535 SILC_GET32_MSB(mode, tmp);
537 /* Check if mode changed */
538 if (channel->mode == mode)
541 /* Get user's channel entry and check that mode change is allowed */
543 if (!silc_server_client_on_channel(client, channel, &chl))
545 if (!silc_server_check_cmode_rights(server, channel, chl, mode)) {
546 SILC_LOG_DEBUG(("CMODE change is not allowed"));
551 /* Send the same notify to the channel */
552 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
553 FALSE, packet->buffer->data,
554 packet->buffer->len, FALSE);
556 /* If the channel had private keys set and the mode was removed then
557 we must re-generate and re-distribute a new channel key */
558 if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY &&
559 !(mode & SILC_CHANNEL_MODE_PRIVKEY)) {
560 /* Re-generate channel key */
561 if (!silc_server_create_channel_key(server, channel, 0))
564 /* Send the channel key. This sends it to our local clients and if
565 we are normal server to our router as well. */
566 silc_server_send_channel_key(server, NULL, channel,
567 server->server_type == SILC_ROUTER ?
568 FALSE : !server->standalone);
572 channel->mode = mode;
575 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
577 unsigned char hash[32];
580 silc_hmac_free(channel->hmac);
581 if (!silc_hmac_alloc(tmp, NULL, &channel->hmac))
584 /* Set the HMAC key out of current channel key. The client must do
586 silc_hash_make(silc_hmac_get_hash(channel->hmac), channel->key,
587 channel->key_len / 8,
589 silc_hmac_set_key(channel->hmac, hash,
590 silc_hash_len(silc_hmac_get_hash(channel->hmac)));
591 memset(hash, 0, sizeof(hash));
594 /* Get the passphrase */
595 tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
597 silc_free(channel->passphrase);
598 channel->passphrase = strdup(tmp);
603 case SILC_NOTIFY_TYPE_CUMODE_CHANGE:
606 * Distribute the notify to local clients on the channel
608 SilcChannelClientEntry chl2 = NULL;
609 bool notify_sent = FALSE;
611 SILC_LOG_DEBUG(("CUMODE CHANGE notify"));
614 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
617 client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
621 /* Get client entry */
622 if (id_type == SILC_ID_CLIENT) {
623 client = silc_idlist_find_client_by_id(server->global_list,
624 client_id, TRUE, &cache);
626 client = silc_idlist_find_client_by_id(server->local_list,
627 client_id, TRUE, &cache);
629 silc_free(client_id);
633 silc_free(client_id);
637 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
638 packet->dst_id_type);
643 /* Get channel entry */
644 channel = silc_idlist_find_channel_by_id(server->global_list,
647 channel = silc_idlist_find_channel_by_id(server->local_list,
650 silc_free(channel_id);
656 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
658 silc_free(channel_id);
662 SILC_GET32_MSB(mode, tmp);
664 /* Get target client */
665 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
668 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
672 /* Get client entry */
673 client2 = silc_idlist_find_client_by_id(server->global_list,
674 client_id, TRUE, NULL);
676 client2 = silc_idlist_find_client_by_id(server->local_list,
677 client_id, TRUE, NULL);
679 silc_free(client_id);
683 silc_free(client_id);
686 /* Check that sender is on channel */
687 if (!silc_server_client_on_channel(client, channel, &chl))
690 if (client != client2) {
691 /* Sender must be operator */
692 if (chl->mode == SILC_CHANNEL_UMODE_NONE) {
693 SILC_LOG_DEBUG(("CUMODE change is not allowed"));
697 /* Check that target is on channel */
698 if (!silc_server_client_on_channel(client2, channel, &chl))
701 /* If target is founder mode change is not allowed. */
702 if (chl->mode & SILC_CHANNEL_UMODE_CHANFO) {
703 SILC_LOG_DEBUG(("CUMODE change is not allowed"));
709 /* Get entry to the channel user list */
710 silc_hash_table_list(channel->user_list, &htl);
711 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
712 /* If the mode is channel founder and we already find a client
713 to have that mode on the channel we will enforce the sender
714 to change the channel founder mode away. There can be only one
715 channel founder on the channel. */
716 if (server->server_type == SILC_ROUTER &&
717 mode & SILC_CHANNEL_UMODE_CHANFO &&
718 chl->mode & SILC_CHANNEL_UMODE_CHANFO) {
720 unsigned char cumode[4];
722 if (chl->client == client && chl->mode == mode) {
727 mode &= ~SILC_CHANNEL_UMODE_CHANFO;
728 silc_server_send_notify_cumode(server, sock, FALSE, channel, mode,
729 client2->id, SILC_ID_CLIENT,
732 idp = silc_id_payload_encode(client2->id, SILC_ID_CLIENT);
733 SILC_PUT32_MSB(mode, cumode);
734 silc_server_send_notify_to_channel(server, sock, channel, FALSE,
735 SILC_NOTIFY_TYPE_CUMODE_CHANGE,
736 3, idp->data, idp->len,
738 idp->data, idp->len);
739 silc_buffer_free(idp);
742 /* Force the mode change if we alredy set the mode */
745 silc_free(channel_id);
746 silc_hash_table_list_reset(&htl);
751 if (chl->client == client2) {
752 if (chl->mode == mode) {
757 SILC_LOG_DEBUG(("Changing the channel user mode"));
759 /* Change the mode */
761 if (!(mode & SILC_CHANNEL_UMODE_CHANFO))
767 silc_hash_table_list_reset(&htl);
769 /* Send the same notify to the channel */
771 silc_server_packet_send_to_channel(server, sock, channel,
773 FALSE, packet->buffer->data,
774 packet->buffer->len, FALSE);
776 silc_free(channel_id);
780 case SILC_NOTIFY_TYPE_INVITE:
782 if (packet->dst_id_type == SILC_ID_CLIENT)
785 SILC_LOG_DEBUG(("INVITE notify"));
788 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
791 channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
795 /* Get channel entry */
796 channel = silc_idlist_find_channel_by_id(server->global_list,
799 channel = silc_idlist_find_channel_by_id(server->local_list,
802 silc_free(channel_id);
806 silc_free(channel_id);
809 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
812 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
816 /* Get client entry */
817 client = silc_idlist_find_client_by_id(server->global_list,
818 client_id, TRUE, &cache);
820 client = silc_idlist_find_client_by_id(server->local_list,
821 client_id, TRUE, &cache);
823 silc_free(client_id);
827 silc_free(client_id);
829 /* Get user's channel entry and check that inviting is allowed. */
830 if (!silc_server_client_on_channel(client, channel, &chl))
832 if (chl->mode == SILC_CHANNEL_UMODE_NONE &&
833 channel->mode & SILC_CHANNEL_MODE_INVITE) {
834 SILC_LOG_DEBUG(("Inviting is not allowed"));
838 /* Get the added invite */
839 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
841 if (!channel->invite_list)
842 channel->invite_list = silc_calloc(tmp_len + 2,
843 sizeof(*channel->invite_list));
845 channel->invite_list = silc_realloc(channel->invite_list,
846 sizeof(*channel->invite_list) *
848 strlen(channel->invite_list) +
850 if (tmp[tmp_len - 1] == ',')
851 tmp[tmp_len - 1] = '\0';
853 strncat(channel->invite_list, tmp, tmp_len);
854 strncat(channel->invite_list, ",", 1);
857 /* Get the deleted invite */
858 tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
859 if (tmp && channel->invite_list) {
860 char *start, *end, *n;
862 if (!strncmp(channel->invite_list, tmp,
863 strlen(channel->invite_list) - 1)) {
864 silc_free(channel->invite_list);
865 channel->invite_list = NULL;
867 start = strstr(channel->invite_list, tmp);
868 if (start && strlen(start) >= tmp_len) {
869 end = start + tmp_len;
870 n = silc_calloc(strlen(channel->invite_list) - tmp_len, sizeof(*n));
871 strncat(n, channel->invite_list, start - channel->invite_list);
872 strncat(n, end + 1, ((channel->invite_list +
873 strlen(channel->invite_list)) - end) - 1);
874 silc_free(channel->invite_list);
875 channel->invite_list = n;
882 case SILC_NOTIFY_TYPE_CHANNEL_CHANGE:
884 * Distribute to the local clients on the channel and change the
888 SILC_LOG_DEBUG(("CHANNEL CHANGE"));
890 if (sock->type != SILC_SOCKET_TYPE_ROUTER)
893 /* Get the old Channel ID */
894 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
897 channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
901 /* Get the channel entry */
902 channel = silc_idlist_find_channel_by_id(server->local_list,
905 channel = silc_idlist_find_channel_by_id(server->global_list,
908 silc_free(channel_id);
913 /* Send the notify to the channel */
914 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
915 FALSE, packet->buffer->data,
916 packet->buffer->len, FALSE);
918 /* Get the new Channel ID */
919 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
922 channel_id2 = silc_id_payload_parse_id(tmp, tmp_len, NULL);
926 SILC_LOG_DEBUG(("Old Channel ID id(%s)",
927 silc_id_render(channel_id, SILC_ID_CHANNEL)));
928 SILC_LOG_DEBUG(("New Channel ID id(%s)",
929 silc_id_render(channel_id2, SILC_ID_CHANNEL)));
931 /* Replace the Channel ID */
932 if (!silc_idlist_replace_channel_id(server->local_list, channel_id,
934 if (!silc_idlist_replace_channel_id(server->global_list, channel_id,
936 silc_free(channel_id2);
941 SilcBuffer users = NULL, users_modes = NULL;
943 /* Re-announce this channel which ID was changed. */
944 silc_server_send_new_channel(server, sock, FALSE, channel->channel_name,
946 silc_id_get_len(channel->id,
950 /* Re-announce our clients on the channel as the ID has changed now */
951 silc_server_announce_get_channel_users(server, channel, &users,
954 silc_buffer_push(users, users->data - users->head);
955 silc_server_packet_send(server, sock,
956 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
957 users->data, users->len, FALSE);
958 silc_buffer_free(users);
961 silc_buffer_push(users_modes, users_modes->data - users_modes->head);
962 silc_server_packet_send_dest(server, sock,
963 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
964 channel->id, SILC_ID_CHANNEL,
966 users_modes->len, FALSE);
967 silc_buffer_free(users_modes);
970 /* Re-announce channel's topic */
971 if (channel->topic) {
972 silc_server_send_notify_topic_set(server, sock,
973 server->server_type == SILC_ROUTER ?
974 TRUE : FALSE, channel,
975 channel->id, SILC_ID_CHANNEL,
980 silc_free(channel_id);
984 case SILC_NOTIFY_TYPE_SERVER_SIGNOFF:
986 * Remove the server entry and all clients that this server owns.
989 SILC_LOG_DEBUG(("SERVER SIGNOFF notify"));
992 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
995 server_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
999 /* Get server entry */
1000 server_entry = silc_idlist_find_server_by_id(server->global_list,
1001 server_id, TRUE, NULL);
1003 if (!server_entry) {
1004 server_entry = silc_idlist_find_server_by_id(server->local_list,
1005 server_id, TRUE, NULL);
1007 if (!server_entry) {
1008 /* If we are normal server then we might not have the server. Check
1009 whether router was kind enough to send the list of all clients
1010 that actually was to be removed. Remove them if the list is
1012 if (server->server_type != SILC_ROUTER &&
1013 silc_argument_get_arg_num(args) > 1) {
1016 for (i = 1; i < silc_argument_get_arg_num(args); i++) {
1018 tmp = silc_argument_get_arg_type(args, i + 1, &tmp_len);
1021 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1025 /* Get client entry */
1026 client = silc_idlist_find_client_by_id(server->global_list,
1027 client_id, TRUE, &cache);
1030 client = silc_idlist_find_client_by_id(server->local_list,
1031 client_id, TRUE, &cache);
1034 silc_free(client_id);
1038 silc_free(client_id);
1040 /* Update statistics */
1041 server->stat.clients--;
1042 if (server->server_type == SILC_ROUTER)
1043 server->stat.cell_clients--;
1044 SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
1045 SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
1047 /* Remove the client from all channels. */
1048 silc_server_remove_from_channels(server, NULL, client,
1051 /* Remove the client */
1052 silc_idlist_del_client(local ? server->local_list :
1053 server->global_list, client);
1057 silc_free(server_id);
1061 silc_free(server_id);
1063 /* Free all client entries that this server owns as they will
1064 become invalid now as well. */
1065 silc_server_remove_clients_by_server(server, server_entry, TRUE);
1067 /* Remove the server entry */
1068 silc_idlist_del_server(local ? server->local_list :
1069 server->global_list, server_entry);
1071 /* XXX update statistics */
1075 case SILC_NOTIFY_TYPE_KICKED:
1077 * Distribute the notify to local clients on the channel
1080 SILC_LOG_DEBUG(("KICKED notify"));
1083 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
1084 packet->dst_id_type);
1089 /* Get channel entry */
1090 channel = silc_idlist_find_channel_by_id(server->global_list,
1093 channel = silc_idlist_find_channel_by_id(server->local_list,
1096 silc_free(channel_id);
1100 silc_free(channel_id);
1103 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1106 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1110 /* If the the client is not in local list we check global list */
1111 client = silc_idlist_find_client_by_id(server->global_list,
1112 client_id, TRUE, NULL);
1114 client = silc_idlist_find_client_by_id(server->local_list,
1115 client_id, TRUE, NULL);
1117 silc_free(client_id);
1121 silc_free(client_id);
1123 /* If target is founder they cannot be kicked */
1124 if (!silc_server_client_on_channel(client, channel, &chl))
1126 if (chl->mode & SILC_CHANNEL_UMODE_CHANFO)
1129 /* Get kicker. In protocol version 1.0 this is not mandatory argument
1130 so we check it only if it is provided. */
1131 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1133 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1137 /* If the the client is not in local list we check global list */
1138 client2 = silc_idlist_find_client_by_id(server->global_list,
1139 client_id, TRUE, NULL);
1141 client2 = silc_idlist_find_client_by_id(server->local_list,
1142 client_id, TRUE, NULL);
1144 silc_free(client_id);
1148 silc_free(client_id);
1150 /* Kicker must be operator on channel */
1151 if (!silc_server_client_on_channel(client2, channel, &chl))
1153 if (chl->mode == SILC_CHANNEL_UMODE_NONE) {
1154 SILC_LOG_DEBUG(("Kicking is not allowed"));
1159 /* Send to channel */
1160 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
1161 FALSE, packet->buffer->data,
1162 packet->buffer->len, FALSE);
1164 /* Remove the client from channel */
1165 silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
1169 case SILC_NOTIFY_TYPE_KILLED:
1172 * Distribute the notify to local clients on channels
1177 SILC_LOG_DEBUG(("KILLED notify"));
1180 id = silc_argument_get_arg_type(args, 1, &id_len);
1183 client_id = silc_id_payload_parse_id(id, id_len, NULL);
1187 /* If the the client is not in local list we check global list */
1188 client = silc_idlist_find_client_by_id(server->global_list,
1189 client_id, TRUE, NULL);
1191 client = silc_idlist_find_client_by_id(server->local_list,
1192 client_id, TRUE, NULL);
1194 silc_free(client_id);
1198 silc_free(client_id);
1200 /* If the client is one of ours, then close the connection to the
1201 client now. This removes the client from all channels as well. */
1202 if (packet->dst_id_type == SILC_ID_CLIENT && client->connection) {
1203 sock = client->connection;
1204 silc_server_free_client_data(server, NULL, client, FALSE, NULL);
1205 silc_server_close_connection(server, sock);
1210 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1214 /* Send the notify to local clients on the channels except to the
1215 client who is killed. */
1216 silc_server_send_notify_on_channels(server, client, client,
1217 SILC_NOTIFY_TYPE_KILLED,
1222 /* Remove the client from all channels */
1223 silc_server_remove_from_channels(server, NULL, client, FALSE, NULL,
1229 case SILC_NOTIFY_TYPE_UMODE_CHANGE:
1231 * Save the mode of the client.
1234 SILC_LOG_DEBUG(("UMODE_CHANGE notify"));
1237 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1240 client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1244 /* Get client entry */
1245 client = silc_idlist_find_client_by_id(server->global_list,
1246 client_id, TRUE, NULL);
1248 client = silc_idlist_find_client_by_id(server->local_list,
1249 client_id, TRUE, NULL);
1251 silc_free(client_id);
1255 silc_free(client_id);
1258 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1261 SILC_GET32_MSB(mode, tmp);
1263 /* Check that mode changing is allowed. */
1264 if (!silc_server_check_umode_rights(server, client, mode)) {
1265 SILC_LOG_DEBUG(("UMODE change is not allowed"));
1269 /* Change the mode */
1270 client->mode = mode;
1274 case SILC_NOTIFY_TYPE_BAN:
1279 SILC_LOG_DEBUG(("BAN notify"));
1281 /* Get Channel ID */
1282 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1285 channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1289 /* Get channel entry */
1290 channel = silc_idlist_find_channel_by_id(server->global_list,
1293 channel = silc_idlist_find_channel_by_id(server->local_list,
1296 silc_free(channel_id);
1300 silc_free(channel_id);
1302 /* Get the new ban and add it to the ban list */
1303 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1305 if (!channel->ban_list)
1306 channel->ban_list = silc_calloc(tmp_len + 2,
1307 sizeof(*channel->ban_list));
1309 channel->ban_list = silc_realloc(channel->ban_list,
1310 sizeof(*channel->ban_list) *
1312 strlen(channel->ban_list) + 2));
1313 strncat(channel->ban_list, tmp, tmp_len);
1314 strncat(channel->ban_list, ",", 1);
1317 /* Get the ban to be removed and remove it from the list */
1318 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1319 if (tmp && channel->ban_list) {
1320 char *start, *end, *n;
1322 if (!strncmp(channel->ban_list, tmp, strlen(channel->ban_list) - 1)) {
1323 silc_free(channel->ban_list);
1324 channel->ban_list = NULL;
1326 start = strstr(channel->ban_list, tmp);
1327 if (start && strlen(start) >= tmp_len) {
1328 end = start + tmp_len;
1329 n = silc_calloc(strlen(channel->ban_list) - tmp_len, sizeof(*n));
1330 strncat(n, channel->ban_list, start - channel->ban_list);
1331 strncat(n, end + 1, ((channel->ban_list +
1332 strlen(channel->ban_list)) - end) - 1);
1333 silc_free(channel->ban_list);
1334 channel->ban_list = n;
1340 /* Ignore rest of the notify types for now */
1341 case SILC_NOTIFY_TYPE_NONE:
1342 case SILC_NOTIFY_TYPE_MOTD:
1349 silc_notify_payload_free(payload);
1352 void silc_server_notify_list(SilcServer server,
1353 SilcSocketConnection sock,
1354 SilcPacketContext *packet)
1356 SilcPacketContext *new;
1360 SILC_LOG_DEBUG(("Processing Notify List"));
1362 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
1363 packet->src_id_type != SILC_ID_SERVER)
1366 /* Make copy of the original packet context, except for the actual
1367 data buffer, which we will here now fetch from the original buffer. */
1368 new = silc_packet_context_alloc();
1369 new->type = SILC_PACKET_NOTIFY;
1370 new->flags = packet->flags;
1371 new->src_id = packet->src_id;
1372 new->src_id_len = packet->src_id_len;
1373 new->src_id_type = packet->src_id_type;
1374 new->dst_id = packet->dst_id;
1375 new->dst_id_len = packet->dst_id_len;
1376 new->dst_id_type = packet->dst_id_type;
1378 buffer = silc_buffer_alloc(1024);
1379 new->buffer = buffer;
1381 while (packet->buffer->len) {
1382 SILC_GET16_MSB(len, packet->buffer->data + 2);
1383 if (len > packet->buffer->len)
1386 if (len > buffer->truelen) {
1387 silc_buffer_free(buffer);
1388 buffer = silc_buffer_alloc(1024 + len);
1391 silc_buffer_pull_tail(buffer, len);
1392 silc_buffer_put(buffer, packet->buffer->data, len);
1394 /* Process the Notify */
1395 silc_server_notify(server, sock, new);
1397 silc_buffer_push_tail(buffer, len);
1398 silc_buffer_pull(packet->buffer, len);
1401 silc_buffer_free(buffer);
1405 /* Received private message. This resolves the destination of the message
1406 and sends the packet. This is used by both server and router. If the
1407 destination is our locally connected client this sends the packet to
1408 the client. This may also send the message for further routing if
1409 the destination is not in our server (or router). */
1411 void silc_server_private_message(SilcServer server,
1412 SilcSocketConnection sock,
1413 SilcPacketContext *packet)
1415 SilcSocketConnection dst_sock;
1416 SilcIDListData idata;
1418 SILC_LOG_DEBUG(("Start"));
1420 if (packet->src_id_type != SILC_ID_CLIENT ||
1421 packet->dst_id_type != SILC_ID_CLIENT || !packet->dst_id)
1424 /* Get the route to the client */
1425 dst_sock = silc_server_get_client_route(server, packet->dst_id,
1426 packet->dst_id_len, NULL, &idata);
1428 /* Send IDENTIFY command reply with error status to indicate that
1429 such destination ID does not exist or is invalid */
1430 SilcBuffer idp = silc_id_payload_encode_data(packet->dst_id,
1432 packet->dst_id_type);
1436 if (packet->src_id_type == SILC_ID_CLIENT) {
1437 SilcClientID *client_id = silc_id_str2id(packet->src_id,
1439 packet->src_id_type);
1440 silc_server_send_dest_command_reply(server, sock,
1441 client_id, SILC_ID_CLIENT,
1442 SILC_COMMAND_IDENTIFY,
1443 SILC_STATUS_ERR_NO_SUCH_CLIENT_ID,
1444 0, 1, 2, idp->data, idp->len);
1445 silc_free(client_id);
1447 silc_server_send_command_reply(server, sock, SILC_COMMAND_IDENTIFY,
1448 SILC_STATUS_ERR_NO_SUCH_CLIENT_ID,
1449 0, 1, 2, idp->data, idp->len);
1452 silc_buffer_free(idp);
1456 /* Send the private message */
1457 silc_server_send_private_message(server, dst_sock, idata->send_key,
1458 idata->hmac_send, idata->psn_send++,
1462 /* Received private message key packet.. This packet is never for us. It is to
1463 the client in the packet's destination ID. Sending of this sort of packet
1464 equals sending private message, ie. it is sent point to point from
1465 one client to another. */
1467 void silc_server_private_message_key(SilcServer server,
1468 SilcSocketConnection sock,
1469 SilcPacketContext *packet)
1471 SilcSocketConnection dst_sock;
1472 SilcIDListData idata;
1474 SILC_LOG_DEBUG(("Start"));
1476 if (packet->src_id_type != SILC_ID_CLIENT ||
1477 packet->dst_id_type != SILC_ID_CLIENT)
1480 if (!packet->dst_id)
1483 /* Get the route to the client */
1484 dst_sock = silc_server_get_client_route(server, packet->dst_id,
1485 packet->dst_id_len, NULL, &idata);
1489 /* Relay the packet */
1490 silc_server_relay_packet(server, dst_sock, idata->send_key,
1491 idata->hmac_send, idata->psn_send++, packet, FALSE);
1494 /* Processes incoming command reply packet. The command reply packet may
1495 be destined to one of our clients or it may directly for us. We will
1496 call the command reply routine after processing the packet. */
1498 void silc_server_command_reply(SilcServer server,
1499 SilcSocketConnection sock,
1500 SilcPacketContext *packet)
1502 SilcBuffer buffer = packet->buffer;
1503 SilcClientEntry client = NULL;
1504 SilcSocketConnection dst_sock;
1505 SilcIDListData idata;
1506 SilcClientID *id = NULL;
1508 SILC_LOG_DEBUG(("Start"));
1510 /* Source must be server or router */
1511 if (packet->src_id_type != SILC_ID_SERVER &&
1512 sock->type != SILC_SOCKET_TYPE_ROUTER)
1515 if (packet->dst_id_type == SILC_ID_CHANNEL)
1518 if (packet->dst_id_type == SILC_ID_CLIENT) {
1519 /* Destination must be one of ours */
1520 id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CLIENT);
1523 client = silc_idlist_find_client_by_id(server->local_list, id, TRUE, NULL);
1525 SILC_LOG_ERROR(("Cannot process command reply to unknown client"));
1531 if (packet->dst_id_type == SILC_ID_SERVER) {
1532 /* For now this must be for us */
1533 if (memcmp(packet->dst_id, server->id_string, server->id_string_len)) {
1534 SILC_LOG_ERROR(("Cannot process command reply to unknown server"));
1539 /* Execute command reply locally for the command */
1540 silc_server_command_reply_process(server, sock, buffer);
1542 if (packet->dst_id_type == SILC_ID_CLIENT && client && id) {
1543 /* Relay the packet to the client */
1544 const SilcBufferStruct p;
1546 dst_sock = (SilcSocketConnection)client->connection;
1547 idata = (SilcIDListData)client;
1549 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1550 + packet->dst_id_len + packet->padlen);
1551 if (!silc_packet_send_prepare(dst_sock, 0, 0, buffer->len,
1552 idata->hmac_send, (const SilcBuffer)&p)) {
1553 SILC_LOG_ERROR(("Cannot send packet"));
1556 silc_buffer_put((SilcBuffer)&p, buffer->data, buffer->len);
1558 /* Encrypt packet */
1559 silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
1560 (SilcBuffer)&p, buffer->len);
1562 /* Send the packet */
1563 silc_server_packet_send_real(server, dst_sock, TRUE);
1569 /* Process received channel message. The message can be originated from
1570 client or server. */
1572 void silc_server_channel_message(SilcServer server,
1573 SilcSocketConnection sock,
1574 SilcPacketContext *packet)
1576 SilcChannelEntry channel = NULL;
1577 SilcChannelID *id = NULL;
1578 void *sender_id = NULL;
1579 SilcClientEntry sender_entry = NULL;
1582 SILC_LOG_DEBUG(("Processing channel message"));
1585 if (packet->dst_id_type != SILC_ID_CHANNEL) {
1586 SILC_LOG_DEBUG(("Received bad message for channel, dropped"));
1590 /* Find channel entry */
1591 id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CHANNEL);
1594 channel = silc_idlist_find_channel_by_id(server->local_list, id, NULL);
1596 channel = silc_idlist_find_channel_by_id(server->global_list, id, NULL);
1598 SILC_LOG_DEBUG(("Could not find channel"));
1603 /* See that this client is on the channel. If the original sender is
1604 not client (as it can be server as well) we don't do the check. */
1605 sender_id = silc_id_str2id(packet->src_id, packet->src_id_len,
1606 packet->src_id_type);
1609 if (packet->src_id_type == SILC_ID_CLIENT) {
1610 sender_entry = silc_idlist_find_client_by_id(server->local_list,
1611 sender_id, TRUE, NULL);
1612 if (!sender_entry) {
1614 sender_entry = silc_idlist_find_client_by_id(server->global_list,
1615 sender_id, TRUE, NULL);
1617 if (!sender_entry || !silc_server_client_on_channel(sender_entry,
1619 SILC_LOG_DEBUG(("Client not on channel"));
1623 /* If the packet is coming from router, but the client entry is local
1624 entry to us then some router is rerouting this to us and it is not
1625 allowed. When the client is local to us it means that we've routed
1626 this packet to network, and now someone is routing it back to us. */
1627 if (server->server_type == SILC_ROUTER &&
1628 sock->type == SILC_SOCKET_TYPE_ROUTER && local) {
1629 SILC_LOG_DEBUG(("Channel message rerouted to the sender, drop it"));
1634 /* Distribute the packet to our local clients. This will send the
1635 packet for further routing as well, if needed. */
1636 silc_server_packet_relay_to_channel(server, sock, channel, sender_id,
1637 packet->src_id_type, sender_entry,
1638 packet->buffer->data,
1639 packet->buffer->len, FALSE);
1642 silc_free(sender_id);
1646 /* Received channel key packet. We distribute the key to all of our locally
1647 connected clients on the channel. */
1649 void silc_server_channel_key(SilcServer server,
1650 SilcSocketConnection sock,
1651 SilcPacketContext *packet)
1653 SilcBuffer buffer = packet->buffer;
1654 SilcChannelEntry channel;
1656 if (packet->src_id_type != SILC_ID_SERVER ||
1657 (server->server_type == SILC_ROUTER &&
1658 sock->type == SILC_SOCKET_TYPE_ROUTER))
1661 /* Save the channel key */
1662 channel = silc_server_save_channel_key(server, buffer, NULL);
1666 /* Distribute the key to everybody who is on the channel. If we are router
1667 we will also send it to locally connected servers. */
1668 silc_server_send_channel_key(server, sock, channel, FALSE);
1670 if (server->server_type != SILC_BACKUP_ROUTER) {
1671 /* Distribute to local cell backup routers. */
1672 silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
1673 SILC_PACKET_CHANNEL_KEY, 0,
1674 buffer->data, buffer->len, FALSE, TRUE);
1678 /* Received New Client packet and processes it. Creates Client ID for the
1679 client. Client becomes registered after calling this functions. */
1681 SilcClientEntry silc_server_new_client(SilcServer server,
1682 SilcSocketConnection sock,
1683 SilcPacketContext *packet)
1685 SilcBuffer buffer = packet->buffer;
1686 SilcClientEntry client;
1687 SilcClientID *client_id;
1689 SilcIDListData idata;
1690 char *username = NULL, *realname = NULL, *id_string;
1691 SilcUInt16 username_len;
1694 char *hostname, *nickname;
1697 SILC_LOG_DEBUG(("Creating new client"));
1699 if (sock->type != SILC_SOCKET_TYPE_CLIENT)
1702 /* Take client entry */
1703 client = (SilcClientEntry)sock->user_data;
1704 idata = (SilcIDListData)client;
1706 /* Remove the old cache entry. */
1707 if (!silc_idcache_del_by_context(server->local_list->clients, client)) {
1708 SILC_LOG_INFO(("Unauthenticated client attempted to register to network"));
1709 silc_server_disconnect_remote(server, sock, "Server closed connection: "
1710 "You have not been authenticated");
1714 /* Parse incoming packet */
1715 ret = silc_buffer_unformat(buffer,
1716 SILC_STR_UI16_NSTRING_ALLOC(&username,
1718 SILC_STR_UI16_STRING_ALLOC(&realname),
1721 silc_free(username);
1722 silc_free(realname);
1723 SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
1724 "connection", sock->hostname, sock->ip));
1725 silc_server_disconnect_remote(server, sock, "Server closed connection: "
1726 "Incomplete client information");
1731 silc_free(username);
1732 silc_free(realname);
1733 SILC_LOG_ERROR(("Client %s (%s) did not send its username, closing "
1734 "connection", sock->hostname, sock->ip));
1735 silc_server_disconnect_remote(server, sock, "Server closed connection: "
1736 "Incomplete client information");
1740 if (username_len > 128)
1741 username[128] = '\0';
1743 /* Check for bad characters for nickname, and modify the nickname if
1744 it includes those. */
1745 if (silc_server_name_bad_chars(username, username_len)) {
1746 nickname = silc_server_name_modify_bad(username, username_len);
1748 nickname = strdup(username);
1751 /* Make sanity checks for the hostname of the client. If the hostname
1752 is provided in the `username' check that it is the same than the
1753 resolved hostname, or if not resolved the hostname that appears in
1754 the client's public key. If the hostname is not present then put
1755 it from the resolved name or from the public key. */
1756 if (strchr(username, '@')) {
1757 SilcPublicKeyIdentifier pident;
1758 int tlen = strcspn(username, "@");
1759 char *phostname = NULL;
1761 hostname = silc_memdup(username + tlen + 1, strlen(username) - tlen - 1);
1763 if (strcmp(sock->hostname, sock->ip) &&
1764 strcmp(sock->hostname, hostname)) {
1765 silc_free(username);
1766 silc_free(hostname);
1767 silc_free(realname);
1768 SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
1769 "connection", sock->hostname, sock->ip));
1770 silc_server_disconnect_remote(server, sock,
1771 "Server closed connection: "
1772 "Incomplete client information");
1776 pident = silc_pkcs_decode_identifier(client->data.public_key->identifier);
1778 phostname = strdup(pident->host);
1779 silc_pkcs_free_identifier(pident);
1782 if (!strcmp(sock->hostname, sock->ip) &&
1783 phostname && strcmp(phostname, hostname)) {
1784 silc_free(username);
1785 silc_free(hostname);
1786 silc_free(phostname);
1787 silc_free(realname);
1788 SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
1789 "connection", sock->hostname, sock->ip));
1790 silc_server_disconnect_remote(server, sock,
1791 "Server closed connection: "
1792 "Incomplete client information");
1796 silc_free(phostname);
1798 /* The hostname is not present, add it. */
1800 /* XXX For now we cannot take the host name from the public key since
1801 they are not trusted or we cannot verify them as trusted. Just take
1802 what the resolved name or address is. */
1804 if (strcmp(sock->hostname, sock->ip)) {
1806 newusername = silc_calloc(strlen(username) +
1807 strlen(sock->hostname) + 2,
1808 sizeof(*newusername));
1809 strncat(newusername, username, strlen(username));
1810 strncat(newusername, "@", 1);
1811 strncat(newusername, sock->hostname, strlen(sock->hostname));
1812 silc_free(username);
1813 username = newusername;
1816 SilcPublicKeyIdentifier pident =
1817 silc_pkcs_decode_identifier(client->data.public_key->identifier);
1820 newusername = silc_calloc(strlen(username) +
1821 strlen(pident->host) + 2,
1822 sizeof(*newusername));
1823 strncat(newusername, username, strlen(username));
1824 strncat(newusername, "@", 1);
1825 strncat(newusername, pident->host, strlen(pident->host));
1826 silc_free(username);
1827 username = newusername;
1828 silc_pkcs_free_identifier(pident);
1834 /* Create Client ID */
1835 while (!silc_id_create_client_id(server, server->id, server->rng,
1836 server->md5hash, nickname, &client_id)) {
1838 snprintf(&nickname[strlen(nickname) - 1], 1, "%d", nickfail);
1841 /* Update client entry */
1842 idata->status |= SILC_IDLIST_STATUS_REGISTERED;
1843 client->nickname = nickname;
1844 client->username = username;
1845 client->userinfo = realname ? realname : strdup(" ");
1846 client->id = client_id;
1847 id_len = silc_id_get_len(client_id, SILC_ID_CLIENT);
1849 /* Add the client again to the ID cache */
1850 silc_idcache_add(server->local_list->clients, client->nickname,
1851 client_id, client, 0, NULL);
1853 /* Notify our router about new client on the SILC network */
1854 if (!server->standalone)
1855 silc_server_send_new_id(server, (SilcSocketConnection)
1856 server->router->connection,
1857 server->server_type == SILC_ROUTER ? TRUE : FALSE,
1858 client->id, SILC_ID_CLIENT, id_len);
1860 /* Send the new client ID to the client. */
1861 id_string = silc_id_id2str(client->id, SILC_ID_CLIENT);
1862 reply = silc_buffer_alloc(2 + 2 + id_len);
1863 silc_buffer_pull_tail(reply, SILC_BUFFER_END(reply));
1864 silc_buffer_format(reply,
1865 SILC_STR_UI_SHORT(SILC_ID_CLIENT),
1866 SILC_STR_UI_SHORT(id_len),
1867 SILC_STR_UI_XNSTRING(id_string, id_len),
1869 silc_server_packet_send(server, sock, SILC_PACKET_NEW_ID, 0,
1870 reply->data, reply->len, FALSE);
1871 silc_free(id_string);
1872 silc_buffer_free(reply);
1874 /* Send some nice info to the client */
1875 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1876 ("Welcome to the SILC Network %s",
1878 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1879 ("Your host is %s, running version %s",
1880 server->server_name, server_version));
1881 if (server->server_type == SILC_ROUTER) {
1882 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1883 ("There are %d clients on %d servers in SILC "
1884 "Network", server->stat.clients,
1885 server->stat.servers + 1));
1886 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1887 ("There are %d clients on %d server in our cell",
1888 server->stat.cell_clients,
1889 server->stat.cell_servers + 1));
1890 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1891 ("I have %d clients, %d channels, %d servers and "
1893 server->stat.my_clients,
1894 server->stat.my_channels,
1895 server->stat.my_servers,
1896 server->stat.my_routers));
1897 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1898 ("There are %d server operators and %d router "
1900 server->stat.server_ops,
1901 server->stat.router_ops));
1902 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1903 ("I have %d operators online",
1904 server->stat.my_router_ops +
1905 server->stat.my_server_ops));
1907 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1908 ("I have %d clients and %d channels formed",
1909 server->stat.my_clients,
1910 server->stat.my_channels));
1911 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1912 ("%d operators online",
1913 server->stat.my_server_ops));
1915 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1916 ("Your connection is secured with %s cipher, "
1917 "key length %d bits",
1918 idata->send_key->cipher->name,
1919 idata->send_key->cipher->key_len));
1920 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1921 ("Your current nickname is %s",
1925 silc_server_send_motd(server, sock);
1930 /* Create new server. This processes received New Server packet and
1931 saves the received Server ID. The server is our locally connected
1932 server thus we save all the information and save it to local list.
1933 This funtion can be used by both normal server and router server.
1934 If normal server uses this it means that its router has connected
1935 to the server. If router uses this it means that one of the cell's
1936 servers is connected to the router. */
1938 SilcServerEntry silc_server_new_server(SilcServer server,
1939 SilcSocketConnection sock,
1940 SilcPacketContext *packet)
1942 SilcBuffer buffer = packet->buffer;
1943 SilcServerEntry new_server, server_entry;
1944 SilcServerID *server_id;
1945 SilcIDListData idata;
1946 unsigned char *server_name, *id_string;
1947 SilcUInt16 id_len, name_len;
1951 SILC_LOG_DEBUG(("Creating new server"));
1953 if (sock->type != SILC_SOCKET_TYPE_SERVER &&
1954 sock->type != SILC_SOCKET_TYPE_ROUTER)
1957 /* Take server entry */
1958 new_server = (SilcServerEntry)sock->user_data;
1959 idata = (SilcIDListData)new_server;
1961 /* Remove the old cache entry */
1962 if (!silc_idcache_del_by_context(server->local_list->servers, new_server)) {
1963 if (!silc_idcache_del_by_context(server->global_list->servers,
1965 SILC_LOG_INFO(("Unauthenticated %s attempted to register to "
1966 "network", (sock->type == SILC_SOCKET_TYPE_SERVER ?
1967 "server" : "router")));
1968 silc_server_disconnect_remote(server, sock, "Server closed connection: "
1969 "You have not been authenticated");
1975 /* Parse the incoming packet */
1976 ret = silc_buffer_unformat(buffer,
1977 SILC_STR_UI16_NSTRING_ALLOC(&id_string, &id_len),
1978 SILC_STR_UI16_NSTRING_ALLOC(&server_name,
1983 silc_free(id_string);
1985 silc_free(server_name);
1989 if (id_len > buffer->len) {
1990 silc_free(id_string);
1991 silc_free(server_name);
1996 server_name[255] = '\0';
1999 server_id = silc_id_str2id(id_string, id_len, SILC_ID_SERVER);
2001 silc_free(id_string);
2002 silc_free(server_name);
2005 silc_free(id_string);
2007 /* Check for valid server ID */
2008 if (!silc_id_is_valid_server_id(server, server_id, sock)) {
2009 SILC_LOG_INFO(("Invalid server ID sent by %s (%s)",
2010 sock->ip, sock->hostname));
2011 silc_server_disconnect_remote(server, sock, "Server closed connection: "
2012 "Your Server ID is not valid");
2013 silc_free(server_name);
2017 /* Check that we do not have this ID already */
2018 server_entry = silc_idlist_find_server_by_id(server->local_list,
2019 server_id, TRUE, NULL);
2021 silc_idcache_del_by_context(server->local_list->servers, server_entry);
2023 server_entry = silc_idlist_find_server_by_id(server->global_list,
2024 server_id, TRUE, NULL);
2026 silc_idcache_del_by_context(server->global_list->servers, server_entry);
2029 /* Update server entry */
2030 idata->status |= SILC_IDLIST_STATUS_REGISTERED;
2031 new_server->server_name = server_name;
2032 new_server->id = server_id;
2034 SILC_LOG_DEBUG(("New server id(%s)",
2035 silc_id_render(server_id, SILC_ID_SERVER)));
2037 /* Add again the entry to the ID cache. */
2038 silc_idcache_add(local ? server->local_list->servers :
2039 server->global_list->servers, server_name, server_id,
2040 new_server, 0, NULL);
2042 /* Distribute the information about new server in the SILC network
2043 to our router. If we are normal server we won't send anything
2044 since this connection must be our router connection. */
2045 if (server->server_type == SILC_ROUTER && !server->standalone &&
2046 server->router->connection != sock)
2047 silc_server_send_new_id(server, server->router->connection,
2048 TRUE, new_server->id, SILC_ID_SERVER,
2049 silc_id_get_len(server_id, SILC_ID_SERVER));
2051 if (server->server_type == SILC_ROUTER)
2052 server->stat.cell_servers++;
2054 /* Check whether this router connection has been replaced by an
2055 backup router. If it has been then we'll disable the server and will
2056 ignore everything it will send until the backup router resuming
2057 protocol has been completed. */
2058 if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
2059 silc_server_backup_replaced_get(server, server_id, NULL)) {
2060 /* Send packet to the server indicating that it cannot use this
2061 connection as it has been replaced by backup router. */
2062 SilcBuffer packet = silc_buffer_alloc(2);
2063 silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
2064 silc_buffer_format(packet,
2065 SILC_STR_UI_CHAR(SILC_SERVER_BACKUP_REPLACED),
2066 SILC_STR_UI_CHAR(0),
2068 silc_server_packet_send(server, sock,
2069 SILC_PACKET_RESUME_ROUTER, 0,
2070 packet->data, packet->len, TRUE);
2071 silc_buffer_free(packet);
2073 /* Mark the router disabled. The data sent earlier will go but nothing
2074 after this does not go to this connection. */
2075 idata->status |= SILC_IDLIST_STATUS_DISABLED;
2077 /* If it is router announce our stuff to it. */
2078 if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
2079 server->server_type == SILC_ROUTER) {
2080 silc_server_announce_servers(server, FALSE, 0, sock);
2081 silc_server_announce_clients(server, 0, sock);
2082 silc_server_announce_channels(server, 0, sock);
2089 /* Processes incoming New ID packet. New ID Payload is used to distribute
2090 information about newly registered clients and servers. */
2092 static void silc_server_new_id_real(SilcServer server,
2093 SilcSocketConnection sock,
2094 SilcPacketContext *packet,
2097 SilcBuffer buffer = packet->buffer;
2099 SilcServerEntry router, server_entry;
2100 SilcSocketConnection router_sock;
2105 SILC_LOG_DEBUG(("Processing new ID"));
2107 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2108 server->server_type == SILC_SERVER ||
2109 packet->src_id_type != SILC_ID_SERVER)
2112 idp = silc_id_payload_parse(buffer->data, buffer->len);
2116 id_type = silc_id_payload_get_type(idp);
2118 /* Normal server cannot have other normal server connections */
2119 server_entry = (SilcServerEntry)sock->user_data;
2120 if (id_type == SILC_ID_SERVER && sock->type == SILC_SOCKET_TYPE_SERVER &&
2121 server_entry->server_type == SILC_SERVER)
2124 id = silc_id_payload_get_id(idp);
2128 /* If the packet is coming from server then use the sender as the
2129 origin of the the packet. If it came from router then check the real
2130 sender of the packet and use that as the origin. */
2131 if (sock->type == SILC_SOCKET_TYPE_SERVER) {
2132 id_list = server->local_list;
2134 router = sock->user_data;
2136 /* If the sender is backup router and ID is server (and we are not
2137 backup router) then switch the entry to global list. */
2138 if (server_entry->server_type == SILC_BACKUP_ROUTER &&
2139 id_type == SILC_ID_SERVER &&
2140 server->id_entry->server_type != SILC_BACKUP_ROUTER) {
2141 id_list = server->global_list;
2142 router_sock = server->router ? server->router->connection : sock;
2145 void *sender_id = silc_id_str2id(packet->src_id, packet->src_id_len,
2146 packet->src_id_type);
2147 router = silc_idlist_find_server_by_id(server->global_list,
2148 sender_id, TRUE, NULL);
2150 router = silc_idlist_find_server_by_id(server->local_list,
2151 sender_id, TRUE, NULL);
2152 silc_free(sender_id);
2154 id_list = server->global_list;
2161 case SILC_ID_CLIENT:
2163 SilcClientEntry entry;
2165 /* Check that we do not have this client already */
2166 entry = silc_idlist_find_client_by_id(server->global_list,
2167 id, server->server_type,
2170 entry = silc_idlist_find_client_by_id(server->local_list,
2171 id, server->server_type,
2174 SILC_LOG_DEBUG(("Ignoring client that we already have"));
2178 SILC_LOG_DEBUG(("New client id(%s) from [%s] %s",
2179 silc_id_render(id, SILC_ID_CLIENT),
2180 sock->type == SILC_SOCKET_TYPE_SERVER ?
2181 "Server" : "Router", sock->hostname));
2183 /* As a router we keep information of all global information in our
2184 global list. Cell wide information however is kept in the local
2186 entry = silc_idlist_add_client(id_list, NULL, NULL, NULL,
2187 id, router, NULL, 0);
2189 SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
2191 /* Inform the sender that the ID is not usable */
2192 silc_server_send_notify_signoff(server, sock, FALSE, id, NULL);
2195 entry->nickname = NULL;
2196 entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
2198 if (sock->type == SILC_SOCKET_TYPE_SERVER)
2199 server->stat.cell_clients++;
2200 server->stat.clients++;
2204 case SILC_ID_SERVER:
2206 SilcServerEntry entry;
2208 /* If the ID is mine, ignore it. */
2209 if (SILC_ID_SERVER_COMPARE(id, server->id)) {
2210 SILC_LOG_DEBUG(("Ignoring my own ID as new ID"));
2214 /* If the ID is the sender's ID, ignore it (we have it already) */
2215 if (SILC_ID_SERVER_COMPARE(id, router->id)) {
2216 SILC_LOG_DEBUG(("Ignoring sender's own ID"));
2220 /* Check that we do not have this server already */
2221 entry = silc_idlist_find_server_by_id(server->global_list,
2222 id, server->server_type,
2225 entry = silc_idlist_find_server_by_id(server->local_list,
2226 id, server->server_type,
2229 SILC_LOG_DEBUG(("Ignoring server that we already have"));
2233 SILC_LOG_DEBUG(("New server id(%s) from [%s] %s",
2234 silc_id_render(id, SILC_ID_SERVER),
2235 sock->type == SILC_SOCKET_TYPE_SERVER ?
2236 "Server" : "Router", sock->hostname));
2238 /* As a router we keep information of all global information in our
2239 global list. Cell wide information however is kept in the local
2241 entry = silc_idlist_add_server(id_list, NULL, 0, id, router,
2244 SILC_LOG_ERROR(("Could not add new server to the ID Cache"));
2247 entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
2249 if (sock->type == SILC_SOCKET_TYPE_SERVER)
2250 server->stat.cell_servers++;
2251 server->stat.servers++;
2255 case SILC_ID_CHANNEL:
2256 SILC_LOG_ERROR(("Channel cannot be registered with NEW_ID packet"));
2265 /* If the sender of this packet is server and we are router we need to
2266 broadcast this packet to other routers in the network. */
2267 if (broadcast && !server->standalone && server->server_type == SILC_ROUTER &&
2268 sock->type == SILC_SOCKET_TYPE_SERVER &&
2269 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2270 SILC_LOG_DEBUG(("Broadcasting received New ID packet"));
2271 silc_server_packet_send(server, server->router->connection,
2273 packet->flags | SILC_PACKET_FLAG_BROADCAST,
2274 buffer->data, buffer->len, FALSE);
2275 silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
2276 packet->type, packet->flags,
2277 packet->buffer->data, packet->buffer->len,
2282 silc_id_payload_free(idp);
2286 /* Processes incoming New ID packet. New ID Payload is used to distribute
2287 information about newly registered clients and servers. */
2289 void silc_server_new_id(SilcServer server, SilcSocketConnection sock,
2290 SilcPacketContext *packet)
2292 silc_server_new_id_real(server, sock, packet, TRUE);
2295 /* Receoved New Id List packet, list of New ID payloads inside one
2296 packet. Process the New ID payloads one by one. */
2298 void silc_server_new_id_list(SilcServer server, SilcSocketConnection sock,
2299 SilcPacketContext *packet)
2301 SilcPacketContext *new_id;
2305 SILC_LOG_DEBUG(("Processing New ID List"));
2307 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2308 packet->src_id_type != SILC_ID_SERVER)
2311 /* If the sender of this packet is server and we are router we need to
2312 broadcast this packet to other routers in the network. Broadcast
2313 this list packet instead of multiple New ID packets. */
2314 if (!server->standalone && server->server_type == SILC_ROUTER &&
2315 sock->type == SILC_SOCKET_TYPE_SERVER &&
2316 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2317 SILC_LOG_DEBUG(("Broadcasting received New ID List packet"));
2318 silc_server_packet_send(server, server->router->connection,
2320 packet->flags | SILC_PACKET_FLAG_BROADCAST,
2321 packet->buffer->data, packet->buffer->len, FALSE);
2322 silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
2323 packet->type, packet->flags,
2324 packet->buffer->data, packet->buffer->len,
2328 /* Make copy of the original packet context, except for the actual
2329 data buffer, which we will here now fetch from the original buffer. */
2330 new_id = silc_packet_context_alloc();
2331 new_id->type = SILC_PACKET_NEW_ID;
2332 new_id->flags = packet->flags;
2333 new_id->src_id = packet->src_id;
2334 new_id->src_id_len = packet->src_id_len;
2335 new_id->src_id_type = packet->src_id_type;
2336 new_id->dst_id = packet->dst_id;
2337 new_id->dst_id_len = packet->dst_id_len;
2338 new_id->dst_id_type = packet->dst_id_type;
2340 idp = silc_buffer_alloc(256);
2341 new_id->buffer = idp;
2343 while (packet->buffer->len) {
2344 SILC_GET16_MSB(id_len, packet->buffer->data + 2);
2345 if ((id_len > packet->buffer->len) ||
2346 (id_len > idp->truelen))
2349 silc_buffer_pull_tail(idp, 4 + id_len);
2350 silc_buffer_put(idp, packet->buffer->data, 4 + id_len);
2352 /* Process the New ID */
2353 silc_server_new_id_real(server, sock, new_id, FALSE);
2355 silc_buffer_push_tail(idp, 4 + id_len);
2356 silc_buffer_pull(packet->buffer, 4 + id_len);
2359 silc_buffer_free(idp);
2363 /* Received New Channel packet. Information about new channels in the
2364 network are distributed using this packet. Save the information about
2365 the new channel. This usually comes from router but also normal server
2366 can send this to notify channels it has when it connects to us. */
2368 void silc_server_new_channel(SilcServer server,
2369 SilcSocketConnection sock,
2370 SilcPacketContext *packet)
2372 SilcChannelPayload payload;
2373 SilcChannelID *channel_id;
2375 SilcUInt32 name_len;
2379 SilcServerEntry server_entry;
2380 SilcChannelEntry channel;
2382 SILC_LOG_DEBUG(("Processing New Channel"));
2384 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2385 packet->src_id_type != SILC_ID_SERVER ||
2386 server->server_type == SILC_SERVER)
2389 /* Parse the channel payload */
2390 payload = silc_channel_payload_parse(packet->buffer->data,
2391 packet->buffer->len);
2395 /* Get the channel ID */
2396 channel_id = silc_channel_get_id_parse(payload);
2398 silc_channel_payload_free(payload);
2402 channel_name = silc_channel_get_name(payload, &name_len);
2404 channel_name[255] = '\0';
2406 id = silc_channel_get_id(payload, &id_len);
2408 server_entry = (SilcServerEntry)sock->user_data;
2410 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
2411 /* Add the channel to global list as it is coming from router. It
2412 cannot be our own channel as it is coming from router. */
2414 /* Check that we don't already have this channel */
2415 channel = silc_idlist_find_channel_by_name(server->local_list,
2416 channel_name, NULL);
2418 channel = silc_idlist_find_channel_by_name(server->global_list,
2419 channel_name, NULL);
2421 SILC_LOG_DEBUG(("New channel id(%s) from [Router] %s",
2422 silc_id_render(channel_id, SILC_ID_CHANNEL),
2425 silc_idlist_add_channel(server->global_list, strdup(channel_name),
2426 0, channel_id, sock->user_data, NULL, NULL, 0);
2427 server->stat.channels++;
2430 /* The channel is coming from our server, thus it is in our cell
2431 we will add it to our local list. */
2434 SILC_LOG_DEBUG(("Channel id(%s) from [Server] %s",
2435 silc_id_render(channel_id, SILC_ID_CHANNEL),
2438 /* Check that we don't already have this channel */
2439 channel = silc_idlist_find_channel_by_name(server->local_list,
2440 channel_name, NULL);
2442 channel = silc_idlist_find_channel_by_name(server->global_list,
2443 channel_name, NULL);
2445 /* If the channel does not exist, then create it. This creates a new
2446 key to the channel as well that we will send to the server. */
2448 /* The protocol says that the Channel ID's IP address must be based
2449 on the router's IP address. Check whether the ID is based in our
2450 IP and if it is not then create a new ID and enforce the server
2451 to switch the ID. */
2452 if (server_entry->server_type != SILC_BACKUP_ROUTER &&
2453 !SILC_ID_COMPARE(channel_id, server->id, server->id->ip.data_len)) {
2455 SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
2457 if (silc_id_create_channel_id(server, server->id, server->rng, &tmp)) {
2458 silc_server_send_notify_channel_change(server, sock, FALSE,
2460 silc_free(channel_id);
2465 /* Create the channel with the provided Channel ID */
2466 channel = silc_server_create_new_channel_with_id(server, NULL, NULL,
2470 silc_channel_payload_free(payload);
2471 silc_free(channel_id);
2475 /* Get the mode and set it to the channel */
2476 channel->mode = silc_channel_get_mode(payload);
2478 /* Send the new channel key to the server */
2479 id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
2480 id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
2481 chk = silc_channel_key_payload_encode(id_len, id,
2482 strlen(channel->channel_key->
2484 channel->channel_key->cipher->name,
2485 channel->key_len / 8,
2487 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
2488 chk->data, chk->len, FALSE);
2489 silc_buffer_free(chk);
2492 /* The channel exist by that name, check whether the ID's match.
2493 If they don't then we'll force the server to use the ID we have.
2494 We also create a new key for the channel. */
2495 SilcBuffer users = NULL, users_modes = NULL;
2497 if (!SILC_ID_CHANNEL_COMPARE(channel_id, channel->id)) {
2498 /* They don't match, send CHANNEL_CHANGE notify to the server to
2499 force the ID change. */
2500 SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
2501 silc_server_send_notify_channel_change(server, sock, FALSE,
2502 channel_id, channel->id);
2505 /* If the mode is different from what we have then enforce the
2507 mode = silc_channel_get_mode(payload);
2508 if (channel->mode != mode) {
2509 SILC_LOG_DEBUG(("Forcing the server to change channel mode"));
2510 silc_server_send_notify_cmode(server, sock, FALSE, channel,
2511 channel->mode, server->id,
2513 channel->cipher, channel->hmac_name,
2514 channel->passphrase);
2517 /* Create new key for the channel and send it to the server and
2518 everybody else possibly on the channel. */
2520 if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
2521 if (!silc_server_create_channel_key(server, channel, 0))
2524 /* Send to the channel */
2525 silc_server_send_channel_key(server, sock, channel, FALSE);
2526 id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
2527 id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
2529 /* Send to the server */
2530 chk = silc_channel_key_payload_encode(id_len, id,
2531 strlen(channel->channel_key->
2533 channel->channel_key->
2535 channel->key_len / 8,
2537 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
2538 chk->data, chk->len, FALSE);
2539 silc_buffer_free(chk);
2543 silc_free(channel_id);
2545 /* Since the channel is coming from server and we also know about it
2546 then send the JOIN notify to the server so that it see's our
2547 users on the channel "joining" the channel. */
2548 silc_server_announce_get_channel_users(server, channel, &users,
2551 silc_buffer_push(users, users->data - users->head);
2552 silc_server_packet_send(server, sock,
2553 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
2554 users->data, users->len, FALSE);
2555 silc_buffer_free(users);
2558 silc_buffer_push(users_modes, users_modes->data - users_modes->head);
2559 silc_server_packet_send_dest(server, sock,
2560 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
2561 channel->id, SILC_ID_CHANNEL,
2563 users_modes->len, FALSE);
2564 silc_buffer_free(users_modes);
2569 silc_channel_payload_free(payload);
2572 /* Received New Channel List packet, list of New Channel List payloads inside
2573 one packet. Process the New Channel payloads one by one. */
2575 void silc_server_new_channel_list(SilcServer server,
2576 SilcSocketConnection sock,
2577 SilcPacketContext *packet)
2579 SilcPacketContext *new;
2581 SilcUInt16 len1, len2;
2583 SILC_LOG_DEBUG(("Processing New Channel List"));
2585 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2586 packet->src_id_type != SILC_ID_SERVER ||
2587 server->server_type == SILC_SERVER)
2590 /* If the sender of this packet is server and we are router we need to
2591 broadcast this packet to other routers in the network. Broadcast
2592 this list packet instead of multiple New Channel packets. */
2593 if (!server->standalone && server->server_type == SILC_ROUTER &&
2594 sock->type == SILC_SOCKET_TYPE_SERVER &&
2595 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2596 SILC_LOG_DEBUG(("Broadcasting received New Channel List packet"));
2597 silc_server_packet_send(server, server->router->connection,
2599 packet->flags | SILC_PACKET_FLAG_BROADCAST,
2600 packet->buffer->data, packet->buffer->len, FALSE);
2601 silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
2602 packet->type, packet->flags,
2603 packet->buffer->data, packet->buffer->len,
2607 /* Make copy of the original packet context, except for the actual
2608 data buffer, which we will here now fetch from the original buffer. */
2609 new = silc_packet_context_alloc();
2610 new->type = SILC_PACKET_NEW_CHANNEL;
2611 new->flags = packet->flags;
2612 new->src_id = packet->src_id;
2613 new->src_id_len = packet->src_id_len;
2614 new->src_id_type = packet->src_id_type;
2615 new->dst_id = packet->dst_id;
2616 new->dst_id_len = packet->dst_id_len;
2617 new->dst_id_type = packet->dst_id_type;
2619 buffer = silc_buffer_alloc(512);
2620 new->buffer = buffer;
2622 while (packet->buffer->len) {
2623 SILC_GET16_MSB(len1, packet->buffer->data);
2624 if ((len1 > packet->buffer->len) ||
2625 (len1 > buffer->truelen))
2628 SILC_GET16_MSB(len2, packet->buffer->data + 2 + len1);
2629 if ((len2 > packet->buffer->len) ||
2630 (len2 > buffer->truelen))
2633 silc_buffer_pull_tail(buffer, 8 + len1 + len2);
2634 silc_buffer_put(buffer, packet->buffer->data, 8 + len1 + len2);
2636 /* Process the New Channel */
2637 silc_server_new_channel(server, sock, new);
2639 silc_buffer_push_tail(buffer, 8 + len1 + len2);
2640 silc_buffer_pull(packet->buffer, 8 + len1 + len2);
2643 silc_buffer_free(buffer);
2647 /* Received key agreement packet. This packet is never for us. It is to
2648 the client in the packet's destination ID. Sending of this sort of packet
2649 equals sending private message, ie. it is sent point to point from
2650 one client to another. */
2652 void silc_server_key_agreement(SilcServer server,
2653 SilcSocketConnection sock,
2654 SilcPacketContext *packet)
2656 SilcSocketConnection dst_sock;
2657 SilcIDListData idata;
2659 SILC_LOG_DEBUG(("Start"));
2661 if (packet->src_id_type != SILC_ID_CLIENT ||
2662 packet->dst_id_type != SILC_ID_CLIENT)
2665 if (!packet->dst_id)
2668 /* Get the route to the client */
2669 dst_sock = silc_server_get_client_route(server, packet->dst_id,
2670 packet->dst_id_len, NULL, &idata);
2674 /* Relay the packet */
2675 silc_server_relay_packet(server, dst_sock, idata->send_key,
2676 idata->hmac_send, idata->psn_send++,
2680 /* Received connection auth request packet that is used during connection
2681 phase to resolve the mandatory authentication method. This packet can
2682 actually be received at anytime but usually it is used only during
2683 the connection authentication phase. Now, protocol says that this packet
2684 can come from client or server, however, we support only this coming
2685 from client and expect that server always knows what authentication
2688 void silc_server_connection_auth_request(SilcServer server,
2689 SilcSocketConnection sock,
2690 SilcPacketContext *packet)
2692 SilcServerConfigClient *client = NULL;
2693 SilcUInt16 conn_type;
2695 SilcAuthMethod auth_meth = SILC_AUTH_NONE;
2697 SILC_LOG_DEBUG(("Start"));
2699 if (packet->src_id_type && packet->src_id_type != SILC_ID_CLIENT)
2702 /* Parse the payload */
2703 ret = silc_buffer_unformat(packet->buffer,
2704 SILC_STR_UI_SHORT(&conn_type),
2705 SILC_STR_UI_SHORT(NULL),
2710 if (conn_type != SILC_SOCKET_TYPE_CLIENT)
2713 /* Get the authentication method for the client */
2714 auth_meth = SILC_AUTH_NONE;
2715 client = silc_server_config_find_client(server, sock->ip);
2717 client = silc_server_config_find_client(server, sock->hostname);
2719 if (client->passphrase) {
2720 if (client->publickeys && !server->config->prefer_passphrase_auth)
2721 auth_meth = SILC_AUTH_PUBLIC_KEY;
2723 auth_meth = SILC_AUTH_PASSWORD;
2724 } else if (client->publickeys)
2725 auth_meth = SILC_AUTH_PUBLIC_KEY;
2728 /* Send it back to the client */
2729 silc_server_send_connection_auth_request(server, sock, conn_type, auth_meth);
2732 /* Received REKEY packet. The sender of the packet wants to regenerate
2733 its session keys. This starts the REKEY protocol. */
2735 void silc_server_rekey(SilcServer server,
2736 SilcSocketConnection sock,
2737 SilcPacketContext *packet)
2739 SilcProtocol protocol;
2740 SilcServerRekeyInternalContext *proto_ctx;
2741 SilcIDListData idata = (SilcIDListData)sock->user_data;
2743 SILC_LOG_DEBUG(("Start"));
2745 /* Allocate internal protocol context. This is sent as context
2747 proto_ctx = silc_calloc(1, sizeof(*proto_ctx));
2748 proto_ctx->server = (void *)server;
2749 proto_ctx->sock = sock;
2750 proto_ctx->responder = TRUE;
2751 proto_ctx->pfs = idata->rekey->pfs;
2753 /* Perform rekey protocol. Will call the final callback after the
2754 protocol is over. */
2755 silc_protocol_alloc(SILC_PROTOCOL_SERVER_REKEY,
2756 &protocol, proto_ctx, silc_server_rekey_final);
2757 sock->protocol = protocol;
2759 if (proto_ctx->pfs == FALSE)
2760 /* Run the protocol */
2761 silc_protocol_execute(protocol, server->schedule, 0, 0);
2764 /* Received file transger packet. This packet is never for us. It is to
2765 the client in the packet's destination ID. Sending of this sort of packet
2766 equals sending private message, ie. it is sent point to point from
2767 one client to another. */
2769 void silc_server_ftp(SilcServer server,
2770 SilcSocketConnection sock,
2771 SilcPacketContext *packet)
2773 SilcSocketConnection dst_sock;
2774 SilcIDListData idata;
2776 SILC_LOG_DEBUG(("Start"));
2778 if (packet->src_id_type != SILC_ID_CLIENT ||
2779 packet->dst_id_type != SILC_ID_CLIENT)
2782 if (!packet->dst_id)
2785 /* Get the route to the client */
2786 dst_sock = silc_server_get_client_route(server, packet->dst_id,
2787 packet->dst_id_len, NULL, &idata);
2791 /* Relay the packet */
2792 silc_server_relay_packet(server, dst_sock, idata->send_key,
2793 idata->hmac_send, idata->psn_send++,