5 Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
7 Copyright (C) 1997 - 2001 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, *channel_id2;
41 SilcClientID *client_id, *client_id2;
42 SilcServerID *server_id;
43 SilcChannelEntry channel;
44 SilcClientEntry client;
45 SilcServerEntry server_entry;
46 SilcChannelClientEntry chl;
47 SilcIDCacheEntry cache;
48 SilcHashTableList htl;
53 SILC_LOG_DEBUG(("Start"));
55 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
56 packet->src_id_type != SILC_ID_SERVER)
62 /* If the packet is destined directly to a client then relay the packet
63 before processing it. */
64 if (packet->dst_id_type == SILC_ID_CLIENT) {
66 SilcSocketConnection dst_sock;
68 /* Get the route to the client */
69 dst_sock = silc_server_get_client_route(server, packet->dst_id,
70 packet->dst_id_len, NULL, &idata);
72 /* Relay the packet */
73 silc_server_relay_packet(server, dst_sock, idata->send_key,
74 idata->hmac_receive, packet, TRUE);
77 /* If we are router and this packet is not already broadcast packet
78 we will broadcast it. The sending socket really cannot be router or
79 the router is buggy. If this packet is coming from router then it must
80 have the broadcast flag set already and we won't do anything. */
81 if (!server->standalone && server->server_type == SILC_ROUTER &&
82 sock->type == SILC_SOCKET_TYPE_SERVER &&
83 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
84 SILC_LOG_DEBUG(("Broadcasting received Notify packet"));
85 silc_server_packet_send(server, server->router->connection, packet->type,
86 packet->flags | SILC_PACKET_FLAG_BROADCAST,
87 packet->buffer->data, packet->buffer->len, FALSE);
90 payload = silc_notify_payload_parse(packet->buffer);
94 type = silc_notify_get_type(payload);
95 args = silc_notify_get_args(payload);
100 case SILC_NOTIFY_TYPE_JOIN:
102 * Distribute the notify to local clients on the channel
104 SILC_LOG_DEBUG(("JOIN notify"));
107 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
110 channel_id = silc_id_payload_parse_id(tmp, tmp_len);
114 /* Get channel entry */
115 channel = silc_idlist_find_channel_by_id(server->global_list,
118 channel = silc_idlist_find_channel_by_id(server->local_list,
121 silc_free(channel_id);
125 silc_free(channel_id);
128 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
131 client_id = silc_id_payload_parse_id(tmp, tmp_len);
135 /* Send to channel */
136 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
137 FALSE, packet->buffer->data,
138 packet->buffer->len, FALSE);
140 /* If the the client is not in local list we check global list (ie. the
141 channel will be global channel) and if it does not exist then create
142 entry for the client. */
143 client = silc_idlist_find_client_by_id(server->global_list,
146 client = silc_idlist_find_client_by_id(server->local_list,
149 /* If router did not find the client the it is bogus */
150 if (server->server_type == SILC_ROUTER)
154 silc_idlist_add_client(server->global_list, NULL, NULL, NULL,
155 silc_id_dup(client_id, SILC_ID_CLIENT),
156 sock->user_data, NULL);
158 silc_free(client_id);
162 client->data.registered = TRUE;
166 /* Do not add client to channel if it is there already */
167 if (silc_server_client_on_channel(client, channel))
170 if (server->server_type == SILC_SERVER &&
171 sock->type == SILC_SOCKET_TYPE_ROUTER)
172 /* The channel is global now */
173 channel->global_users = TRUE;
175 /* JOIN the global client to the channel (local clients (if router
176 created the channel) is joined in the pending JOIN command). */
177 chl = silc_calloc(1, sizeof(*chl));
178 chl->client = client;
179 chl->channel = channel;
180 silc_hash_table_add(channel->user_list, client, chl);
181 silc_hash_table_add(client->channels, channel, chl);
182 silc_free(client_id);
186 case SILC_NOTIFY_TYPE_LEAVE:
188 * Distribute the notify to local clients on the channel
190 SILC_LOG_DEBUG(("LEAVE notify"));
192 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
193 packet->dst_id_type);
197 /* Get channel entry */
198 channel = silc_idlist_find_channel_by_id(server->global_list,
201 channel = silc_idlist_find_channel_by_id(server->local_list,
204 silc_free(channel_id);
210 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
212 silc_free(channel_id);
215 client_id = silc_id_payload_parse_id(tmp, tmp_len);
217 silc_free(channel_id);
221 /* Send to channel */
222 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
223 FALSE, packet->buffer->data,
224 packet->buffer->len, FALSE);
226 /* Get client entry */
227 client = silc_idlist_find_client_by_id(server->global_list,
230 client = silc_idlist_find_client_by_id(server->local_list,
233 silc_free(client_id);
234 silc_free(channel_id);
238 silc_free(client_id);
240 /* Remove the user from channel */
241 silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
244 case SILC_NOTIFY_TYPE_SIGNOFF:
246 * Distribute the notify to local clients on the channel
248 SILC_LOG_DEBUG(("SIGNOFF notify"));
251 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
254 client_id = silc_id_payload_parse_id(tmp, tmp_len);
258 /* Get client entry */
259 client = silc_idlist_find_client_by_id(server->global_list,
262 client = silc_idlist_find_client_by_id(server->local_list,
265 silc_free(client_id);
269 silc_free(client_id);
271 /* Get signoff message */
272 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
276 /* Remove the client from all channels. */
277 silc_server_remove_from_channels(server, NULL, client, TRUE, tmp, FALSE);
279 client->data.registered = FALSE;
280 cache->expire = SILC_ID_CACHE_EXPIRE_DEF;
281 server->stat.clients--;
282 if (server->server_type == SILC_ROUTER)
283 server->stat.cell_clients--;
286 case SILC_NOTIFY_TYPE_TOPIC_SET:
288 * Distribute the notify to local clients on the channel
291 SILC_LOG_DEBUG(("TOPIC SET notify"));
293 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
294 packet->dst_id_type);
298 /* Get channel entry */
299 channel = silc_idlist_find_channel_by_id(server->global_list,
302 channel = silc_idlist_find_channel_by_id(server->local_list,
305 silc_free(channel_id);
311 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
313 silc_free(channel_id);
318 silc_free(channel->topic);
319 channel->topic = silc_calloc(tmp_len + 1, sizeof(*channel->topic));
320 memcpy(channel->topic, tmp, tmp_len);
322 /* Send the same notify to the channel */
323 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
324 FALSE, packet->buffer->data,
325 packet->buffer->len, FALSE);
326 silc_free(channel_id);
329 case SILC_NOTIFY_TYPE_NICK_CHANGE:
332 * Distribute the notify to local clients on the channel
334 unsigned char *id, *id2;
336 SILC_LOG_DEBUG(("NICK CHANGE notify"));
338 /* Get old client ID */
339 id = silc_argument_get_arg_type(args, 1, &tmp_len);
342 client_id = silc_id_payload_parse_id(id, tmp_len);
346 /* Get new client ID */
347 id2 = silc_argument_get_arg_type(args, 2, &tmp_len);
350 client_id2 = silc_id_payload_parse_id(id2, tmp_len);
354 SILC_LOG_DEBUG(("Old Client ID id(%s)",
355 silc_id_render(client_id, SILC_ID_CLIENT)));
356 SILC_LOG_DEBUG(("New Client ID id(%s)",
357 silc_id_render(client_id2, SILC_ID_CLIENT)));
359 /* Replace the Client ID */
360 client = silc_idlist_replace_client_id(server->global_list, client_id,
363 client = silc_idlist_replace_client_id(server->local_list, client_id,
367 /* The nickname is not valid anymore, set it NULL. This causes that
368 the nickname will be queried if someone wants to know it. */
369 if (client->nickname)
370 silc_free(client->nickname);
371 client->nickname = NULL;
373 /* Send the NICK_CHANGE notify type to local clients on the channels
374 this client is joined to. */
375 silc_server_send_notify_on_channels(server, NULL, client,
376 SILC_NOTIFY_TYPE_NICK_CHANGE, 2,
381 silc_free(client_id);
383 silc_free(client_id2);
387 case SILC_NOTIFY_TYPE_CMODE_CHANGE:
389 * Distribute the notify to local clients on the channel
392 SILC_LOG_DEBUG(("CMODE CHANGE notify"));
394 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
395 packet->dst_id_type);
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_free(channel_id);
411 /* Send the same notify to the channel */
412 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
413 FALSE, packet->buffer->data,
414 packet->buffer->len, FALSE);
417 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
419 silc_free(channel_id);
423 SILC_GET32_MSB(mode, tmp);
425 /* If the channel had private keys set and the mode was removed then
426 we must re-generate and re-distribute a new channel key */
427 if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY &&
428 !(mode & SILC_CHANNEL_MODE_PRIVKEY)) {
429 /* Re-generate channel key */
430 silc_server_create_channel_key(server, channel, 0);
432 /* Send the channel key. This sends it to our local clients and if
433 we are normal server to our router as well. */
434 silc_server_send_channel_key(server, NULL, channel,
435 server->server_type == SILC_ROUTER ?
436 FALSE : !server->standalone);
440 channel->mode = mode;
441 silc_free(channel_id);
444 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
446 unsigned char hash[32];
449 silc_hmac_free(channel->hmac);
450 if (!silc_hmac_alloc(tmp, NULL, &channel->hmac))
453 /* Set the HMAC key out of current channel key. The client must do
455 silc_hash_make(channel->hmac->hash, channel->key, channel->key_len / 8,
457 silc_hmac_set_key(channel->hmac, hash,
458 silc_hash_len(channel->hmac->hash));
459 memset(hash, 0, sizeof(hash));
464 case SILC_NOTIFY_TYPE_CUMODE_CHANGE:
466 * Distribute the notify to local clients on the channel
469 SILC_LOG_DEBUG(("CUMODE CHANGE notify"));
471 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
472 packet->dst_id_type);
476 /* Get channel entry */
477 channel = silc_idlist_find_channel_by_id(server->global_list,
480 channel = silc_idlist_find_channel_by_id(server->local_list,
483 silc_free(channel_id);
489 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
491 silc_free(channel_id);
495 SILC_GET32_MSB(mode, tmp);
497 /* Get target client */
498 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
501 client_id = silc_id_payload_parse_id(tmp, tmp_len);
505 /* Get client entry */
506 client = silc_idlist_find_client_by_id(server->global_list,
509 client = silc_idlist_find_client_by_id(server->local_list,
512 silc_free(client_id);
516 silc_free(client_id);
518 /* Get entry to the channel user list */
519 silc_hash_table_list(channel->user_list, &htl);
520 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
521 SilcChannelClientEntry chl2 = NULL;
523 /* If the mode is channel founder and we already find a client
524 to have that mode on the channel we will enforce the sender
525 to change the channel founder mode away. There can be only one
526 channel founder on the channel. */
527 if (server->server_type == SILC_ROUTER &&
528 mode & SILC_CHANNEL_UMODE_CHANFO &&
529 chl->mode & SILC_CHANNEL_UMODE_CHANFO) {
530 silc_server_send_notify_cumode(server, sock, FALSE, channel,
531 (mode & (~SILC_CHANNEL_UMODE_CHANFO)),
532 server->id, SILC_ID_SERVER,
534 silc_free(channel_id);
536 /* Change the mode back if we changed it */
538 chl2->mode &= ~SILC_CHANNEL_UMODE_CHANFO;
542 if (chl->client == client) {
543 /* Change the mode */
545 if (!(mode & SILC_CHANNEL_UMODE_CHANFO))
552 /* Send the same notify to the channel */
553 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
554 FALSE, packet->buffer->data,
555 packet->buffer->len, FALSE);
556 silc_free(channel_id);
559 case SILC_NOTIFY_TYPE_INVITE:
561 if (packet->dst_id_type == SILC_ID_CLIENT)
564 SILC_LOG_DEBUG(("INVITE notify"));
567 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
570 channel_id = silc_id_payload_parse_id(tmp, tmp_len);
574 /* Get channel entry */
575 channel = silc_idlist_find_channel_by_id(server->global_list,
578 channel = silc_idlist_find_channel_by_id(server->local_list,
581 silc_free(channel_id);
585 silc_free(channel_id);
587 /* Get the added invite */
588 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
590 if (!channel->invite_list)
591 channel->invite_list = silc_calloc(tmp_len + 2,
592 sizeof(*channel->invite_list));
594 channel->invite_list = silc_realloc(channel->invite_list,
595 sizeof(*channel->invite_list) *
597 strlen(channel->invite_list) +
599 if (tmp[tmp_len - 1] == ',')
600 tmp[tmp_len - 1] = '\0';
602 strncat(channel->invite_list, tmp, tmp_len);
603 strncat(channel->invite_list, ",", 1);
606 /* Get the deleted invite */
607 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
608 if (tmp && channel->invite_list) {
609 char *start, *end, *n;
611 if (!strncmp(channel->invite_list, tmp,
612 strlen(channel->invite_list) - 1)) {
613 silc_free(channel->invite_list);
614 channel->invite_list = NULL;
616 start = strstr(channel->invite_list, tmp);
617 if (start && strlen(start) >= tmp_len) {
618 end = start + tmp_len;
619 n = silc_calloc(strlen(channel->invite_list) - tmp_len, sizeof(*n));
620 strncat(n, channel->invite_list, start - channel->invite_list);
621 strncat(n, end + 1, ((channel->invite_list +
622 strlen(channel->invite_list)) - end) - 1);
623 silc_free(channel->invite_list);
624 channel->invite_list = n;
631 case SILC_NOTIFY_TYPE_CHANNEL_CHANGE:
633 * Distribute to the local clients on the channel and change the
637 SILC_LOG_DEBUG(("CHANNEL CHANGE"));
639 if (sock->type != SILC_SOCKET_TYPE_ROUTER)
642 /* Get the old Channel ID */
643 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
646 channel_id = silc_id_payload_parse_id(tmp, tmp_len);
650 /* Get the channel entry */
651 channel = silc_idlist_find_channel_by_id(server->global_list,
654 channel = silc_idlist_find_channel_by_id(server->local_list,
657 silc_free(channel_id);
662 /* Send the notify to the channel */
663 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
664 FALSE, packet->buffer->data,
665 packet->buffer->len, FALSE);
667 /* Get the new Channel ID */
668 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
671 channel_id2 = silc_id_payload_parse_id(tmp, tmp_len);
675 SILC_LOG_DEBUG(("Old Channel ID id(%s)",
676 silc_id_render(channel_id, SILC_ID_CHANNEL)));
677 SILC_LOG_DEBUG(("New Channel ID id(%s)",
678 silc_id_render(channel_id2, SILC_ID_CHANNEL)));
680 /* Replace the Channel ID */
681 if (!silc_idlist_replace_channel_id(server->global_list, channel_id,
683 if (!silc_idlist_replace_channel_id(server->local_list, channel_id,
685 silc_free(channel_id2);
690 SilcBuffer users = NULL, users_modes = NULL;
692 /* Re-announce our clients on the channel as the ID has changed now */
693 silc_server_announce_get_channel_users(server, channel, &users,
696 silc_buffer_push(users, users->data - users->head);
697 silc_server_packet_send(server, sock,
698 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
699 users->data, users->len, FALSE);
700 silc_buffer_free(users);
703 silc_buffer_push(users_modes, users_modes->data - users_modes->head);
704 silc_server_packet_send_dest(server, sock,
705 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
706 channel->id, SILC_ID_CHANNEL,
708 users_modes->len, FALSE);
709 silc_buffer_free(users_modes);
713 silc_free(channel_id);
717 case SILC_NOTIFY_TYPE_SERVER_SIGNOFF:
719 * Remove the server entry and all clients that this server owns.
722 SILC_LOG_DEBUG(("SERVER SIGNOFF notify"));
725 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
728 server_id = silc_id_payload_parse_id(tmp, tmp_len);
732 /* Get server entry */
733 server_entry = silc_idlist_find_server_by_id(server->global_list,
736 server_entry = silc_idlist_find_server_by_id(server->local_list,
739 silc_free(server_id);
743 silc_free(server_id);
745 /* Free all client entries that this server owns as they will
746 become invalid now as well. */
747 silc_server_remove_clients_by_server(server, server_entry, TRUE);
749 /* Remove the server entry */
750 if (!silc_idlist_del_server(server->global_list, server_entry))
751 silc_idlist_del_server(server->local_list, server_entry);
753 /* XXX update statistics */
757 case SILC_NOTIFY_TYPE_KICKED:
759 * Distribute the notify to local clients on the channel
762 SILC_LOG_DEBUG(("KICKED notify"));
764 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
765 packet->dst_id_type);
769 /* Get channel entry */
770 channel = silc_idlist_find_channel_by_id(server->global_list,
773 channel = silc_idlist_find_channel_by_id(server->local_list,
776 silc_free(channel_id);
780 silc_free(channel_id);
783 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
786 client_id = silc_id_payload_parse_id(tmp, tmp_len);
790 /* Send to channel */
791 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
792 FALSE, packet->buffer->data,
793 packet->buffer->len, FALSE);
795 /* If the the client is not in local list we check global list */
796 client = silc_idlist_find_client_by_id(server->global_list,
799 client = silc_idlist_find_client_by_id(server->local_list,
802 silc_free(client_id);
807 /* Remove the client from channel */
808 silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
812 case SILC_NOTIFY_TYPE_KILLED:
815 * Distribute the notify to local clients on channels
820 SILC_LOG_DEBUG(("KILLED notify"));
823 id = silc_argument_get_arg_type(args, 1, &id_len);
826 client_id = silc_id_payload_parse_id(id, id_len);
830 /* If the the client is not in local list we check global list */
831 client = silc_idlist_find_client_by_id(server->global_list,
834 client = silc_idlist_find_client_by_id(server->local_list,
837 silc_free(client_id);
841 silc_free(client_id);
843 /* If the client is one of ours, then close the connection to the
844 client now. This removes the client from all channels as well. */
845 if (packet->dst_id_type == SILC_ID_CLIENT && client->data.registered &&
846 client->connection) {
847 sock = client->connection;
848 silc_server_free_client_data(server, NULL, client, FALSE, NULL);
849 silc_server_close_connection(server, sock);
854 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
858 /* Send the notify to local clients on the channels except to the
859 client who is killed. */
860 silc_server_send_notify_on_channels(server, client, client,
861 SILC_NOTIFY_TYPE_KILLED,
866 /* Remove the client from all channels */
867 silc_server_remove_from_channels(server, NULL, client, FALSE, NULL,
873 case SILC_NOTIFY_TYPE_UMODE_CHANGE:
875 * Save the mode of the client.
878 SILC_LOG_DEBUG(("UMODE_CHANGE notify"));
881 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
884 client_id = silc_id_payload_parse_id(tmp, tmp_len);
888 /* Get client entry */
889 client = silc_idlist_find_client_by_id(server->global_list,
892 client = silc_idlist_find_client_by_id(server->local_list,
895 silc_free(client_id);
899 silc_free(client_id);
902 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
907 SILC_GET32_MSB(client->mode, tmp);
911 case SILC_NOTIFY_TYPE_BAN:
916 SILC_LOG_DEBUG(("BAN notify"));
919 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
922 channel_id = silc_id_payload_parse_id(tmp, tmp_len);
926 /* Get channel entry */
927 channel = silc_idlist_find_channel_by_id(server->global_list,
930 channel = silc_idlist_find_channel_by_id(server->local_list,
933 silc_free(channel_id);
937 silc_free(channel_id);
939 /* Get the new ban and add it to the ban list */
940 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
942 if (!channel->ban_list)
943 channel->ban_list = silc_calloc(tmp_len + 2,
944 sizeof(*channel->ban_list));
946 channel->ban_list = silc_realloc(channel->ban_list,
947 sizeof(*channel->ban_list) *
949 strlen(channel->ban_list) + 2));
950 strncat(channel->ban_list, tmp, tmp_len);
951 strncat(channel->ban_list, ",", 1);
954 /* Get the ban to be removed and remove it from the list */
955 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
956 if (tmp && channel->ban_list) {
957 char *start, *end, *n;
959 if (!strcmp(channel->ban_list, tmp)) {
960 silc_free(channel->ban_list);
961 channel->ban_list = NULL;
963 start = strstr(channel->ban_list, tmp);
964 if (start && strlen(start) >= tmp_len) {
965 end = start + tmp_len;
966 n = silc_calloc(strlen(channel->ban_list) - tmp_len, sizeof(*n));
967 strncat(n, channel->ban_list, start - channel->ban_list);
968 strncat(n, end + 1, ((channel->ban_list +
969 strlen(channel->ban_list)) - end) - 1);
970 silc_free(channel->ban_list);
971 channel->ban_list = n;
978 /* Ignore rest of the notify types for now */
979 case SILC_NOTIFY_TYPE_NONE:
980 case SILC_NOTIFY_TYPE_MOTD:
987 silc_notify_payload_free(payload);
990 void silc_server_notify_list(SilcServer server,
991 SilcSocketConnection sock,
992 SilcPacketContext *packet)
994 SilcPacketContext *new;
998 SILC_LOG_DEBUG(("Processing Notify List"));
1000 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
1001 packet->src_id_type != SILC_ID_SERVER)
1004 /* Make copy of the original packet context, except for the actual
1005 data buffer, which we will here now fetch from the original buffer. */
1006 new = silc_packet_context_alloc();
1007 new->type = SILC_PACKET_NOTIFY;
1008 new->flags = packet->flags;
1009 new->src_id = packet->src_id;
1010 new->src_id_len = packet->src_id_len;
1011 new->src_id_type = packet->src_id_type;
1012 new->dst_id = packet->dst_id;
1013 new->dst_id_len = packet->dst_id_len;
1014 new->dst_id_type = packet->dst_id_type;
1016 buffer = silc_buffer_alloc(1024);
1017 new->buffer = buffer;
1019 while (packet->buffer->len) {
1020 SILC_GET16_MSB(len, packet->buffer->data + 2);
1021 if (len > packet->buffer->len)
1024 if (len > buffer->truelen) {
1025 silc_buffer_free(buffer);
1026 buffer = silc_buffer_alloc(1024 + len);
1029 silc_buffer_pull_tail(buffer, len);
1030 silc_buffer_put(buffer, packet->buffer->data, len);
1032 /* Process the Notify */
1033 silc_server_notify(server, sock, new);
1035 silc_buffer_push_tail(buffer, len);
1036 silc_buffer_pull(packet->buffer, len);
1039 silc_buffer_free(buffer);
1043 /* Received private message. This resolves the destination of the message
1044 and sends the packet. This is used by both server and router. If the
1045 destination is our locally connected client this sends the packet to
1046 the client. This may also send the message for further routing if
1047 the destination is not in our server (or router). */
1049 void silc_server_private_message(SilcServer server,
1050 SilcSocketConnection sock,
1051 SilcPacketContext *packet)
1053 SilcSocketConnection dst_sock;
1054 SilcIDListData idata;
1056 SILC_LOG_DEBUG(("Start"));
1058 if (packet->src_id_type != SILC_ID_CLIENT ||
1059 packet->dst_id_type != SILC_ID_CLIENT)
1062 if (!packet->dst_id)
1065 /* Get the route to the client */
1066 dst_sock = silc_server_get_client_route(server, packet->dst_id,
1067 packet->dst_id_len, NULL, &idata);
1071 /* Send the private message */
1072 silc_server_send_private_message(server, dst_sock, idata->send_key,
1073 idata->hmac_send, packet);
1076 /* Received private message key packet.. This packet is never for us. It is to
1077 the client in the packet's destination ID. Sending of this sort of packet
1078 equals sending private message, ie. it is sent point to point from
1079 one client to another. */
1081 void silc_server_private_message_key(SilcServer server,
1082 SilcSocketConnection sock,
1083 SilcPacketContext *packet)
1085 SilcSocketConnection dst_sock;
1086 SilcIDListData idata;
1088 SILC_LOG_DEBUG(("Start"));
1090 if (packet->src_id_type != SILC_ID_CLIENT ||
1091 packet->dst_id_type != SILC_ID_CLIENT)
1094 if (!packet->dst_id)
1097 /* Get the route to the client */
1098 dst_sock = silc_server_get_client_route(server, packet->dst_id,
1099 packet->dst_id_len, NULL, &idata);
1103 /* Relay the packet */
1104 silc_server_relay_packet(server, dst_sock, idata->send_key,
1105 idata->hmac_send, packet, FALSE);
1108 /* Processes incoming command reply packet. The command reply packet may
1109 be destined to one of our clients or it may directly for us. We will
1110 call the command reply routine after processing the packet. */
1112 void silc_server_command_reply(SilcServer server,
1113 SilcSocketConnection sock,
1114 SilcPacketContext *packet)
1116 SilcBuffer buffer = packet->buffer;
1117 SilcClientEntry client = NULL;
1118 SilcSocketConnection dst_sock;
1119 SilcIDListData idata;
1120 SilcClientID *id = NULL;
1122 SILC_LOG_DEBUG(("Start"));
1124 /* Source must be server or router */
1125 if (packet->src_id_type != SILC_ID_SERVER &&
1126 sock->type != SILC_SOCKET_TYPE_ROUTER)
1129 if (packet->dst_id_type == SILC_ID_CHANNEL)
1132 if (packet->dst_id_type == SILC_ID_CLIENT) {
1133 /* Destination must be one of ours */
1134 id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CLIENT);
1137 client = silc_idlist_find_client_by_id(server->local_list, id, NULL);
1139 SILC_LOG_ERROR(("Cannot process command reply to unknown client"));
1145 if (packet->dst_id_type == SILC_ID_SERVER) {
1146 /* For now this must be for us */
1147 if (memcmp(packet->dst_id, server->id_string, packet->dst_id_len)) {
1148 SILC_LOG_ERROR(("Cannot process command reply to unknown server"));
1153 /* Execute command reply locally for the command */
1154 silc_server_command_reply_process(server, sock, buffer);
1156 if (packet->dst_id_type == SILC_ID_CLIENT && client && id) {
1157 /* Relay the packet to the client */
1159 dst_sock = (SilcSocketConnection)client->connection;
1160 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1161 + packet->dst_id_len + packet->padlen);
1163 silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
1164 silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
1166 idata = (SilcIDListData)client;
1168 /* Encrypt packet */
1169 silc_packet_encrypt(idata->send_key, idata->hmac_send, dst_sock->outbuf,
1172 /* Send the packet */
1173 silc_server_packet_send_real(server, dst_sock, TRUE);
1179 /* Process received channel message. The message can be originated from
1180 client or server. */
1182 void silc_server_channel_message(SilcServer server,
1183 SilcSocketConnection sock,
1184 SilcPacketContext *packet)
1186 SilcChannelEntry channel = NULL;
1187 SilcChannelID *id = NULL;
1188 void *sender = NULL;
1189 void *sender_entry = NULL;
1191 SILC_LOG_DEBUG(("Processing channel message"));
1194 if (packet->dst_id_type != SILC_ID_CHANNEL) {
1195 SILC_LOG_DEBUG(("Received bad message for channel, dropped"));
1199 /* Find channel entry */
1200 id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CHANNEL);
1203 channel = silc_idlist_find_channel_by_id(server->local_list, id, NULL);
1205 channel = silc_idlist_find_channel_by_id(server->global_list, id, NULL);
1207 SILC_LOG_DEBUG(("Could not find channel"));
1212 /* See that this client is on the channel. If the original sender is
1213 not client (as it can be server as well) we don't do the check. */
1214 sender = silc_id_str2id(packet->src_id, packet->src_id_len,
1215 packet->src_id_type);
1218 if (packet->src_id_type == SILC_ID_CLIENT) {
1219 sender_entry = silc_idlist_find_client_by_id(server->local_list,
1222 sender_entry = silc_idlist_find_client_by_id(server->global_list,
1224 if (!sender_entry || !silc_server_client_on_channel(sender_entry,
1226 SILC_LOG_DEBUG(("Client not on channel"));
1231 /* Distribute the packet to our local clients. This will send the
1232 packet for further routing as well, if needed. */
1233 silc_server_packet_relay_to_channel(server, sock, channel, sender,
1234 packet->src_id_type, sender_entry,
1235 packet->buffer->data,
1236 packet->buffer->len, FALSE);
1245 /* Received channel key packet. We distribute the key to all of our locally
1246 connected clients on the channel. */
1248 void silc_server_channel_key(SilcServer server,
1249 SilcSocketConnection sock,
1250 SilcPacketContext *packet)
1252 SilcBuffer buffer = packet->buffer;
1253 SilcChannelEntry channel;
1255 if (packet->src_id_type != SILC_ID_SERVER ||
1256 (server->server_type == SILC_ROUTER &&
1257 sock->type == SILC_SOCKET_TYPE_ROUTER))
1260 /* Save the channel key */
1261 channel = silc_server_save_channel_key(server, buffer, NULL);
1265 /* Distribute the key to everybody who is on the channel. If we are router
1266 we will also send it to locally connected servers. */
1267 silc_server_send_channel_key(server, sock, channel, FALSE);
1270 /* Received New Client packet and processes it. Creates Client ID for the
1271 client. Client becomes registered after calling this functions. */
1273 SilcClientEntry silc_server_new_client(SilcServer server,
1274 SilcSocketConnection sock,
1275 SilcPacketContext *packet)
1277 SilcBuffer buffer = packet->buffer;
1278 SilcClientEntry client;
1279 SilcClientID *client_id;
1281 SilcIDListData idata;
1282 char *username = NULL, *realname = NULL, *id_string;
1285 char *hostname, *nickname;
1287 SILC_LOG_DEBUG(("Creating new client"));
1289 if (sock->type != SILC_SOCKET_TYPE_CLIENT)
1292 /* Take client entry */
1293 client = (SilcClientEntry)sock->user_data;
1294 idata = (SilcIDListData)client;
1296 /* Remove the old cache entry */
1297 if (!silc_idcache_del_by_context(server->local_list->clients, client)) {
1298 SILC_LOG_ERROR(("Lost client's cache entry - bad thing"));
1299 silc_server_disconnect_remote(server, sock, "Server closed connection: "
1304 /* Parse incoming packet */
1305 ret = silc_buffer_unformat(buffer,
1306 SILC_STR_UI16_STRING_ALLOC(&username),
1307 SILC_STR_UI16_STRING_ALLOC(&realname),
1311 silc_free(username);
1313 silc_free(realname);
1314 silc_server_disconnect_remote(server, sock, "Server closed connection: "
1315 "Incomplete client information");
1320 silc_free(username);
1322 silc_free(realname);
1323 silc_server_disconnect_remote(server, sock, "Server closed connection: "
1324 "Incomplete client information");
1328 if (strlen(username) > 128)
1329 username[127] = '\0';
1331 nickname = strdup(username);
1333 /* Make sanity checks for the hostname of the client. If the hostname
1334 is provided in the `username' check that it is the same than the
1335 resolved hostname, or if not resolved the hostname that appears in
1336 the client's public key. If the hostname is not present then put
1337 it from the resolved name or from the public key. */
1338 if (strchr(username, '@')) {
1339 SilcPublicKeyIdentifier pident;
1340 int tlen = strcspn(username, "@");
1341 char *phostname = NULL;
1343 hostname = silc_calloc((strlen(username) - tlen) + 1, sizeof(char));
1344 memcpy(hostname, username + tlen + 1, strlen(username) - tlen - 1);
1346 if (strcmp(sock->hostname, sock->ip) &&
1347 strcmp(sock->hostname, hostname)) {
1348 silc_free(username);
1349 silc_free(hostname);
1351 silc_free(realname);
1352 silc_server_disconnect_remote(server, sock,
1353 "Server closed connection: "
1354 "Incomplete client information");
1358 pident = silc_pkcs_decode_identifier(client->data.public_key->identifier);
1360 phostname = strdup(pident->host);
1361 silc_pkcs_free_identifier(pident);
1364 if (!strcmp(sock->hostname, sock->ip) &&
1365 phostname && strcmp(phostname, hostname)) {
1366 silc_free(username);
1367 silc_free(hostname);
1369 silc_free(phostname);
1371 silc_free(realname);
1372 silc_server_disconnect_remote(server, sock,
1373 "Server closed connection: "
1374 "Incomplete client information");
1379 silc_free(phostname);
1381 /* The hostname is not present, add it. */
1383 /* XXX For now we cannot take the host name from the public key since
1384 they are not trusted or we cannot verify them as trusted. Just take
1385 what the resolved name or address is. */
1387 if (strcmp(sock->hostname, sock->ip)) {
1389 newusername = silc_calloc(strlen(username) +
1390 strlen(sock->hostname) + 2,
1391 sizeof(*newusername));
1392 strncat(newusername, username, strlen(username));
1393 strncat(newusername, "@", 1);
1394 strncat(newusername, sock->hostname, strlen(sock->hostname));
1395 silc_free(username);
1396 username = newusername;
1399 SilcPublicKeyIdentifier pident =
1400 silc_pkcs_decode_identifier(client->data.public_key->identifier);
1403 newusername = silc_calloc(strlen(username) +
1404 strlen(pident->host) + 2,
1405 sizeof(*newusername));
1406 strncat(newusername, username, strlen(username));
1407 strncat(newusername, "@", 1);
1408 strncat(newusername, pident->host, strlen(pident->host));
1409 silc_free(username);
1410 username = newusername;
1411 silc_pkcs_free_identifier(pident);
1417 /* Create Client ID */
1418 silc_id_create_client_id(server->id, server->rng, server->md5hash,
1419 username, &client_id);
1421 /* Update client entry */
1422 idata->registered = TRUE;
1423 client->nickname = nickname;
1424 client->username = username;
1425 client->userinfo = realname ? realname : strdup(" ");
1426 client->id = client_id;
1427 id_len = silc_id_get_len(client_id, SILC_ID_CLIENT);
1429 /* Add the client again to the ID cache */
1430 silc_idcache_add(server->local_list->clients, client->nickname,
1431 client_id, client, FALSE);
1433 /* Notify our router about new client on the SILC network */
1434 if (!server->standalone)
1435 silc_server_send_new_id(server, (SilcSocketConnection)
1436 server->router->connection,
1437 server->server_type == SILC_ROUTER ? TRUE : FALSE,
1438 client->id, SILC_ID_CLIENT, id_len);
1440 /* Send the new client ID to the client. */
1441 id_string = silc_id_id2str(client->id, SILC_ID_CLIENT);
1442 reply = silc_buffer_alloc(2 + 2 + id_len);
1443 silc_buffer_pull_tail(reply, SILC_BUFFER_END(reply));
1444 silc_buffer_format(reply,
1445 SILC_STR_UI_SHORT(SILC_ID_CLIENT),
1446 SILC_STR_UI_SHORT(id_len),
1447 SILC_STR_UI_XNSTRING(id_string, id_len),
1449 silc_server_packet_send(server, sock, SILC_PACKET_NEW_ID, 0,
1450 reply->data, reply->len, FALSE);
1451 silc_free(id_string);
1452 silc_buffer_free(reply);
1454 /* Send some nice info to the client */
1455 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1456 ("Welcome to the SILC Network %s",
1458 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1459 ("Your host is %s, running version %s",
1460 server->config->server_info->server_name,
1462 if (server->server_type == SILC_ROUTER) {
1463 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1464 ("There are %d clients on %d servers in SILC "
1465 "Network", server->stat.clients,
1466 server->stat.servers + 1));
1467 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1468 ("There are %d clients on %d server in our cell",
1469 server->stat.cell_clients,
1470 server->stat.cell_servers + 1));
1471 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1472 ("I have %d clients, %d channels, %d servers and "
1474 server->stat.my_clients,
1475 server->stat.my_channels,
1476 server->stat.my_servers,
1477 server->stat.my_routers));
1478 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1479 ("%d server operators and %d router operators "
1481 server->stat.my_server_ops,
1482 server->stat.my_router_ops));
1484 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1485 ("I have %d clients and %d channels formed",
1486 server->stat.my_clients,
1487 server->stat.my_channels));
1488 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1489 ("%d operators online",
1490 server->stat.my_server_ops));
1492 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1493 ("Your connection is secured with %s cipher, "
1494 "key length %d bits",
1495 idata->send_key->cipher->name,
1496 idata->send_key->cipher->key_len));
1497 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1498 ("Your current nickname is %s",
1502 silc_server_send_motd(server, sock);
1507 /* Create new server. This processes received New Server packet and
1508 saves the received Server ID. The server is our locally connected
1509 server thus we save all the information and save it to local list.
1510 This funtion can be used by both normal server and router server.
1511 If normal server uses this it means that its router has connected
1512 to the server. If router uses this it means that one of the cell's
1513 servers is connected to the router. */
1515 SilcServerEntry silc_server_new_server(SilcServer server,
1516 SilcSocketConnection sock,
1517 SilcPacketContext *packet)
1519 SilcBuffer buffer = packet->buffer;
1520 SilcServerEntry new_server;
1521 SilcServerID *server_id;
1522 SilcIDListData idata;
1523 unsigned char *server_name, *id_string;
1524 uint16 id_len, name_len;
1527 SILC_LOG_DEBUG(("Creating new server"));
1529 if (sock->type != SILC_SOCKET_TYPE_SERVER &&
1530 sock->type != SILC_SOCKET_TYPE_ROUTER)
1533 /* Take server entry */
1534 new_server = (SilcServerEntry)sock->user_data;
1535 idata = (SilcIDListData)new_server;
1537 /* Remove the old cache entry */
1538 silc_idcache_del_by_context(server->local_list->servers, new_server);
1540 /* Parse the incoming packet */
1541 ret = silc_buffer_unformat(buffer,
1542 SILC_STR_UI16_NSTRING_ALLOC(&id_string, &id_len),
1543 SILC_STR_UI16_NSTRING_ALLOC(&server_name,
1548 silc_free(id_string);
1550 silc_free(server_name);
1554 if (id_len > buffer->len) {
1555 silc_free(id_string);
1556 silc_free(server_name);
1561 server_name[255] = '\0';
1564 server_id = silc_id_str2id(id_string, id_len, SILC_ID_SERVER);
1566 silc_free(id_string);
1567 silc_free(server_name);
1570 silc_free(id_string);
1572 /* Update server entry */
1573 idata->registered = TRUE;
1574 new_server->server_name = server_name;
1575 new_server->id = server_id;
1577 /* Add again the entry to the ID cache. */
1578 silc_idcache_add(server->local_list->servers, server_name, server_id,
1581 /* Distribute the information about new server in the SILC network
1582 to our router. If we are normal server we won't send anything
1583 since this connection must be our router connection. */
1584 if (server->server_type == SILC_ROUTER && !server->standalone &&
1585 server->router->connection != sock)
1586 silc_server_send_new_id(server, server->router->connection,
1587 TRUE, new_server->id, SILC_ID_SERVER,
1588 silc_id_get_len(server_id, SILC_ID_SERVER));
1590 if (server->server_type == SILC_ROUTER)
1591 server->stat.cell_servers++;
1596 /* Processes incoming New ID packet. New ID Payload is used to distribute
1597 information about newly registered clients and servers. */
1599 static void silc_server_new_id_real(SilcServer server,
1600 SilcSocketConnection sock,
1601 SilcPacketContext *packet,
1604 SilcBuffer buffer = packet->buffer;
1606 SilcServerEntry router;
1607 SilcSocketConnection router_sock;
1612 SILC_LOG_DEBUG(("Processing new ID"));
1614 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
1615 server->server_type == SILC_SERVER ||
1616 packet->src_id_type != SILC_ID_SERVER)
1619 idp = silc_id_payload_parse(buffer);
1623 id_type = silc_id_payload_get_type(idp);
1625 /* Normal server cannot have other normal server connections */
1626 if (id_type == SILC_ID_SERVER && sock->type == SILC_SOCKET_TYPE_SERVER)
1629 id = silc_id_payload_get_id(idp);
1633 /* If the sender of this packet is server and we are router we need to
1634 broadcast this packet to other routers in the network. */
1635 if (broadcast && !server->standalone && server->server_type == SILC_ROUTER &&
1636 sock->type == SILC_SOCKET_TYPE_SERVER &&
1637 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
1638 SILC_LOG_DEBUG(("Broadcasting received New ID packet"));
1639 silc_server_packet_send(server, server->router->connection,
1641 packet->flags | SILC_PACKET_FLAG_BROADCAST,
1642 buffer->data, buffer->len, FALSE);
1645 if (sock->type == SILC_SOCKET_TYPE_SERVER)
1646 id_list = server->local_list;
1648 id_list = server->global_list;
1650 /* If the packet is coming from server then use the sender as the
1651 origin of the the packet. If it came from router then check the real
1652 sender of the packet and use that as the origin. */
1653 if (sock->type == SILC_SOCKET_TYPE_SERVER) {
1655 router = sock->user_data;
1657 void *sender_id = silc_id_str2id(packet->src_id, packet->src_id_len,
1658 packet->src_id_type);
1659 router = silc_idlist_find_server_by_id(server->global_list,
1662 router = silc_idlist_find_server_by_id(server->local_list,
1664 silc_free(sender_id);
1671 case SILC_ID_CLIENT:
1673 SilcClientEntry entry;
1675 SILC_LOG_DEBUG(("New client id(%s) from [%s] %s",
1676 silc_id_render(id, SILC_ID_CLIENT),
1677 sock->type == SILC_SOCKET_TYPE_SERVER ?
1678 "Server" : "Router", sock->hostname));
1680 /* As a router we keep information of all global information in our
1681 global list. Cell wide information however is kept in the local
1683 entry = silc_idlist_add_client(id_list, NULL, NULL, NULL,
1685 entry->nickname = NULL;
1686 entry->data.registered = TRUE;
1688 if (sock->type == SILC_SOCKET_TYPE_SERVER)
1689 server->stat.cell_clients++;
1690 server->stat.clients++;
1694 case SILC_ID_SERVER:
1695 /* If the ID is mine, ignore it. */
1696 if (SILC_ID_SERVER_COMPARE(id, server->id)) {
1697 SILC_LOG_DEBUG(("Ignoring my own ID as new ID"));
1701 SILC_LOG_DEBUG(("New server id(%s) from [%s] %s",
1702 silc_id_render(id, SILC_ID_SERVER),
1703 sock->type == SILC_SOCKET_TYPE_SERVER ?
1704 "Server" : "Router", sock->hostname));
1706 /* As a router we keep information of all global information in our global
1707 list. Cell wide information however is kept in the local list. */
1708 silc_idlist_add_server(id_list, NULL, 0, id, router, router_sock);
1710 if (sock->type == SILC_SOCKET_TYPE_SERVER)
1711 server->stat.cell_servers++;
1712 server->stat.servers++;
1715 case SILC_ID_CHANNEL:
1716 SILC_LOG_ERROR(("Channel cannot be registered with NEW_ID packet"));
1724 silc_id_payload_free(idp);
1728 /* Processes incoming New ID packet. New ID Payload is used to distribute
1729 information about newly registered clients and servers. */
1731 void silc_server_new_id(SilcServer server, SilcSocketConnection sock,
1732 SilcPacketContext *packet)
1734 silc_server_new_id_real(server, sock, packet, TRUE);
1737 /* Receoved New Id List packet, list of New ID payloads inside one
1738 packet. Process the New ID payloads one by one. */
1740 void silc_server_new_id_list(SilcServer server, SilcSocketConnection sock,
1741 SilcPacketContext *packet)
1743 SilcPacketContext *new_id;
1747 SILC_LOG_DEBUG(("Processing New ID List"));
1749 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
1750 packet->src_id_type != SILC_ID_SERVER)
1753 /* If the sender of this packet is server and we are router we need to
1754 broadcast this packet to other routers in the network. Broadcast
1755 this list packet instead of multiple New ID packets. */
1756 if (!server->standalone && server->server_type == SILC_ROUTER &&
1757 sock->type == SILC_SOCKET_TYPE_SERVER &&
1758 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
1759 SILC_LOG_DEBUG(("Broadcasting received New ID List packet"));
1760 silc_server_packet_send(server, server->router->connection,
1762 packet->flags | SILC_PACKET_FLAG_BROADCAST,
1763 packet->buffer->data, packet->buffer->len, FALSE);
1766 /* Make copy of the original packet context, except for the actual
1767 data buffer, which we will here now fetch from the original buffer. */
1768 new_id = silc_packet_context_alloc();
1769 new_id->type = SILC_PACKET_NEW_ID;
1770 new_id->flags = packet->flags;
1771 new_id->src_id = packet->src_id;
1772 new_id->src_id_len = packet->src_id_len;
1773 new_id->src_id_type = packet->src_id_type;
1774 new_id->dst_id = packet->dst_id;
1775 new_id->dst_id_len = packet->dst_id_len;
1776 new_id->dst_id_type = packet->dst_id_type;
1778 idp = silc_buffer_alloc(256);
1779 new_id->buffer = idp;
1781 while (packet->buffer->len) {
1782 SILC_GET16_MSB(id_len, packet->buffer->data + 2);
1783 if ((id_len > packet->buffer->len) ||
1784 (id_len > idp->truelen))
1787 silc_buffer_pull_tail(idp, 4 + id_len);
1788 silc_buffer_put(idp, packet->buffer->data, 4 + id_len);
1790 /* Process the New ID */
1791 silc_server_new_id_real(server, sock, new_id, FALSE);
1793 silc_buffer_push_tail(idp, 4 + id_len);
1794 silc_buffer_pull(packet->buffer, 4 + id_len);
1797 silc_buffer_free(idp);
1801 /* Received New Channel packet. Information about new channels in the
1802 network are distributed using this packet. Save the information about
1803 the new channel. This usually comes from router but also normal server
1804 can send this to notify channels it has when it connects to us. */
1806 void silc_server_new_channel(SilcServer server,
1807 SilcSocketConnection sock,
1808 SilcPacketContext *packet)
1810 SilcChannelPayload payload;
1811 SilcChannelID *channel_id;
1818 SILC_LOG_DEBUG(("Processing New Channel"));
1820 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
1821 packet->src_id_type != SILC_ID_SERVER ||
1822 server->server_type == SILC_SERVER)
1825 /* Parse the channel payload */
1826 payload = silc_channel_payload_parse(packet->buffer);
1830 /* Get the channel ID */
1831 channel_id = silc_channel_get_id_parse(payload);
1833 silc_channel_payload_free(payload);
1837 channel_name = silc_channel_get_name(payload, &name_len);
1839 channel_name[255] = '\0';
1841 id = silc_channel_get_id(payload, &id_len);
1843 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
1844 /* Add the server to global list as it is coming from router. It
1845 cannot be our own channel as it is coming from router. */
1847 SILC_LOG_DEBUG(("New channel id(%s) from [Router] %s",
1848 silc_id_render(channel_id, SILC_ID_CHANNEL),
1851 silc_idlist_add_channel(server->global_list, strdup(channel_name),
1852 0, channel_id, server->router->connection,
1855 server->stat.channels++;
1857 /* The channel is coming from our server, thus it is in our cell
1858 we will add it to our local list. */
1859 SilcChannelEntry channel;
1862 SILC_LOG_DEBUG(("New channel id(%s) from [Server] %s",
1863 silc_id_render(channel_id, SILC_ID_CHANNEL),
1866 /* Check that we don't already have this channel */
1867 channel = silc_idlist_find_channel_by_name(server->local_list,
1868 channel_name, NULL);
1870 channel = silc_idlist_find_channel_by_name(server->global_list,
1871 channel_name, NULL);
1873 /* If the channel does not exist, then create it. We create the channel
1874 with the channel ID provided by the server. This creates a new
1875 key to the channel as well that we will send to the server. */
1877 channel = silc_server_create_new_channel_with_id(server, NULL, NULL,
1881 silc_channel_payload_free(payload);
1882 silc_free(channel_id);
1886 /* Get the mode and set it to the channel */
1887 channel->mode = silc_channel_get_mode(payload);
1889 /* Send the new channel key to the server */
1890 chk = silc_channel_key_payload_encode(id_len, id,
1891 strlen(channel->channel_key->
1893 channel->channel_key->cipher->name,
1894 channel->key_len / 8,
1896 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
1897 chk->data, chk->len, FALSE);
1898 silc_buffer_free(chk);
1901 /* The channel exist by that name, check whether the ID's match.
1902 If they don't then we'll force the server to use the ID we have.
1903 We also create a new key for the channel. */
1904 SilcBuffer users = NULL, users_modes = NULL;
1907 channel_id = silc_id_dup(channel_id, SILC_ID_CHANNEL);
1909 if (!SILC_ID_CHANNEL_COMPARE(channel_id, channel->id)) {
1910 /* They don't match, send CHANNEL_CHANGE notify to the server to
1911 force the ID change. */
1912 SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
1913 silc_server_send_notify_channel_change(server, sock, FALSE,
1914 channel_id, channel->id);
1917 /* If the mode is different from what we have then enforce the
1919 mode = silc_channel_get_mode(payload);
1920 if (channel->mode != mode) {
1921 SILC_LOG_DEBUG(("Forcing the server to change channel mode"));
1922 silc_server_send_notify_cmode(server, sock, FALSE, channel,
1923 channel->mode, server->id,
1925 channel->cipher, channel->hmac_name);
1928 /* Create new key for the channel and send it to the server and
1929 everybody else possibly on the channel. */
1931 if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
1932 silc_server_create_channel_key(server, channel, 0);
1934 /* Send to the channel */
1935 silc_server_send_channel_key(server, sock, channel, FALSE);
1936 id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
1937 id_len = SILC_ID_CHANNEL_LEN;
1939 /* Send to the server */
1940 chk = silc_channel_key_payload_encode(id_len, id,
1941 strlen(channel->channel_key->
1943 channel->channel_key->
1945 channel->key_len / 8,
1947 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
1948 chk->data, chk->len, FALSE);
1949 silc_buffer_free(chk);
1953 silc_free(channel_id);
1955 /* Since the channel is coming from server and we also know about it
1956 then send the JOIN notify to the server so that it see's our
1957 users on the channel "joining" the channel. */
1958 silc_server_announce_get_channel_users(server, channel, &users,
1961 silc_buffer_push(users, users->data - users->head);
1962 silc_server_packet_send(server, sock,
1963 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1964 users->data, users->len, FALSE);
1965 silc_buffer_free(users);
1968 silc_buffer_push(users_modes, users_modes->data - users_modes->head);
1969 silc_server_packet_send_dest(server, sock,
1970 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1971 channel->id, SILC_ID_CHANNEL,
1973 users_modes->len, FALSE);
1974 silc_buffer_free(users_modes);
1979 silc_channel_payload_free(payload);
1982 /* Received New Channel List packet, list of New Channel List payloads inside
1983 one packet. Process the New Channel payloads one by one. */
1985 void silc_server_new_channel_list(SilcServer server,
1986 SilcSocketConnection sock,
1987 SilcPacketContext *packet)
1989 SilcPacketContext *new;
1993 SILC_LOG_DEBUG(("Processing New Channel List"));
1995 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
1996 packet->src_id_type != SILC_ID_SERVER ||
1997 server->server_type == SILC_SERVER)
2000 /* If the sender of this packet is server and we are router we need to
2001 broadcast this packet to other routers in the network. Broadcast
2002 this list packet instead of multiple New Channel packets. */
2003 if (!server->standalone && server->server_type == SILC_ROUTER &&
2004 sock->type == SILC_SOCKET_TYPE_SERVER &&
2005 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2006 SILC_LOG_DEBUG(("Broadcasting received New Channel List packet"));
2007 silc_server_packet_send(server, server->router->connection,
2009 packet->flags | SILC_PACKET_FLAG_BROADCAST,
2010 packet->buffer->data, packet->buffer->len, FALSE);
2013 /* Make copy of the original packet context, except for the actual
2014 data buffer, which we will here now fetch from the original buffer. */
2015 new = silc_packet_context_alloc();
2016 new->type = SILC_PACKET_NEW_CHANNEL;
2017 new->flags = packet->flags;
2018 new->src_id = packet->src_id;
2019 new->src_id_len = packet->src_id_len;
2020 new->src_id_type = packet->src_id_type;
2021 new->dst_id = packet->dst_id;
2022 new->dst_id_len = packet->dst_id_len;
2023 new->dst_id_type = packet->dst_id_type;
2025 buffer = silc_buffer_alloc(512);
2026 new->buffer = buffer;
2028 while (packet->buffer->len) {
2029 SILC_GET16_MSB(len1, packet->buffer->data);
2030 if ((len1 > packet->buffer->len) ||
2031 (len1 > buffer->truelen))
2034 SILC_GET16_MSB(len2, packet->buffer->data + 2 + len1);
2035 if ((len2 > packet->buffer->len) ||
2036 (len2 > buffer->truelen))
2039 silc_buffer_pull_tail(buffer, 8 + len1 + len2);
2040 silc_buffer_put(buffer, packet->buffer->data, 8 + len1 + len2);
2042 /* Process the New Channel */
2043 silc_server_new_channel(server, sock, new);
2045 silc_buffer_push_tail(buffer, 8 + len1 + len2);
2046 silc_buffer_pull(packet->buffer, 8 + len1 + len2);
2049 silc_buffer_free(buffer);
2053 /* Received key agreement packet. This packet is never for us. It is to
2054 the client in the packet's destination ID. Sending of this sort of packet
2055 equals sending private message, ie. it is sent point to point from
2056 one client to another. */
2058 void silc_server_key_agreement(SilcServer server,
2059 SilcSocketConnection sock,
2060 SilcPacketContext *packet)
2062 SilcSocketConnection dst_sock;
2063 SilcIDListData idata;
2065 SILC_LOG_DEBUG(("Start"));
2067 if (packet->src_id_type != SILC_ID_CLIENT ||
2068 packet->dst_id_type != SILC_ID_CLIENT)
2071 if (!packet->dst_id)
2074 /* Get the route to the client */
2075 dst_sock = silc_server_get_client_route(server, packet->dst_id,
2076 packet->dst_id_len, NULL, &idata);
2080 /* Relay the packet */
2081 silc_server_relay_packet(server, dst_sock, idata->send_key,
2082 idata->hmac_send, packet, FALSE);
2085 /* Received connection auth request packet that is used during connection
2086 phase to resolve the mandatory authentication method. This packet can
2087 actually be received at anytime but usually it is used only during
2088 the connection authentication phase. Now, protocol says that this packet
2089 can come from client or server, however, we support only this coming
2090 from client and expect that server's always knows what authentication
2093 void silc_server_connection_auth_request(SilcServer server,
2094 SilcSocketConnection sock,
2095 SilcPacketContext *packet)
2097 SilcServerConfigSectionClientConnection *client = NULL;
2100 SilcAuthMethod auth_meth;
2102 SILC_LOG_DEBUG(("Start"));
2104 if (packet->src_id_type && packet->src_id_type != SILC_ID_CLIENT)
2107 /* Parse the payload */
2108 ret = silc_buffer_unformat(packet->buffer,
2109 SILC_STR_UI_SHORT(&conn_type),
2110 SILC_STR_UI_SHORT(NULL),
2115 if (conn_type != SILC_SOCKET_TYPE_CLIENT)
2118 /* Get the authentication method for the client */
2119 auth_meth = SILC_AUTH_NONE;
2120 client = silc_server_config_find_client_conn(server->config,
2124 client = silc_server_config_find_client_conn(server->config,
2128 auth_meth = client->auth_meth;
2130 /* Send it back to the client */
2131 silc_server_send_connection_auth_request(server, sock,
2136 /* Received REKEY packet. The sender of the packet wants to regenerate
2137 its session keys. This starts the REKEY protocol. */
2139 void silc_server_rekey(SilcServer server,
2140 SilcSocketConnection sock,
2141 SilcPacketContext *packet)
2143 SilcProtocol protocol;
2144 SilcServerRekeyInternalContext *proto_ctx;
2145 SilcIDListData idata = (SilcIDListData)sock->user_data;
2147 SILC_LOG_DEBUG(("Start"));
2149 /* Allocate internal protocol context. This is sent as context
2151 proto_ctx = silc_calloc(1, sizeof(*proto_ctx));
2152 proto_ctx->server = (void *)server;
2153 proto_ctx->sock = sock;
2154 proto_ctx->responder = TRUE;
2155 proto_ctx->pfs = idata->rekey->pfs;
2157 /* Perform rekey protocol. Will call the final callback after the
2158 protocol is over. */
2159 silc_protocol_alloc(SILC_PROTOCOL_SERVER_REKEY,
2160 &protocol, proto_ctx, silc_server_rekey_final);
2161 sock->protocol = protocol;
2163 if (proto_ctx->pfs == FALSE)
2164 /* Run the protocol */
2165 silc_protocol_execute(protocol, server->timeout_queue, 0, 0);