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 = NULL, *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, idata->psn_send++,
78 /* Parse the Notify Payload */
79 payload = silc_notify_payload_parse(packet->buffer->data,
84 /* If we are router and this packet is not already broadcast packet
85 we will broadcast it. The sending socket really cannot be router or
86 the router is buggy. If this packet is coming from router then it must
87 have the broadcast flag set already and we won't do anything. */
88 if (!server->standalone && server->server_type == SILC_ROUTER &&
89 sock->type == SILC_SOCKET_TYPE_SERVER &&
90 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
91 SILC_LOG_DEBUG(("Broadcasting received Notify packet"));
92 if (packet->dst_id_type == SILC_ID_CHANNEL) {
93 /* Packet is destined to channel */
94 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
99 silc_server_packet_send_dest(server, server->router->connection,
101 packet->flags | SILC_PACKET_FLAG_BROADCAST,
102 channel_id, SILC_ID_CHANNEL,
103 packet->buffer->data, packet->buffer->len,
105 silc_server_backup_send_dest(server, (SilcServerEntry)sock->user_data,
106 packet->type, packet->flags,
107 channel_id, SILC_ID_CHANNEL,
108 packet->buffer->data, packet->buffer->len,
111 /* Packet is destined to client or server */
112 silc_server_packet_send(server, server->router->connection,
114 packet->flags | SILC_PACKET_FLAG_BROADCAST,
115 packet->buffer->data, packet->buffer->len,
117 silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
118 packet->type, packet->flags,
119 packet->buffer->data, packet->buffer->len,
124 type = silc_notify_get_type(payload);
125 args = silc_notify_get_args(payload);
130 case SILC_NOTIFY_TYPE_JOIN:
132 * Distribute the notify to local clients on the channel
134 SILC_LOG_DEBUG(("JOIN notify"));
137 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
140 channel_id = silc_id_payload_parse_id(tmp, tmp_len);
144 /* Get channel entry */
145 channel = silc_idlist_find_channel_by_id(server->global_list,
148 channel = silc_idlist_find_channel_by_id(server->local_list,
151 silc_free(channel_id);
155 silc_free(channel_id);
158 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
161 client_id = silc_id_payload_parse_id(tmp, tmp_len);
165 /* If the the client is not in local list we check global list (ie. the
166 channel will be global channel) and if it does not exist then create
167 entry for the client. */
168 client = silc_idlist_find_client_by_id(server->global_list,
169 client_id, server->server_type,
172 client = silc_idlist_find_client_by_id(server->local_list,
173 client_id, server->server_type,
176 /* If router did not find the client the it is bogus */
177 if (server->server_type != SILC_SERVER)
181 silc_idlist_add_client(server->global_list, NULL, NULL, NULL,
182 silc_id_dup(client_id, SILC_ID_CLIENT),
183 sock->user_data, NULL);
185 SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
186 silc_free(client_id);
190 client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
194 /* Do not process the notify if the client is not registered */
195 if (!(client->data.status & SILC_IDLIST_STATUS_REGISTERED))
198 /* Do not add client to channel if it is there already */
199 if (silc_server_client_on_channel(client, channel)) {
200 SILC_LOG_DEBUG(("Client already on channel"));
204 /* Send to channel */
205 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
206 FALSE, packet->buffer->data,
207 packet->buffer->len, FALSE);
209 if (server->server_type != SILC_ROUTER &&
210 sock->type == SILC_SOCKET_TYPE_ROUTER)
211 /* The channel is global now */
212 channel->global_users = TRUE;
214 /* JOIN the global client to the channel (local clients (if router
215 created the channel) is joined in the pending JOIN command). */
216 chl = silc_calloc(1, sizeof(*chl));
217 chl->client = client;
218 chl->channel = channel;
220 /* If this is the first one on the channel then it is the founder of
222 if (!silc_hash_table_count(channel->user_list))
223 chl->mode = (SILC_CHANNEL_UMODE_CHANOP | SILC_CHANNEL_UMODE_CHANFO);
225 silc_hash_table_add(channel->user_list, client, chl);
226 silc_hash_table_add(client->channels, channel, chl);
227 silc_free(client_id);
231 case SILC_NOTIFY_TYPE_LEAVE:
233 * Distribute the notify to local clients on the channel
235 SILC_LOG_DEBUG(("LEAVE notify"));
238 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
239 packet->dst_id_type);
244 /* Get channel entry */
245 channel = silc_idlist_find_channel_by_id(server->global_list,
248 channel = silc_idlist_find_channel_by_id(server->local_list,
251 silc_free(channel_id);
257 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
259 silc_free(channel_id);
262 client_id = silc_id_payload_parse_id(tmp, tmp_len);
264 silc_free(channel_id);
268 /* Get client entry */
269 client = silc_idlist_find_client_by_id(server->global_list,
270 client_id, TRUE, NULL);
272 client = silc_idlist_find_client_by_id(server->local_list,
273 client_id, TRUE, NULL);
275 silc_free(client_id);
276 silc_free(channel_id);
280 silc_free(client_id);
282 /* Check if on channel */
283 if (!silc_server_client_on_channel(client, channel))
286 /* Send the leave notify to channel */
287 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
288 FALSE, packet->buffer->data,
289 packet->buffer->len, FALSE);
291 /* Remove the user from channel */
292 silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
295 case SILC_NOTIFY_TYPE_SIGNOFF:
297 * Distribute the notify to local clients on the channel
299 SILC_LOG_DEBUG(("SIGNOFF notify"));
302 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
305 client_id = silc_id_payload_parse_id(tmp, tmp_len);
309 /* Get client entry */
310 client = silc_idlist_find_client_by_id(server->global_list,
311 client_id, TRUE, &cache);
313 client = silc_idlist_find_client_by_id(server->local_list,
314 client_id, TRUE, &cache);
316 silc_free(client_id);
320 silc_free(client_id);
322 /* Get signoff message */
323 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
327 /* Remove the client from all channels. */
328 silc_server_remove_from_channels(server, NULL, client, TRUE, tmp, FALSE);
330 client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
331 cache->expire = SILC_ID_CACHE_EXPIRE_DEF;
332 server->stat.clients--;
333 if (server->server_type == SILC_ROUTER)
334 server->stat.cell_clients--;
337 case SILC_NOTIFY_TYPE_TOPIC_SET:
339 * Distribute the notify to local clients on the channel
342 SILC_LOG_DEBUG(("TOPIC SET notify"));
345 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
346 packet->dst_id_type);
351 /* Get channel entry */
352 channel = silc_idlist_find_channel_by_id(server->global_list,
355 channel = silc_idlist_find_channel_by_id(server->local_list,
358 silc_free(channel_id);
364 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
366 silc_free(channel_id);
370 silc_free(channel->topic);
371 channel->topic = strdup(tmp);
373 /* Send the same notify to the channel */
374 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
375 FALSE, packet->buffer->data,
376 packet->buffer->len, FALSE);
377 silc_free(channel_id);
380 case SILC_NOTIFY_TYPE_NICK_CHANGE:
383 * Distribute the notify to local clients on the channel
385 unsigned char *id, *id2;
387 SILC_LOG_DEBUG(("NICK CHANGE notify"));
389 /* Get old client ID */
390 id = silc_argument_get_arg_type(args, 1, &tmp_len);
393 client_id = silc_id_payload_parse_id(id, tmp_len);
397 /* Get new client ID */
398 id2 = silc_argument_get_arg_type(args, 2, &tmp_len);
401 client_id2 = silc_id_payload_parse_id(id2, tmp_len);
405 SILC_LOG_DEBUG(("Old Client ID id(%s)",
406 silc_id_render(client_id, SILC_ID_CLIENT)));
407 SILC_LOG_DEBUG(("New Client ID id(%s)",
408 silc_id_render(client_id2, SILC_ID_CLIENT)));
410 /* Replace the Client ID */
411 client = silc_idlist_replace_client_id(server->global_list, client_id,
414 client = silc_idlist_replace_client_id(server->local_list, client_id,
418 /* The nickname is not valid anymore, set it NULL. This causes that
419 the nickname will be queried if someone wants to know it. */
420 if (client->nickname)
421 silc_free(client->nickname);
422 client->nickname = NULL;
424 /* Send the NICK_CHANGE notify type to local clients on the channels
425 this client is joined to. */
426 silc_server_send_notify_on_channels(server, NULL, client,
427 SILC_NOTIFY_TYPE_NICK_CHANGE, 2,
432 silc_free(client_id);
434 silc_free(client_id2);
438 case SILC_NOTIFY_TYPE_CMODE_CHANGE:
440 * Distribute the notify to local clients on the channel
443 SILC_LOG_DEBUG(("CMODE CHANGE notify"));
446 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
447 packet->dst_id_type);
452 /* Get channel entry */
453 channel = silc_idlist_find_channel_by_id(server->global_list,
456 channel = silc_idlist_find_channel_by_id(server->local_list,
459 silc_free(channel_id);
465 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
467 silc_free(channel_id);
471 SILC_GET32_MSB(mode, tmp);
473 /* Check if mode changed */
474 if (channel->mode == mode)
477 /* Send the same notify to the channel */
478 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
479 FALSE, packet->buffer->data,
480 packet->buffer->len, FALSE);
482 /* If the channel had private keys set and the mode was removed then
483 we must re-generate and re-distribute a new channel key */
484 if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY &&
485 !(mode & SILC_CHANNEL_MODE_PRIVKEY)) {
486 /* Re-generate channel key */
487 if (!silc_server_create_channel_key(server, channel, 0))
490 /* Send the channel key. This sends it to our local clients and if
491 we are normal server to our router as well. */
492 silc_server_send_channel_key(server, NULL, channel,
493 server->server_type == SILC_ROUTER ?
494 FALSE : !server->standalone);
498 channel->mode = mode;
499 silc_free(channel_id);
502 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
504 unsigned char hash[32];
507 silc_hmac_free(channel->hmac);
508 if (!silc_hmac_alloc(tmp, NULL, &channel->hmac))
511 /* Set the HMAC key out of current channel key. The client must do
513 silc_hash_make(silc_hmac_get_hash(channel->hmac), channel->key,
514 channel->key_len / 8,
516 silc_hmac_set_key(channel->hmac, hash,
517 silc_hash_len(silc_hmac_get_hash(channel->hmac)));
518 memset(hash, 0, sizeof(hash));
521 /* Get the passphrase */
522 tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
524 silc_free(channel->passphrase);
525 channel->passphrase = strdup(tmp);
530 case SILC_NOTIFY_TYPE_CUMODE_CHANGE:
533 * Distribute the notify to local clients on the channel
535 SilcChannelClientEntry chl2 = NULL;
536 bool notify_sent = FALSE;
538 SILC_LOG_DEBUG(("CUMODE CHANGE notify"));
541 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
542 packet->dst_id_type);
547 /* Get channel entry */
548 channel = silc_idlist_find_channel_by_id(server->global_list,
551 channel = silc_idlist_find_channel_by_id(server->local_list,
554 silc_free(channel_id);
560 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
562 silc_free(channel_id);
566 SILC_GET32_MSB(mode, tmp);
568 /* Get target client */
569 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
572 client_id = silc_id_payload_parse_id(tmp, tmp_len);
576 /* Get client entry */
577 client = silc_idlist_find_client_by_id(server->global_list,
578 client_id, TRUE, NULL);
580 client = silc_idlist_find_client_by_id(server->local_list,
581 client_id, TRUE, NULL);
583 silc_free(client_id);
587 silc_free(client_id);
589 /* Get entry to the channel user list */
590 silc_hash_table_list(channel->user_list, &htl);
591 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
592 /* If the mode is channel founder and we already find a client
593 to have that mode on the channel we will enforce the sender
594 to change the channel founder mode away. There can be only one
595 channel founder on the channel. */
596 if (server->server_type == SILC_ROUTER &&
597 mode & SILC_CHANNEL_UMODE_CHANFO &&
598 chl->mode & SILC_CHANNEL_UMODE_CHANFO) {
600 unsigned char cumode[4];
602 if (chl->client == client && chl->mode == mode) {
607 mode &= ~SILC_CHANNEL_UMODE_CHANFO;
608 silc_server_send_notify_cumode(server, sock, FALSE, channel, mode,
609 client->id, SILC_ID_CLIENT,
612 idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
613 SILC_PUT32_MSB(mode, cumode);
614 silc_server_send_notify_to_channel(server, sock, channel, FALSE,
615 SILC_NOTIFY_TYPE_CUMODE_CHANGE,
616 3, idp->data, idp->len,
618 idp->data, idp->len);
619 silc_buffer_free(idp);
622 /* Force the mode change if we alredy set the mode */
625 silc_free(channel_id);
630 if (chl->client == client) {
631 if (chl->mode == mode) {
636 /* Change the mode */
638 if (!(mode & SILC_CHANNEL_UMODE_CHANFO))
645 /* Send the same notify to the channel */
647 silc_server_packet_send_to_channel(server, sock, channel,
649 FALSE, packet->buffer->data,
650 packet->buffer->len, FALSE);
652 silc_free(channel_id);
656 case SILC_NOTIFY_TYPE_INVITE:
658 if (packet->dst_id_type == SILC_ID_CLIENT)
661 SILC_LOG_DEBUG(("INVITE notify"));
664 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
667 channel_id = silc_id_payload_parse_id(tmp, tmp_len);
671 /* Get channel entry */
672 channel = silc_idlist_find_channel_by_id(server->global_list,
675 channel = silc_idlist_find_channel_by_id(server->local_list,
678 silc_free(channel_id);
682 silc_free(channel_id);
684 /* Get the added invite */
685 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
687 if (!channel->invite_list)
688 channel->invite_list = silc_calloc(tmp_len + 2,
689 sizeof(*channel->invite_list));
691 channel->invite_list = silc_realloc(channel->invite_list,
692 sizeof(*channel->invite_list) *
694 strlen(channel->invite_list) +
696 if (tmp[tmp_len - 1] == ',')
697 tmp[tmp_len - 1] = '\0';
699 strncat(channel->invite_list, tmp, tmp_len);
700 strncat(channel->invite_list, ",", 1);
703 /* Get the deleted invite */
704 tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
705 if (tmp && channel->invite_list) {
706 char *start, *end, *n;
708 if (!strncmp(channel->invite_list, tmp,
709 strlen(channel->invite_list) - 1)) {
710 silc_free(channel->invite_list);
711 channel->invite_list = NULL;
713 start = strstr(channel->invite_list, tmp);
714 if (start && strlen(start) >= tmp_len) {
715 end = start + tmp_len;
716 n = silc_calloc(strlen(channel->invite_list) - tmp_len, sizeof(*n));
717 strncat(n, channel->invite_list, start - channel->invite_list);
718 strncat(n, end + 1, ((channel->invite_list +
719 strlen(channel->invite_list)) - end) - 1);
720 silc_free(channel->invite_list);
721 channel->invite_list = n;
728 case SILC_NOTIFY_TYPE_CHANNEL_CHANGE:
730 * Distribute to the local clients on the channel and change the
734 SILC_LOG_DEBUG(("CHANNEL CHANGE"));
736 if (sock->type != SILC_SOCKET_TYPE_ROUTER)
739 /* Get the old Channel ID */
740 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
743 channel_id = silc_id_payload_parse_id(tmp, tmp_len);
747 /* Get the channel entry */
748 channel = silc_idlist_find_channel_by_id(server->global_list,
751 channel = silc_idlist_find_channel_by_id(server->local_list,
754 silc_free(channel_id);
759 /* Send the notify to the channel */
760 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
761 FALSE, packet->buffer->data,
762 packet->buffer->len, FALSE);
764 /* Get the new Channel ID */
765 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
768 channel_id2 = silc_id_payload_parse_id(tmp, tmp_len);
772 SILC_LOG_DEBUG(("Old Channel ID id(%s)",
773 silc_id_render(channel_id, SILC_ID_CHANNEL)));
774 SILC_LOG_DEBUG(("New Channel ID id(%s)",
775 silc_id_render(channel_id2, SILC_ID_CHANNEL)));
777 /* Replace the Channel ID */
778 if (!silc_idlist_replace_channel_id(server->global_list, channel_id,
780 if (!silc_idlist_replace_channel_id(server->local_list, channel_id,
782 silc_free(channel_id2);
787 SilcBuffer users = NULL, users_modes = NULL;
789 /* Re-announce our clients on the channel as the ID has changed now */
790 silc_server_announce_get_channel_users(server, channel, &users,
793 silc_buffer_push(users, users->data - users->head);
794 silc_server_packet_send(server, sock,
795 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
796 users->data, users->len, FALSE);
797 silc_buffer_free(users);
800 silc_buffer_push(users_modes, users_modes->data - users_modes->head);
801 silc_server_packet_send_dest(server, sock,
802 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
803 channel->id, SILC_ID_CHANNEL,
805 users_modes->len, FALSE);
806 silc_buffer_free(users_modes);
809 /* Re-announce channel's topic */
810 if (channel->topic) {
811 silc_server_send_notify_topic_set(server, sock,
812 server->server_type == SILC_ROUTER ?
813 TRUE : FALSE, channel,
814 channel->id, SILC_ID_CHANNEL,
819 silc_free(channel_id);
823 case SILC_NOTIFY_TYPE_SERVER_SIGNOFF:
825 * Remove the server entry and all clients that this server owns.
828 SILC_LOG_DEBUG(("SERVER SIGNOFF notify"));
831 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
834 server_id = silc_id_payload_parse_id(tmp, tmp_len);
838 /* Get server entry */
839 server_entry = silc_idlist_find_server_by_id(server->global_list,
840 server_id, TRUE, NULL);
842 server_entry = silc_idlist_find_server_by_id(server->local_list,
843 server_id, TRUE, NULL);
845 /* If we are normal server then we might not have the server. Check
846 whether router was kind enough to send the list of all clients
847 that actually was to be removed. Remove them if the list is
849 if (server->server_type != SILC_ROUTER &&
850 silc_argument_get_arg_num(args) > 1) {
853 for (i = 1; i < silc_argument_get_arg_num(args); i++) {
855 tmp = silc_argument_get_arg_type(args, i + 1, &tmp_len);
858 client_id = silc_id_payload_parse_id(tmp, tmp_len);
862 /* Get client entry */
863 client = silc_idlist_find_client_by_id(server->global_list,
864 client_id, TRUE, &cache);
866 client = silc_idlist_find_client_by_id(server->local_list,
867 client_id, TRUE, &cache);
869 silc_free(client_id);
873 silc_free(client_id);
875 /* Remove the client from all channels. */
876 silc_server_remove_from_channels(server, NULL, client,
879 client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
880 cache->expire = SILC_ID_CACHE_EXPIRE_DEF;
881 server->stat.clients--;
882 if (server->server_type == SILC_ROUTER)
883 server->stat.cell_clients--;
887 silc_free(server_id);
891 silc_free(server_id);
893 /* Free all client entries that this server owns as they will
894 become invalid now as well. */
895 silc_server_remove_clients_by_server(server, server_entry, TRUE);
897 /* Remove the server entry */
898 if (!silc_idlist_del_server(server->global_list, server_entry))
899 silc_idlist_del_server(server->local_list, server_entry);
901 /* XXX update statistics */
905 case SILC_NOTIFY_TYPE_KICKED:
907 * Distribute the notify to local clients on the channel
910 SILC_LOG_DEBUG(("KICKED notify"));
913 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
914 packet->dst_id_type);
919 /* Get channel entry */
920 channel = silc_idlist_find_channel_by_id(server->global_list,
923 channel = silc_idlist_find_channel_by_id(server->local_list,
926 silc_free(channel_id);
930 silc_free(channel_id);
933 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
936 client_id = silc_id_payload_parse_id(tmp, tmp_len);
940 /* If the the client is not in local list we check global list */
941 client = silc_idlist_find_client_by_id(server->global_list,
942 client_id, TRUE, NULL);
944 client = silc_idlist_find_client_by_id(server->local_list,
945 client_id, TRUE, NULL);
947 silc_free(client_id);
952 /* Send to channel */
953 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
954 FALSE, packet->buffer->data,
955 packet->buffer->len, FALSE);
957 /* Remove the client from channel */
958 silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
962 case SILC_NOTIFY_TYPE_KILLED:
965 * Distribute the notify to local clients on channels
970 SILC_LOG_DEBUG(("KILLED notify"));
973 id = silc_argument_get_arg_type(args, 1, &id_len);
976 client_id = silc_id_payload_parse_id(id, id_len);
980 /* If the the client is not in local list we check global list */
981 client = silc_idlist_find_client_by_id(server->global_list,
982 client_id, TRUE, NULL);
984 client = silc_idlist_find_client_by_id(server->local_list,
985 client_id, TRUE, NULL);
987 silc_free(client_id);
991 silc_free(client_id);
993 /* If the client is one of ours, then close the connection to the
994 client now. This removes the client from all channels as well. */
995 if (packet->dst_id_type == SILC_ID_CLIENT && client->connection) {
996 sock = client->connection;
997 silc_server_free_client_data(server, NULL, client, FALSE, NULL);
998 silc_server_close_connection(server, sock);
1003 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1007 /* Send the notify to local clients on the channels except to the
1008 client who is killed. */
1009 silc_server_send_notify_on_channels(server, client, client,
1010 SILC_NOTIFY_TYPE_KILLED,
1015 /* Remove the client from all channels */
1016 silc_server_remove_from_channels(server, NULL, client, FALSE, NULL,
1022 case SILC_NOTIFY_TYPE_UMODE_CHANGE:
1024 * Save the mode of the client.
1027 SILC_LOG_DEBUG(("UMODE_CHANGE notify"));
1030 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1033 client_id = silc_id_payload_parse_id(tmp, tmp_len);
1037 /* Get client entry */
1038 client = silc_idlist_find_client_by_id(server->global_list,
1039 client_id, TRUE, NULL);
1041 client = silc_idlist_find_client_by_id(server->local_list,
1042 client_id, TRUE, NULL);
1044 silc_free(client_id);
1048 silc_free(client_id);
1051 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1056 SILC_GET32_MSB(client->mode, tmp);
1060 case SILC_NOTIFY_TYPE_BAN:
1065 SILC_LOG_DEBUG(("BAN notify"));
1067 /* Get Channel ID */
1068 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1071 channel_id = silc_id_payload_parse_id(tmp, tmp_len);
1075 /* Get channel entry */
1076 channel = silc_idlist_find_channel_by_id(server->global_list,
1079 channel = silc_idlist_find_channel_by_id(server->local_list,
1082 silc_free(channel_id);
1086 silc_free(channel_id);
1088 /* Get the new ban and add it to the ban list */
1089 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1091 if (!channel->ban_list)
1092 channel->ban_list = silc_calloc(tmp_len + 2,
1093 sizeof(*channel->ban_list));
1095 channel->ban_list = silc_realloc(channel->ban_list,
1096 sizeof(*channel->ban_list) *
1098 strlen(channel->ban_list) + 2));
1099 strncat(channel->ban_list, tmp, tmp_len);
1100 strncat(channel->ban_list, ",", 1);
1103 /* Get the ban to be removed and remove it from the list */
1104 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1105 if (tmp && channel->ban_list) {
1106 char *start, *end, *n;
1108 if (!strcmp(channel->ban_list, tmp)) {
1109 silc_free(channel->ban_list);
1110 channel->ban_list = NULL;
1112 start = strstr(channel->ban_list, tmp);
1113 if (start && strlen(start) >= tmp_len) {
1114 end = start + tmp_len;
1115 n = silc_calloc(strlen(channel->ban_list) - tmp_len, sizeof(*n));
1116 strncat(n, channel->ban_list, start - channel->ban_list);
1117 strncat(n, end + 1, ((channel->ban_list +
1118 strlen(channel->ban_list)) - end) - 1);
1119 silc_free(channel->ban_list);
1120 channel->ban_list = n;
1127 /* Ignore rest of the notify types for now */
1128 case SILC_NOTIFY_TYPE_NONE:
1129 case SILC_NOTIFY_TYPE_MOTD:
1136 silc_notify_payload_free(payload);
1139 void silc_server_notify_list(SilcServer server,
1140 SilcSocketConnection sock,
1141 SilcPacketContext *packet)
1143 SilcPacketContext *new;
1147 SILC_LOG_DEBUG(("Processing Notify List"));
1149 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
1150 packet->src_id_type != SILC_ID_SERVER)
1153 /* Make copy of the original packet context, except for the actual
1154 data buffer, which we will here now fetch from the original buffer. */
1155 new = silc_packet_context_alloc();
1156 new->type = SILC_PACKET_NOTIFY;
1157 new->flags = packet->flags;
1158 new->src_id = packet->src_id;
1159 new->src_id_len = packet->src_id_len;
1160 new->src_id_type = packet->src_id_type;
1161 new->dst_id = packet->dst_id;
1162 new->dst_id_len = packet->dst_id_len;
1163 new->dst_id_type = packet->dst_id_type;
1165 buffer = silc_buffer_alloc(1024);
1166 new->buffer = buffer;
1168 while (packet->buffer->len) {
1169 SILC_GET16_MSB(len, packet->buffer->data + 2);
1170 if (len > packet->buffer->len)
1173 if (len > buffer->truelen) {
1174 silc_buffer_free(buffer);
1175 buffer = silc_buffer_alloc(1024 + len);
1178 silc_buffer_pull_tail(buffer, len);
1179 silc_buffer_put(buffer, packet->buffer->data, len);
1181 /* Process the Notify */
1182 silc_server_notify(server, sock, new);
1184 silc_buffer_push_tail(buffer, len);
1185 silc_buffer_pull(packet->buffer, len);
1188 silc_buffer_free(buffer);
1192 /* Received private message. This resolves the destination of the message
1193 and sends the packet. This is used by both server and router. If the
1194 destination is our locally connected client this sends the packet to
1195 the client. This may also send the message for further routing if
1196 the destination is not in our server (or router). */
1198 void silc_server_private_message(SilcServer server,
1199 SilcSocketConnection sock,
1200 SilcPacketContext *packet)
1202 SilcSocketConnection dst_sock;
1203 SilcIDListData idata;
1205 SILC_LOG_DEBUG(("Start"));
1207 if (packet->src_id_type != SILC_ID_CLIENT ||
1208 packet->dst_id_type != SILC_ID_CLIENT || !packet->dst_id)
1211 /* Get the route to the client */
1212 dst_sock = silc_server_get_client_route(server, packet->dst_id,
1213 packet->dst_id_len, NULL, &idata);
1215 /* Send IDENTIFY command reply with error status to indicate that
1216 such destination ID does not exist or is invalid */
1217 SilcBuffer idp = silc_id_payload_encode_data(packet->dst_id,
1219 packet->dst_id_type);
1223 silc_server_send_command_reply(server, sock, SILC_COMMAND_IDENTIFY,
1224 SILC_STATUS_ERR_NO_SUCH_CLIENT_ID, 0, 1,
1226 silc_buffer_free(idp);
1230 /* Send the private message */
1231 silc_server_send_private_message(server, dst_sock, idata->send_key,
1232 idata->hmac_send, idata->psn_send++,
1236 /* Received private message key packet.. This packet is never for us. It is to
1237 the client in the packet's destination ID. Sending of this sort of packet
1238 equals sending private message, ie. it is sent point to point from
1239 one client to another. */
1241 void silc_server_private_message_key(SilcServer server,
1242 SilcSocketConnection sock,
1243 SilcPacketContext *packet)
1245 SilcSocketConnection dst_sock;
1246 SilcIDListData idata;
1248 SILC_LOG_DEBUG(("Start"));
1250 if (packet->src_id_type != SILC_ID_CLIENT ||
1251 packet->dst_id_type != SILC_ID_CLIENT)
1254 if (!packet->dst_id)
1257 /* Get the route to the client */
1258 dst_sock = silc_server_get_client_route(server, packet->dst_id,
1259 packet->dst_id_len, NULL, &idata);
1263 /* Relay the packet */
1264 silc_server_relay_packet(server, dst_sock, idata->send_key,
1265 idata->hmac_send, idata->psn_send++, packet, FALSE);
1268 /* Processes incoming command reply packet. The command reply packet may
1269 be destined to one of our clients or it may directly for us. We will
1270 call the command reply routine after processing the packet. */
1272 void silc_server_command_reply(SilcServer server,
1273 SilcSocketConnection sock,
1274 SilcPacketContext *packet)
1276 SilcBuffer buffer = packet->buffer;
1277 SilcClientEntry client = NULL;
1278 SilcSocketConnection dst_sock;
1279 SilcIDListData idata;
1280 SilcClientID *id = NULL;
1282 SILC_LOG_DEBUG(("Start"));
1284 /* Source must be server or router */
1285 if (packet->src_id_type != SILC_ID_SERVER &&
1286 sock->type != SILC_SOCKET_TYPE_ROUTER)
1289 if (packet->dst_id_type == SILC_ID_CHANNEL)
1292 if (packet->dst_id_type == SILC_ID_CLIENT) {
1293 /* Destination must be one of ours */
1294 id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CLIENT);
1297 client = silc_idlist_find_client_by_id(server->local_list, id, TRUE, NULL);
1299 SILC_LOG_ERROR(("Cannot process command reply to unknown client"));
1305 if (packet->dst_id_type == SILC_ID_SERVER) {
1306 /* For now this must be for us */
1307 if (memcmp(packet->dst_id, server->id_string, packet->dst_id_len)) {
1308 SILC_LOG_ERROR(("Cannot process command reply to unknown server"));
1313 /* Execute command reply locally for the command */
1314 silc_server_command_reply_process(server, sock, buffer);
1316 if (packet->dst_id_type == SILC_ID_CLIENT && client && id) {
1317 /* Relay the packet to the client */
1319 dst_sock = (SilcSocketConnection)client->connection;
1320 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1321 + packet->dst_id_len + packet->padlen);
1323 silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
1324 silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
1326 idata = (SilcIDListData)client;
1328 /* Encrypt packet */
1329 silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
1330 dst_sock->outbuf, buffer->len);
1332 /* Send the packet */
1333 silc_server_packet_send_real(server, dst_sock, TRUE);
1339 /* Process received channel message. The message can be originated from
1340 client or server. */
1342 void silc_server_channel_message(SilcServer server,
1343 SilcSocketConnection sock,
1344 SilcPacketContext *packet)
1346 SilcChannelEntry channel = NULL;
1347 SilcChannelID *id = NULL;
1348 void *sender = NULL;
1349 void *sender_entry = NULL;
1352 SILC_LOG_DEBUG(("Processing channel message"));
1355 if (packet->dst_id_type != SILC_ID_CHANNEL) {
1356 SILC_LOG_DEBUG(("Received bad message for channel, dropped"));
1360 /* Find channel entry */
1361 id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CHANNEL);
1364 channel = silc_idlist_find_channel_by_id(server->local_list, id, NULL);
1366 channel = silc_idlist_find_channel_by_id(server->global_list, id, NULL);
1368 SILC_LOG_DEBUG(("Could not find channel"));
1373 /* See that this client is on the channel. If the original sender is
1374 not client (as it can be server as well) we don't do the check. */
1375 sender = silc_id_str2id(packet->src_id, packet->src_id_len,
1376 packet->src_id_type);
1379 if (packet->src_id_type == SILC_ID_CLIENT) {
1380 sender_entry = silc_idlist_find_client_by_id(server->local_list,
1381 sender, TRUE, NULL);
1382 if (!sender_entry) {
1384 sender_entry = silc_idlist_find_client_by_id(server->global_list,
1385 sender, TRUE, NULL);
1387 if (!sender_entry || !silc_server_client_on_channel(sender_entry,
1389 SILC_LOG_DEBUG(("Client not on channel"));
1393 /* If the packet is coming from router, but the client entry is
1394 local entry to us then some router is rerouting this to us and it is
1396 if (server->server_type == SILC_ROUTER &&
1397 sock->type == SILC_SOCKET_TYPE_ROUTER && local) {
1398 SILC_LOG_DEBUG(("Channel message rerouted to the sender, drop it"));
1403 /* Distribute the packet to our local clients. This will send the
1404 packet for further routing as well, if needed. */
1405 silc_server_packet_relay_to_channel(server, sock, channel, sender,
1406 packet->src_id_type, sender_entry,
1407 packet->buffer->data,
1408 packet->buffer->len, FALSE);
1417 /* Received channel key packet. We distribute the key to all of our locally
1418 connected clients on the channel. */
1420 void silc_server_channel_key(SilcServer server,
1421 SilcSocketConnection sock,
1422 SilcPacketContext *packet)
1424 SilcBuffer buffer = packet->buffer;
1425 SilcChannelEntry channel;
1427 if (packet->src_id_type != SILC_ID_SERVER ||
1428 (server->server_type == SILC_ROUTER &&
1429 sock->type == SILC_SOCKET_TYPE_ROUTER))
1432 /* Save the channel key */
1433 channel = silc_server_save_channel_key(server, buffer, NULL);
1437 /* Distribute the key to everybody who is on the channel. If we are router
1438 we will also send it to locally connected servers. */
1439 silc_server_send_channel_key(server, sock, channel, FALSE);
1441 if (server->server_type != SILC_BACKUP_ROUTER) {
1442 /* Distribute to local cell backup routers. */
1443 silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
1444 SILC_PACKET_CHANNEL_KEY, 0,
1445 buffer->data, buffer->len, FALSE, TRUE);
1449 /* Received New Client packet and processes it. Creates Client ID for the
1450 client. Client becomes registered after calling this functions. */
1452 SilcClientEntry silc_server_new_client(SilcServer server,
1453 SilcSocketConnection sock,
1454 SilcPacketContext *packet)
1456 SilcBuffer buffer = packet->buffer;
1457 SilcClientEntry client;
1458 SilcClientID *client_id;
1460 SilcIDListData idata;
1461 char *username = NULL, *realname = NULL, *id_string;
1464 char *hostname, *nickname;
1467 SILC_LOG_DEBUG(("Creating new client"));
1469 if (sock->type != SILC_SOCKET_TYPE_CLIENT)
1472 /* Take client entry */
1473 client = (SilcClientEntry)sock->user_data;
1474 idata = (SilcIDListData)client;
1476 /* Remove the old cache entry. */
1477 if (!silc_idcache_del_by_context(server->local_list->clients, client)) {
1478 SILC_LOG_ERROR(("Lost client's cache entry - bad thing"));
1479 silc_server_disconnect_remote(server, sock, "Server closed connection: "
1484 /* Parse incoming packet */
1485 ret = silc_buffer_unformat(buffer,
1486 SILC_STR_UI16_STRING_ALLOC(&username),
1487 SILC_STR_UI16_STRING_ALLOC(&realname),
1491 silc_free(username);
1493 silc_free(realname);
1494 silc_server_disconnect_remote(server, sock, "Server closed connection: "
1495 "Incomplete client information");
1500 silc_free(username);
1502 silc_free(realname);
1503 silc_server_disconnect_remote(server, sock, "Server closed connection: "
1504 "Incomplete client information");
1508 if (strlen(username) > 128)
1509 username[127] = '\0';
1511 nickname = strdup(username);
1513 /* Make sanity checks for the hostname of the client. If the hostname
1514 is provided in the `username' check that it is the same than the
1515 resolved hostname, or if not resolved the hostname that appears in
1516 the client's public key. If the hostname is not present then put
1517 it from the resolved name or from the public key. */
1518 if (strchr(username, '@')) {
1519 SilcPublicKeyIdentifier pident;
1520 int tlen = strcspn(username, "@");
1521 char *phostname = NULL;
1523 hostname = silc_calloc((strlen(username) - tlen) + 1, sizeof(char));
1524 memcpy(hostname, username + tlen + 1, strlen(username) - tlen - 1);
1526 if (strcmp(sock->hostname, sock->ip) &&
1527 strcmp(sock->hostname, hostname)) {
1528 silc_free(username);
1529 silc_free(hostname);
1531 silc_free(realname);
1532 silc_server_disconnect_remote(server, sock,
1533 "Server closed connection: "
1534 "Incomplete client information");
1538 pident = silc_pkcs_decode_identifier(client->data.public_key->identifier);
1540 phostname = strdup(pident->host);
1541 silc_pkcs_free_identifier(pident);
1544 if (!strcmp(sock->hostname, sock->ip) &&
1545 phostname && strcmp(phostname, hostname)) {
1546 silc_free(username);
1547 silc_free(hostname);
1549 silc_free(phostname);
1551 silc_free(realname);
1552 silc_server_disconnect_remote(server, sock,
1553 "Server closed connection: "
1554 "Incomplete client information");
1559 silc_free(phostname);
1561 /* The hostname is not present, add it. */
1563 /* XXX For now we cannot take the host name from the public key since
1564 they are not trusted or we cannot verify them as trusted. Just take
1565 what the resolved name or address is. */
1567 if (strcmp(sock->hostname, sock->ip)) {
1569 newusername = silc_calloc(strlen(username) +
1570 strlen(sock->hostname) + 2,
1571 sizeof(*newusername));
1572 strncat(newusername, username, strlen(username));
1573 strncat(newusername, "@", 1);
1574 strncat(newusername, sock->hostname, strlen(sock->hostname));
1575 silc_free(username);
1576 username = newusername;
1579 SilcPublicKeyIdentifier pident =
1580 silc_pkcs_decode_identifier(client->data.public_key->identifier);
1583 newusername = silc_calloc(strlen(username) +
1584 strlen(pident->host) + 2,
1585 sizeof(*newusername));
1586 strncat(newusername, username, strlen(username));
1587 strncat(newusername, "@", 1);
1588 strncat(newusername, pident->host, strlen(pident->host));
1589 silc_free(username);
1590 username = newusername;
1591 silc_pkcs_free_identifier(pident);
1597 /* Create Client ID */
1598 while (!silc_id_create_client_id(server, server->id, server->rng,
1599 server->md5hash, nickname, &client_id)) {
1601 snprintf(&nickname[strlen(nickname) - 1], 1, "%d", nickfail);
1604 /* Update client entry */
1605 idata->status |= SILC_IDLIST_STATUS_REGISTERED;
1606 client->nickname = nickname;
1607 client->username = username;
1608 client->userinfo = realname ? realname : strdup(" ");
1609 client->id = client_id;
1610 id_len = silc_id_get_len(client_id, SILC_ID_CLIENT);
1612 /* Add the client again to the ID cache */
1613 silc_idcache_add(server->local_list->clients, client->nickname,
1614 client_id, client, FALSE);
1616 /* Notify our router about new client on the SILC network */
1617 if (!server->standalone)
1618 silc_server_send_new_id(server, (SilcSocketConnection)
1619 server->router->connection,
1620 server->server_type == SILC_ROUTER ? TRUE : FALSE,
1621 client->id, SILC_ID_CLIENT, id_len);
1623 /* Send the new client ID to the client. */
1624 id_string = silc_id_id2str(client->id, SILC_ID_CLIENT);
1625 reply = silc_buffer_alloc(2 + 2 + id_len);
1626 silc_buffer_pull_tail(reply, SILC_BUFFER_END(reply));
1627 silc_buffer_format(reply,
1628 SILC_STR_UI_SHORT(SILC_ID_CLIENT),
1629 SILC_STR_UI_SHORT(id_len),
1630 SILC_STR_UI_XNSTRING(id_string, id_len),
1632 silc_server_packet_send(server, sock, SILC_PACKET_NEW_ID, 0,
1633 reply->data, reply->len, FALSE);
1634 silc_free(id_string);
1635 silc_buffer_free(reply);
1637 /* Send some nice info to the client */
1638 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1639 ("Welcome to the SILC Network %s",
1641 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1642 ("Your host is %s, running version %s",
1643 server->config->server_info->server_name,
1645 if (server->server_type == SILC_ROUTER) {
1646 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1647 ("There are %d clients on %d servers in SILC "
1648 "Network", server->stat.clients,
1649 server->stat.servers + 1));
1650 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1651 ("There are %d clients on %d server in our cell",
1652 server->stat.cell_clients,
1653 server->stat.cell_servers + 1));
1654 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1655 ("I have %d clients, %d channels, %d servers and "
1657 server->stat.my_clients,
1658 server->stat.my_channels,
1659 server->stat.my_servers,
1660 server->stat.my_routers));
1661 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1662 ("%d server operators and %d router operators "
1664 server->stat.my_server_ops,
1665 server->stat.my_router_ops));
1667 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1668 ("I have %d clients and %d channels formed",
1669 server->stat.my_clients,
1670 server->stat.my_channels));
1671 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1672 ("%d operators online",
1673 server->stat.my_server_ops));
1675 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1676 ("Your connection is secured with %s cipher, "
1677 "key length %d bits",
1678 idata->send_key->cipher->name,
1679 idata->send_key->cipher->key_len));
1680 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1681 ("Your current nickname is %s",
1685 silc_server_send_motd(server, sock);
1690 /* Create new server. This processes received New Server packet and
1691 saves the received Server ID. The server is our locally connected
1692 server thus we save all the information and save it to local list.
1693 This funtion can be used by both normal server and router server.
1694 If normal server uses this it means that its router has connected
1695 to the server. If router uses this it means that one of the cell's
1696 servers is connected to the router. */
1698 SilcServerEntry silc_server_new_server(SilcServer server,
1699 SilcSocketConnection sock,
1700 SilcPacketContext *packet)
1702 SilcBuffer buffer = packet->buffer;
1703 SilcServerEntry new_server, server_entry;
1704 SilcServerID *server_id;
1705 SilcIDListData idata;
1706 unsigned char *server_name, *id_string;
1707 uint16 id_len, name_len;
1711 SILC_LOG_DEBUG(("Creating new server"));
1713 if (sock->type != SILC_SOCKET_TYPE_SERVER &&
1714 sock->type != SILC_SOCKET_TYPE_ROUTER)
1717 /* Take server entry */
1718 new_server = (SilcServerEntry)sock->user_data;
1719 idata = (SilcIDListData)new_server;
1721 /* Remove the old cache entry */
1722 if (!silc_idcache_del_by_context(server->local_list->servers, new_server)) {
1723 silc_idcache_del_by_context(server->global_list->servers, new_server);
1727 /* Parse the incoming packet */
1728 ret = silc_buffer_unformat(buffer,
1729 SILC_STR_UI16_NSTRING_ALLOC(&id_string, &id_len),
1730 SILC_STR_UI16_NSTRING_ALLOC(&server_name,
1735 silc_free(id_string);
1737 silc_free(server_name);
1741 if (id_len > buffer->len) {
1742 silc_free(id_string);
1743 silc_free(server_name);
1748 server_name[255] = '\0';
1751 server_id = silc_id_str2id(id_string, id_len, SILC_ID_SERVER);
1753 silc_free(id_string);
1754 silc_free(server_name);
1757 silc_free(id_string);
1759 /* Check that we do not have this ID already */
1760 server_entry = silc_idlist_find_server_by_id(server->local_list,
1761 server_id, TRUE, NULL);
1763 silc_idcache_del_by_context(server->local_list->servers, server_entry);
1765 server_entry = silc_idlist_find_server_by_id(server->global_list,
1766 server_id, TRUE, NULL);
1768 silc_idcache_del_by_context(server->global_list->servers, server_entry);
1771 /* Update server entry */
1772 idata->status |= SILC_IDLIST_STATUS_REGISTERED;
1773 new_server->server_name = server_name;
1774 new_server->id = server_id;
1776 SILC_LOG_DEBUG(("New server id(%s)",
1777 silc_id_render(server_id, SILC_ID_SERVER)));
1779 /* Add again the entry to the ID cache. */
1780 silc_idcache_add(local ? server->local_list->servers :
1781 server->global_list->servers, server_name, server_id,
1784 /* Distribute the information about new server in the SILC network
1785 to our router. If we are normal server we won't send anything
1786 since this connection must be our router connection. */
1787 if (server->server_type == SILC_ROUTER && !server->standalone &&
1788 server->router->connection != sock)
1789 silc_server_send_new_id(server, server->router->connection,
1790 TRUE, new_server->id, SILC_ID_SERVER,
1791 silc_id_get_len(server_id, SILC_ID_SERVER));
1793 if (server->server_type == SILC_ROUTER)
1794 server->stat.cell_servers++;
1796 /* Check whether this router connection has been replaced by an
1797 backup router. If it has been then we'll disable the server and will
1798 ignore everything it will send until the backup router resuming
1799 protocol has been completed. */
1800 if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
1801 silc_server_backup_replaced_get(server, server_id, NULL)) {
1802 /* Send packet to the server indicating that it cannot use this
1803 connection as it has been replaced by backup router. */
1804 SilcBuffer packet = silc_buffer_alloc(2);
1805 silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1806 silc_buffer_format(packet,
1807 SILC_STR_UI_CHAR(SILC_SERVER_BACKUP_REPLACED),
1808 SILC_STR_UI_CHAR(0),
1810 silc_server_packet_send(server, sock,
1811 SILC_PACKET_RESUME_ROUTER, 0,
1812 packet->data, packet->len, TRUE);
1813 silc_buffer_free(packet);
1815 /* Mark the router disabled. The data sent earlier will go but nothing
1816 after this does not go to this connection. */
1817 idata->status |= SILC_IDLIST_STATUS_DISABLED;
1819 /* If it is router announce our stuff to it. */
1820 if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
1821 server->server_type == SILC_ROUTER) {
1822 silc_server_announce_servers(server, FALSE, 0, sock);
1823 silc_server_announce_clients(server, 0, sock);
1824 silc_server_announce_channels(server, 0, sock);
1831 /* Processes incoming New ID packet. New ID Payload is used to distribute
1832 information about newly registered clients and servers. */
1834 static void silc_server_new_id_real(SilcServer server,
1835 SilcSocketConnection sock,
1836 SilcPacketContext *packet,
1839 SilcBuffer buffer = packet->buffer;
1841 SilcServerEntry router, server_entry;
1842 SilcSocketConnection router_sock;
1847 SILC_LOG_DEBUG(("Processing new ID"));
1849 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
1850 server->server_type == SILC_SERVER ||
1851 packet->src_id_type != SILC_ID_SERVER)
1854 idp = silc_id_payload_parse(buffer->data, buffer->len);
1858 id_type = silc_id_payload_get_type(idp);
1860 /* Normal server cannot have other normal server connections */
1861 server_entry = (SilcServerEntry)sock->user_data;
1862 if (id_type == SILC_ID_SERVER && sock->type == SILC_SOCKET_TYPE_SERVER &&
1863 server_entry->server_type == SILC_SERVER)
1866 id = silc_id_payload_get_id(idp);
1870 /* If the packet is coming from server then use the sender as the
1871 origin of the the packet. If it came from router then check the real
1872 sender of the packet and use that as the origin. */
1873 if (sock->type == SILC_SOCKET_TYPE_SERVER) {
1874 id_list = server->local_list;
1876 router = sock->user_data;
1878 /* If the sender is backup router and ID is server (and we are not
1879 backup router) then switch the entry to global list. */
1880 if (server_entry->server_type == SILC_BACKUP_ROUTER &&
1881 id_type == SILC_ID_SERVER &&
1882 server->id_entry->server_type != SILC_BACKUP_ROUTER) {
1883 id_list = server->global_list;
1884 router_sock = server->router ? server->router->connection : sock;
1887 void *sender_id = silc_id_str2id(packet->src_id, packet->src_id_len,
1888 packet->src_id_type);
1889 router = silc_idlist_find_server_by_id(server->global_list,
1890 sender_id, TRUE, NULL);
1892 router = silc_idlist_find_server_by_id(server->local_list,
1893 sender_id, TRUE, NULL);
1894 silc_free(sender_id);
1898 id_list = server->global_list;
1902 case SILC_ID_CLIENT:
1904 SilcClientEntry entry;
1906 /* Check that we do not have this client already */
1907 entry = silc_idlist_find_client_by_id(server->global_list,
1908 id, server->server_type,
1911 entry = silc_idlist_find_client_by_id(server->local_list,
1912 id, server->server_type,
1915 SILC_LOG_DEBUG(("Ignoring client that we already have"));
1919 SILC_LOG_DEBUG(("New client id(%s) from [%s] %s",
1920 silc_id_render(id, SILC_ID_CLIENT),
1921 sock->type == SILC_SOCKET_TYPE_SERVER ?
1922 "Server" : "Router", sock->hostname));
1924 /* As a router we keep information of all global information in our
1925 global list. Cell wide information however is kept in the local
1927 entry = silc_idlist_add_client(id_list, NULL, NULL, NULL,
1930 SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
1932 /* Inform the sender that the ID is not usable */
1933 silc_server_send_notify_signoff(server, sock, FALSE, id, NULL);
1936 entry->nickname = NULL;
1937 entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
1939 if (sock->type == SILC_SOCKET_TYPE_SERVER)
1940 server->stat.cell_clients++;
1941 server->stat.clients++;
1945 case SILC_ID_SERVER:
1947 SilcServerEntry entry;
1949 /* If the ID is mine, ignore it. */
1950 if (SILC_ID_SERVER_COMPARE(id, server->id)) {
1951 SILC_LOG_DEBUG(("Ignoring my own ID as new ID"));
1955 /* If the ID is the sender's ID, ignore it (we have it already) */
1956 if (SILC_ID_SERVER_COMPARE(id, router->id)) {
1957 SILC_LOG_DEBUG(("Ignoring sender's own ID"));
1961 /* Check that we do not have this server already */
1962 entry = silc_idlist_find_server_by_id(server->global_list,
1963 id, server->server_type,
1966 entry = silc_idlist_find_server_by_id(server->local_list,
1967 id, server->server_type,
1970 SILC_LOG_DEBUG(("Ignoring server that we already have"));
1974 SILC_LOG_DEBUG(("New server id(%s) from [%s] %s",
1975 silc_id_render(id, SILC_ID_SERVER),
1976 sock->type == SILC_SOCKET_TYPE_SERVER ?
1977 "Server" : "Router", sock->hostname));
1979 /* As a router we keep information of all global information in our
1980 global list. Cell wide information however is kept in the local
1982 entry = silc_idlist_add_server(id_list, NULL, 0, id, router,
1985 SILC_LOG_ERROR(("Could not add new server to the ID Cache"));
1988 entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
1990 if (sock->type == SILC_SOCKET_TYPE_SERVER)
1991 server->stat.cell_servers++;
1992 server->stat.servers++;
1996 case SILC_ID_CHANNEL:
1997 SILC_LOG_ERROR(("Channel cannot be registered with NEW_ID packet"));
2006 /* If the sender of this packet is server and we are router we need to
2007 broadcast this packet to other routers in the network. */
2008 if (broadcast && !server->standalone && server->server_type == SILC_ROUTER &&
2009 sock->type == SILC_SOCKET_TYPE_SERVER &&
2010 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2011 SILC_LOG_DEBUG(("Broadcasting received New ID packet"));
2012 silc_server_packet_send(server, server->router->connection,
2014 packet->flags | SILC_PACKET_FLAG_BROADCAST,
2015 buffer->data, buffer->len, FALSE);
2016 silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
2017 packet->type, packet->flags,
2018 packet->buffer->data, packet->buffer->len,
2023 silc_id_payload_free(idp);
2027 /* Processes incoming New ID packet. New ID Payload is used to distribute
2028 information about newly registered clients and servers. */
2030 void silc_server_new_id(SilcServer server, SilcSocketConnection sock,
2031 SilcPacketContext *packet)
2033 silc_server_new_id_real(server, sock, packet, TRUE);
2036 /* Receoved New Id List packet, list of New ID payloads inside one
2037 packet. Process the New ID payloads one by one. */
2039 void silc_server_new_id_list(SilcServer server, SilcSocketConnection sock,
2040 SilcPacketContext *packet)
2042 SilcPacketContext *new_id;
2046 SILC_LOG_DEBUG(("Processing New ID List"));
2048 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2049 packet->src_id_type != SILC_ID_SERVER)
2052 /* If the sender of this packet is server and we are router we need to
2053 broadcast this packet to other routers in the network. Broadcast
2054 this list packet instead of multiple New ID packets. */
2055 if (!server->standalone && server->server_type == SILC_ROUTER &&
2056 sock->type == SILC_SOCKET_TYPE_SERVER &&
2057 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2058 SILC_LOG_DEBUG(("Broadcasting received New ID List packet"));
2059 silc_server_packet_send(server, server->router->connection,
2061 packet->flags | SILC_PACKET_FLAG_BROADCAST,
2062 packet->buffer->data, packet->buffer->len, FALSE);
2063 silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
2064 packet->type, packet->flags,
2065 packet->buffer->data, packet->buffer->len,
2069 /* Make copy of the original packet context, except for the actual
2070 data buffer, which we will here now fetch from the original buffer. */
2071 new_id = silc_packet_context_alloc();
2072 new_id->type = SILC_PACKET_NEW_ID;
2073 new_id->flags = packet->flags;
2074 new_id->src_id = packet->src_id;
2075 new_id->src_id_len = packet->src_id_len;
2076 new_id->src_id_type = packet->src_id_type;
2077 new_id->dst_id = packet->dst_id;
2078 new_id->dst_id_len = packet->dst_id_len;
2079 new_id->dst_id_type = packet->dst_id_type;
2081 idp = silc_buffer_alloc(256);
2082 new_id->buffer = idp;
2084 while (packet->buffer->len) {
2085 SILC_GET16_MSB(id_len, packet->buffer->data + 2);
2086 if ((id_len > packet->buffer->len) ||
2087 (id_len > idp->truelen))
2090 silc_buffer_pull_tail(idp, 4 + id_len);
2091 silc_buffer_put(idp, packet->buffer->data, 4 + id_len);
2093 /* Process the New ID */
2094 silc_server_new_id_real(server, sock, new_id, FALSE);
2096 silc_buffer_push_tail(idp, 4 + id_len);
2097 silc_buffer_pull(packet->buffer, 4 + id_len);
2100 silc_buffer_free(idp);
2104 /* Received New Channel packet. Information about new channels in the
2105 network are distributed using this packet. Save the information about
2106 the new channel. This usually comes from router but also normal server
2107 can send this to notify channels it has when it connects to us. */
2109 void silc_server_new_channel(SilcServer server,
2110 SilcSocketConnection sock,
2111 SilcPacketContext *packet)
2113 SilcChannelPayload payload;
2114 SilcChannelID *channel_id;
2120 SilcServerEntry server_entry;
2121 SilcChannelEntry channel;
2123 SILC_LOG_DEBUG(("Processing New Channel"));
2125 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2126 packet->src_id_type != SILC_ID_SERVER ||
2127 server->server_type == SILC_SERVER)
2130 /* Parse the channel payload */
2131 payload = silc_channel_payload_parse(packet->buffer->data,
2132 packet->buffer->len);
2136 /* Get the channel ID */
2137 channel_id = silc_channel_get_id_parse(payload);
2139 silc_channel_payload_free(payload);
2143 channel_name = silc_channel_get_name(payload, &name_len);
2145 channel_name[255] = '\0';
2147 id = silc_channel_get_id(payload, &id_len);
2149 server_entry = (SilcServerEntry)sock->user_data;
2151 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
2152 /* Add the channel to global list as it is coming from router. It
2153 cannot be our own channel as it is coming from router. */
2155 /* Check that we don't already have this channel */
2156 channel = silc_idlist_find_channel_by_name(server->local_list,
2157 channel_name, NULL);
2159 channel = silc_idlist_find_channel_by_name(server->global_list,
2160 channel_name, NULL);
2162 SILC_LOG_DEBUG(("New channel id(%s) from [Router] %s",
2163 silc_id_render(channel_id, SILC_ID_CHANNEL),
2166 silc_idlist_add_channel(server->global_list, strdup(channel_name),
2167 0, channel_id, sock->user_data, NULL, NULL);
2168 server->stat.channels++;
2171 /* The channel is coming from our server, thus it is in our cell
2172 we will add it to our local list. */
2175 SILC_LOG_DEBUG(("Channel id(%s) from [Server] %s",
2176 silc_id_render(channel_id, SILC_ID_CHANNEL),
2179 /* Check that we don't already have this channel */
2180 channel = silc_idlist_find_channel_by_name(server->local_list,
2181 channel_name, NULL);
2183 channel = silc_idlist_find_channel_by_name(server->global_list,
2184 channel_name, NULL);
2186 /* If the channel does not exist, then create it. This creates a new
2187 key to the channel as well that we will send to the server. */
2189 /* The protocol says that the Channel ID's IP address must be based
2190 on the router's IP address. Check whether the ID is based in our
2191 IP and if it is not then create a new ID and enforce the server
2192 to switch the ID. */
2193 if (server_entry->server_type != SILC_BACKUP_ROUTER &&
2194 !SILC_ID_COMPARE(channel_id, server->id, server->id->ip.data_len)) {
2196 SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
2198 if (silc_id_create_channel_id(server, server->id, server->rng, &tmp)) {
2199 silc_server_send_notify_channel_change(server, sock, FALSE,
2201 silc_free(channel_id);
2206 /* Create the channel with the provided Channel ID */
2207 channel = silc_server_create_new_channel_with_id(server, NULL, NULL,
2211 silc_channel_payload_free(payload);
2212 silc_free(channel_id);
2216 /* Get the mode and set it to the channel */
2217 channel->mode = silc_channel_get_mode(payload);
2219 /* Send the new channel key to the server */
2220 chk = silc_channel_key_payload_encode(id_len, id,
2221 strlen(channel->channel_key->
2223 channel->channel_key->cipher->name,
2224 channel->key_len / 8,
2226 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
2227 chk->data, chk->len, FALSE);
2228 silc_buffer_free(chk);
2231 /* The channel exist by that name, check whether the ID's match.
2232 If they don't then we'll force the server to use the ID we have.
2233 We also create a new key for the channel. */
2234 SilcBuffer users = NULL, users_modes = NULL;
2236 if (!SILC_ID_CHANNEL_COMPARE(channel_id, channel->id)) {
2237 /* They don't match, send CHANNEL_CHANGE notify to the server to
2238 force the ID change. */
2239 SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
2240 silc_server_send_notify_channel_change(server, sock, FALSE,
2241 channel_id, channel->id);
2244 /* If the mode is different from what we have then enforce the
2246 mode = silc_channel_get_mode(payload);
2247 if (channel->mode != mode) {
2248 SILC_LOG_DEBUG(("Forcing the server to change channel mode"));
2249 silc_server_send_notify_cmode(server, sock, FALSE, channel,
2250 channel->mode, server->id,
2252 channel->cipher, channel->hmac_name,
2253 channel->passphrase);
2256 /* Create new key for the channel and send it to the server and
2257 everybody else possibly on the channel. */
2259 if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
2260 if (!silc_server_create_channel_key(server, channel, 0))
2263 /* Send to the channel */
2264 silc_server_send_channel_key(server, sock, channel, FALSE);
2265 id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
2266 id_len = SILC_ID_CHANNEL_LEN;
2268 /* Send to the server */
2269 chk = silc_channel_key_payload_encode(id_len, id,
2270 strlen(channel->channel_key->
2272 channel->channel_key->
2274 channel->key_len / 8,
2276 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
2277 chk->data, chk->len, FALSE);
2278 silc_buffer_free(chk);
2282 silc_free(channel_id);
2284 /* Since the channel is coming from server and we also know about it
2285 then send the JOIN notify to the server so that it see's our
2286 users on the channel "joining" the channel. */
2287 silc_server_announce_get_channel_users(server, channel, &users,
2290 silc_buffer_push(users, users->data - users->head);
2291 silc_server_packet_send(server, sock,
2292 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
2293 users->data, users->len, FALSE);
2294 silc_buffer_free(users);
2297 silc_buffer_push(users_modes, users_modes->data - users_modes->head);
2298 silc_server_packet_send_dest(server, sock,
2299 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
2300 channel->id, SILC_ID_CHANNEL,
2302 users_modes->len, FALSE);
2303 silc_buffer_free(users_modes);
2308 silc_channel_payload_free(payload);
2311 /* Received New Channel List packet, list of New Channel List payloads inside
2312 one packet. Process the New Channel payloads one by one. */
2314 void silc_server_new_channel_list(SilcServer server,
2315 SilcSocketConnection sock,
2316 SilcPacketContext *packet)
2318 SilcPacketContext *new;
2322 SILC_LOG_DEBUG(("Processing New Channel List"));
2324 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2325 packet->src_id_type != SILC_ID_SERVER ||
2326 server->server_type == SILC_SERVER)
2329 /* If the sender of this packet is server and we are router we need to
2330 broadcast this packet to other routers in the network. Broadcast
2331 this list packet instead of multiple New Channel packets. */
2332 if (!server->standalone && server->server_type == SILC_ROUTER &&
2333 sock->type == SILC_SOCKET_TYPE_SERVER &&
2334 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2335 SILC_LOG_DEBUG(("Broadcasting received New Channel List packet"));
2336 silc_server_packet_send(server, server->router->connection,
2338 packet->flags | SILC_PACKET_FLAG_BROADCAST,
2339 packet->buffer->data, packet->buffer->len, FALSE);
2340 silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
2341 packet->type, packet->flags,
2342 packet->buffer->data, packet->buffer->len,
2346 /* Make copy of the original packet context, except for the actual
2347 data buffer, which we will here now fetch from the original buffer. */
2348 new = silc_packet_context_alloc();
2349 new->type = SILC_PACKET_NEW_CHANNEL;
2350 new->flags = packet->flags;
2351 new->src_id = packet->src_id;
2352 new->src_id_len = packet->src_id_len;
2353 new->src_id_type = packet->src_id_type;
2354 new->dst_id = packet->dst_id;
2355 new->dst_id_len = packet->dst_id_len;
2356 new->dst_id_type = packet->dst_id_type;
2358 buffer = silc_buffer_alloc(512);
2359 new->buffer = buffer;
2361 while (packet->buffer->len) {
2362 SILC_GET16_MSB(len1, packet->buffer->data);
2363 if ((len1 > packet->buffer->len) ||
2364 (len1 > buffer->truelen))
2367 SILC_GET16_MSB(len2, packet->buffer->data + 2 + len1);
2368 if ((len2 > packet->buffer->len) ||
2369 (len2 > buffer->truelen))
2372 silc_buffer_pull_tail(buffer, 8 + len1 + len2);
2373 silc_buffer_put(buffer, packet->buffer->data, 8 + len1 + len2);
2375 /* Process the New Channel */
2376 silc_server_new_channel(server, sock, new);
2378 silc_buffer_push_tail(buffer, 8 + len1 + len2);
2379 silc_buffer_pull(packet->buffer, 8 + len1 + len2);
2382 silc_buffer_free(buffer);
2386 /* Received key agreement packet. This packet is never for us. It is to
2387 the client in the packet's destination ID. Sending of this sort of packet
2388 equals sending private message, ie. it is sent point to point from
2389 one client to another. */
2391 void silc_server_key_agreement(SilcServer server,
2392 SilcSocketConnection sock,
2393 SilcPacketContext *packet)
2395 SilcSocketConnection dst_sock;
2396 SilcIDListData idata;
2398 SILC_LOG_DEBUG(("Start"));
2400 if (packet->src_id_type != SILC_ID_CLIENT ||
2401 packet->dst_id_type != SILC_ID_CLIENT)
2404 if (!packet->dst_id)
2407 /* Get the route to the client */
2408 dst_sock = silc_server_get_client_route(server, packet->dst_id,
2409 packet->dst_id_len, NULL, &idata);
2413 /* Relay the packet */
2414 silc_server_relay_packet(server, dst_sock, idata->send_key,
2415 idata->hmac_send, idata->psn_send++,
2419 /* Received connection auth request packet that is used during connection
2420 phase to resolve the mandatory authentication method. This packet can
2421 actually be received at anytime but usually it is used only during
2422 the connection authentication phase. Now, protocol says that this packet
2423 can come from client or server, however, we support only this coming
2424 from client and expect that server always knows what authentication
2427 void silc_server_connection_auth_request(SilcServer server,
2428 SilcSocketConnection sock,
2429 SilcPacketContext *packet)
2431 SilcServerConfigSectionClientConnection *client = NULL;
2434 SilcAuthMethod auth_meth;
2436 SILC_LOG_DEBUG(("Start"));
2438 if (packet->src_id_type && packet->src_id_type != SILC_ID_CLIENT)
2441 /* Parse the payload */
2442 ret = silc_buffer_unformat(packet->buffer,
2443 SILC_STR_UI_SHORT(&conn_type),
2444 SILC_STR_UI_SHORT(NULL),
2449 if (conn_type != SILC_SOCKET_TYPE_CLIENT)
2452 /* Get the authentication method for the client */
2453 auth_meth = SILC_AUTH_NONE;
2454 port = server->sockets[server->sock]->port; /* Listenning port */
2455 client = silc_server_config_find_client_conn(server->config,
2459 client = silc_server_config_find_client_conn(server->config,
2463 auth_meth = client->auth_meth;
2465 /* Send it back to the client */
2466 silc_server_send_connection_auth_request(server, sock,
2471 /* Received REKEY packet. The sender of the packet wants to regenerate
2472 its session keys. This starts the REKEY protocol. */
2474 void silc_server_rekey(SilcServer server,
2475 SilcSocketConnection sock,
2476 SilcPacketContext *packet)
2478 SilcProtocol protocol;
2479 SilcServerRekeyInternalContext *proto_ctx;
2480 SilcIDListData idata = (SilcIDListData)sock->user_data;
2482 SILC_LOG_DEBUG(("Start"));
2484 /* Allocate internal protocol context. This is sent as context
2486 proto_ctx = silc_calloc(1, sizeof(*proto_ctx));
2487 proto_ctx->server = (void *)server;
2488 proto_ctx->sock = sock;
2489 proto_ctx->responder = TRUE;
2490 proto_ctx->pfs = idata->rekey->pfs;
2492 /* Perform rekey protocol. Will call the final callback after the
2493 protocol is over. */
2494 silc_protocol_alloc(SILC_PROTOCOL_SERVER_REKEY,
2495 &protocol, proto_ctx, silc_server_rekey_final);
2496 sock->protocol = protocol;
2498 if (proto_ctx->pfs == FALSE)
2499 /* Run the protocol */
2500 silc_protocol_execute(protocol, server->schedule, 0, 0);
2503 /* Received file transger packet. This packet is never for us. It is to
2504 the client in the packet's destination ID. Sending of this sort of packet
2505 equals sending private message, ie. it is sent point to point from
2506 one client to another. */
2508 void silc_server_ftp(SilcServer server,
2509 SilcSocketConnection sock,
2510 SilcPacketContext *packet)
2512 SilcSocketConnection dst_sock;
2513 SilcIDListData idata;
2515 SILC_LOG_DEBUG(("Start"));
2517 if (packet->src_id_type != SILC_ID_CLIENT ||
2518 packet->dst_id_type != SILC_ID_CLIENT)
2521 if (!packet->dst_id)
2524 /* Get the route to the client */
2525 dst_sock = silc_server_get_client_route(server, packet->dst_id,
2526 packet->dst_id_len, NULL, &idata);
2530 /* Relay the packet */
2531 silc_server_relay_packet(server, dst_sock, idata->send_key,
2532 idata->hmac_send, idata->psn_send++,