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, 0);
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 if (packet->src_id_type == SILC_ID_CLIENT) {
1224 SilcClientID *client_id = silc_id_str2id(packet->src_id,
1226 packet->src_id_type);
1227 silc_server_send_dest_command_reply(server, sock,
1228 client_id, SILC_ID_CLIENT,
1229 SILC_COMMAND_IDENTIFY,
1230 SILC_STATUS_ERR_NO_SUCH_CLIENT_ID,
1231 0, 1, 2, idp->data, idp->len);
1232 silc_free(client_id);
1234 silc_server_send_command_reply(server, sock, SILC_COMMAND_IDENTIFY,
1235 SILC_STATUS_ERR_NO_SUCH_CLIENT_ID,
1236 0, 1, 2, idp->data, idp->len);
1239 silc_buffer_free(idp);
1243 /* Send the private message */
1244 silc_server_send_private_message(server, dst_sock, idata->send_key,
1245 idata->hmac_send, idata->psn_send++,
1249 /* Received private message key packet.. This packet is never for us. It is to
1250 the client in the packet's destination ID. Sending of this sort of packet
1251 equals sending private message, ie. it is sent point to point from
1252 one client to another. */
1254 void silc_server_private_message_key(SilcServer server,
1255 SilcSocketConnection sock,
1256 SilcPacketContext *packet)
1258 SilcSocketConnection dst_sock;
1259 SilcIDListData idata;
1261 SILC_LOG_DEBUG(("Start"));
1263 if (packet->src_id_type != SILC_ID_CLIENT ||
1264 packet->dst_id_type != SILC_ID_CLIENT)
1267 if (!packet->dst_id)
1270 /* Get the route to the client */
1271 dst_sock = silc_server_get_client_route(server, packet->dst_id,
1272 packet->dst_id_len, NULL, &idata);
1276 /* Relay the packet */
1277 silc_server_relay_packet(server, dst_sock, idata->send_key,
1278 idata->hmac_send, idata->psn_send++, packet, FALSE);
1281 /* Processes incoming command reply packet. The command reply packet may
1282 be destined to one of our clients or it may directly for us. We will
1283 call the command reply routine after processing the packet. */
1285 void silc_server_command_reply(SilcServer server,
1286 SilcSocketConnection sock,
1287 SilcPacketContext *packet)
1289 SilcBuffer buffer = packet->buffer;
1290 SilcClientEntry client = NULL;
1291 SilcSocketConnection dst_sock;
1292 SilcIDListData idata;
1293 SilcClientID *id = NULL;
1295 SILC_LOG_DEBUG(("Start"));
1297 /* Source must be server or router */
1298 if (packet->src_id_type != SILC_ID_SERVER &&
1299 sock->type != SILC_SOCKET_TYPE_ROUTER)
1302 if (packet->dst_id_type == SILC_ID_CHANNEL)
1305 if (packet->dst_id_type == SILC_ID_CLIENT) {
1306 /* Destination must be one of ours */
1307 id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CLIENT);
1310 client = silc_idlist_find_client_by_id(server->local_list, id, TRUE, NULL);
1312 SILC_LOG_ERROR(("Cannot process command reply to unknown client"));
1318 if (packet->dst_id_type == SILC_ID_SERVER) {
1319 /* For now this must be for us */
1320 if (memcmp(packet->dst_id, server->id_string, packet->dst_id_len)) {
1321 SILC_LOG_ERROR(("Cannot process command reply to unknown server"));
1326 /* Execute command reply locally for the command */
1327 silc_server_command_reply_process(server, sock, buffer);
1329 if (packet->dst_id_type == SILC_ID_CLIENT && client && id) {
1330 /* Relay the packet to the client */
1332 dst_sock = (SilcSocketConnection)client->connection;
1333 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1334 + packet->dst_id_len + packet->padlen);
1336 silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
1337 silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
1339 idata = (SilcIDListData)client;
1341 /* Encrypt packet */
1342 silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
1343 dst_sock->outbuf, buffer->len);
1345 /* Send the packet */
1346 silc_server_packet_send_real(server, dst_sock, TRUE);
1352 /* Process received channel message. The message can be originated from
1353 client or server. */
1355 void silc_server_channel_message(SilcServer server,
1356 SilcSocketConnection sock,
1357 SilcPacketContext *packet)
1359 SilcChannelEntry channel = NULL;
1360 SilcChannelID *id = NULL;
1361 void *sender = NULL;
1362 void *sender_entry = NULL;
1365 SILC_LOG_DEBUG(("Processing channel message"));
1368 if (packet->dst_id_type != SILC_ID_CHANNEL) {
1369 SILC_LOG_DEBUG(("Received bad message for channel, dropped"));
1373 /* Find channel entry */
1374 id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CHANNEL);
1377 channel = silc_idlist_find_channel_by_id(server->local_list, id, NULL);
1379 channel = silc_idlist_find_channel_by_id(server->global_list, id, NULL);
1381 SILC_LOG_DEBUG(("Could not find channel"));
1386 /* See that this client is on the channel. If the original sender is
1387 not client (as it can be server as well) we don't do the check. */
1388 sender = silc_id_str2id(packet->src_id, packet->src_id_len,
1389 packet->src_id_type);
1392 if (packet->src_id_type == SILC_ID_CLIENT) {
1393 sender_entry = silc_idlist_find_client_by_id(server->local_list,
1394 sender, TRUE, NULL);
1395 if (!sender_entry) {
1397 sender_entry = silc_idlist_find_client_by_id(server->global_list,
1398 sender, TRUE, NULL);
1400 if (!sender_entry || !silc_server_client_on_channel(sender_entry,
1402 SILC_LOG_DEBUG(("Client not on channel"));
1406 /* If the packet is coming from router, but the client entry is
1407 local entry to us then some router is rerouting this to us and it is
1409 if (server->server_type == SILC_ROUTER &&
1410 sock->type == SILC_SOCKET_TYPE_ROUTER && local) {
1411 SILC_LOG_DEBUG(("Channel message rerouted to the sender, drop it"));
1416 /* Distribute the packet to our local clients. This will send the
1417 packet for further routing as well, if needed. */
1418 silc_server_packet_relay_to_channel(server, sock, channel, sender,
1419 packet->src_id_type, sender_entry,
1420 packet->buffer->data,
1421 packet->buffer->len, FALSE);
1430 /* Received channel key packet. We distribute the key to all of our locally
1431 connected clients on the channel. */
1433 void silc_server_channel_key(SilcServer server,
1434 SilcSocketConnection sock,
1435 SilcPacketContext *packet)
1437 SilcBuffer buffer = packet->buffer;
1438 SilcChannelEntry channel;
1440 if (packet->src_id_type != SILC_ID_SERVER ||
1441 (server->server_type == SILC_ROUTER &&
1442 sock->type == SILC_SOCKET_TYPE_ROUTER))
1445 /* Save the channel key */
1446 channel = silc_server_save_channel_key(server, buffer, NULL);
1450 /* Distribute the key to everybody who is on the channel. If we are router
1451 we will also send it to locally connected servers. */
1452 silc_server_send_channel_key(server, sock, channel, FALSE);
1454 if (server->server_type != SILC_BACKUP_ROUTER) {
1455 /* Distribute to local cell backup routers. */
1456 silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
1457 SILC_PACKET_CHANNEL_KEY, 0,
1458 buffer->data, buffer->len, FALSE, TRUE);
1462 /* Received New Client packet and processes it. Creates Client ID for the
1463 client. Client becomes registered after calling this functions. */
1465 SilcClientEntry silc_server_new_client(SilcServer server,
1466 SilcSocketConnection sock,
1467 SilcPacketContext *packet)
1469 SilcBuffer buffer = packet->buffer;
1470 SilcClientEntry client;
1471 SilcClientID *client_id;
1473 SilcIDListData idata;
1474 char *username = NULL, *realname = NULL, *id_string;
1477 char *hostname, *nickname;
1480 SILC_LOG_DEBUG(("Creating new client"));
1482 if (sock->type != SILC_SOCKET_TYPE_CLIENT)
1485 /* Take client entry */
1486 client = (SilcClientEntry)sock->user_data;
1487 idata = (SilcIDListData)client;
1489 /* Remove the old cache entry. */
1490 if (!silc_idcache_del_by_context(server->local_list->clients, client)) {
1491 SILC_LOG_ERROR(("Lost client's cache entry - bad thing"));
1492 silc_server_disconnect_remote(server, sock, "Server closed connection: "
1497 /* Parse incoming packet */
1498 ret = silc_buffer_unformat(buffer,
1499 SILC_STR_UI16_STRING_ALLOC(&username),
1500 SILC_STR_UI16_STRING_ALLOC(&realname),
1504 silc_free(username);
1506 silc_free(realname);
1507 silc_server_disconnect_remote(server, sock, "Server closed connection: "
1508 "Incomplete client information");
1513 silc_free(username);
1515 silc_free(realname);
1516 silc_server_disconnect_remote(server, sock, "Server closed connection: "
1517 "Incomplete client information");
1521 if (strlen(username) > 128)
1522 username[127] = '\0';
1524 nickname = strdup(username);
1526 /* Make sanity checks for the hostname of the client. If the hostname
1527 is provided in the `username' check that it is the same than the
1528 resolved hostname, or if not resolved the hostname that appears in
1529 the client's public key. If the hostname is not present then put
1530 it from the resolved name or from the public key. */
1531 if (strchr(username, '@')) {
1532 SilcPublicKeyIdentifier pident;
1533 int tlen = strcspn(username, "@");
1534 char *phostname = NULL;
1536 hostname = silc_calloc((strlen(username) - tlen) + 1, sizeof(char));
1537 memcpy(hostname, username + tlen + 1, strlen(username) - tlen - 1);
1539 if (strcmp(sock->hostname, sock->ip) &&
1540 strcmp(sock->hostname, hostname)) {
1541 silc_free(username);
1542 silc_free(hostname);
1544 silc_free(realname);
1545 silc_server_disconnect_remote(server, sock,
1546 "Server closed connection: "
1547 "Incomplete client information");
1551 pident = silc_pkcs_decode_identifier(client->data.public_key->identifier);
1553 phostname = strdup(pident->host);
1554 silc_pkcs_free_identifier(pident);
1557 if (!strcmp(sock->hostname, sock->ip) &&
1558 phostname && strcmp(phostname, hostname)) {
1559 silc_free(username);
1560 silc_free(hostname);
1562 silc_free(phostname);
1564 silc_free(realname);
1565 silc_server_disconnect_remote(server, sock,
1566 "Server closed connection: "
1567 "Incomplete client information");
1572 silc_free(phostname);
1574 /* The hostname is not present, add it. */
1576 /* XXX For now we cannot take the host name from the public key since
1577 they are not trusted or we cannot verify them as trusted. Just take
1578 what the resolved name or address is. */
1580 if (strcmp(sock->hostname, sock->ip)) {
1582 newusername = silc_calloc(strlen(username) +
1583 strlen(sock->hostname) + 2,
1584 sizeof(*newusername));
1585 strncat(newusername, username, strlen(username));
1586 strncat(newusername, "@", 1);
1587 strncat(newusername, sock->hostname, strlen(sock->hostname));
1588 silc_free(username);
1589 username = newusername;
1592 SilcPublicKeyIdentifier pident =
1593 silc_pkcs_decode_identifier(client->data.public_key->identifier);
1596 newusername = silc_calloc(strlen(username) +
1597 strlen(pident->host) + 2,
1598 sizeof(*newusername));
1599 strncat(newusername, username, strlen(username));
1600 strncat(newusername, "@", 1);
1601 strncat(newusername, pident->host, strlen(pident->host));
1602 silc_free(username);
1603 username = newusername;
1604 silc_pkcs_free_identifier(pident);
1610 /* Create Client ID */
1611 while (!silc_id_create_client_id(server, server->id, server->rng,
1612 server->md5hash, nickname, &client_id)) {
1614 snprintf(&nickname[strlen(nickname) - 1], 1, "%d", nickfail);
1617 /* Update client entry */
1618 idata->status |= SILC_IDLIST_STATUS_REGISTERED;
1619 client->nickname = nickname;
1620 client->username = username;
1621 client->userinfo = realname ? realname : strdup(" ");
1622 client->id = client_id;
1623 id_len = silc_id_get_len(client_id, SILC_ID_CLIENT);
1625 /* Add the client again to the ID cache */
1626 silc_idcache_add(server->local_list->clients, client->nickname,
1627 client_id, client, 0, NULL);
1629 /* Notify our router about new client on the SILC network */
1630 if (!server->standalone)
1631 silc_server_send_new_id(server, (SilcSocketConnection)
1632 server->router->connection,
1633 server->server_type == SILC_ROUTER ? TRUE : FALSE,
1634 client->id, SILC_ID_CLIENT, id_len);
1636 /* Send the new client ID to the client. */
1637 id_string = silc_id_id2str(client->id, SILC_ID_CLIENT);
1638 reply = silc_buffer_alloc(2 + 2 + id_len);
1639 silc_buffer_pull_tail(reply, SILC_BUFFER_END(reply));
1640 silc_buffer_format(reply,
1641 SILC_STR_UI_SHORT(SILC_ID_CLIENT),
1642 SILC_STR_UI_SHORT(id_len),
1643 SILC_STR_UI_XNSTRING(id_string, id_len),
1645 silc_server_packet_send(server, sock, SILC_PACKET_NEW_ID, 0,
1646 reply->data, reply->len, FALSE);
1647 silc_free(id_string);
1648 silc_buffer_free(reply);
1650 /* Send some nice info to the client */
1651 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1652 ("Welcome to the SILC Network %s",
1654 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1655 ("Your host is %s, running version %s",
1656 server->config->server_info->server_name,
1658 if (server->server_type == SILC_ROUTER) {
1659 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1660 ("There are %d clients on %d servers in SILC "
1661 "Network", server->stat.clients,
1662 server->stat.servers + 1));
1663 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1664 ("There are %d clients on %d server in our cell",
1665 server->stat.cell_clients,
1666 server->stat.cell_servers + 1));
1667 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1668 ("I have %d clients, %d channels, %d servers and "
1670 server->stat.my_clients,
1671 server->stat.my_channels,
1672 server->stat.my_servers,
1673 server->stat.my_routers));
1674 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1675 ("%d server operators and %d router operators "
1677 server->stat.my_server_ops,
1678 server->stat.my_router_ops));
1680 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1681 ("I have %d clients and %d channels formed",
1682 server->stat.my_clients,
1683 server->stat.my_channels));
1684 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1685 ("%d operators online",
1686 server->stat.my_server_ops));
1688 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1689 ("Your connection is secured with %s cipher, "
1690 "key length %d bits",
1691 idata->send_key->cipher->name,
1692 idata->send_key->cipher->key_len));
1693 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1694 ("Your current nickname is %s",
1698 silc_server_send_motd(server, sock);
1703 /* Create new server. This processes received New Server packet and
1704 saves the received Server ID. The server is our locally connected
1705 server thus we save all the information and save it to local list.
1706 This funtion can be used by both normal server and router server.
1707 If normal server uses this it means that its router has connected
1708 to the server. If router uses this it means that one of the cell's
1709 servers is connected to the router. */
1711 SilcServerEntry silc_server_new_server(SilcServer server,
1712 SilcSocketConnection sock,
1713 SilcPacketContext *packet)
1715 SilcBuffer buffer = packet->buffer;
1716 SilcServerEntry new_server, server_entry;
1717 SilcServerID *server_id;
1718 SilcIDListData idata;
1719 unsigned char *server_name, *id_string;
1720 uint16 id_len, name_len;
1724 SILC_LOG_DEBUG(("Creating new server"));
1726 if (sock->type != SILC_SOCKET_TYPE_SERVER &&
1727 sock->type != SILC_SOCKET_TYPE_ROUTER)
1730 /* Take server entry */
1731 new_server = (SilcServerEntry)sock->user_data;
1732 idata = (SilcIDListData)new_server;
1734 /* Remove the old cache entry */
1735 if (!silc_idcache_del_by_context(server->local_list->servers, new_server)) {
1736 silc_idcache_del_by_context(server->global_list->servers, new_server);
1740 /* Parse the incoming packet */
1741 ret = silc_buffer_unformat(buffer,
1742 SILC_STR_UI16_NSTRING_ALLOC(&id_string, &id_len),
1743 SILC_STR_UI16_NSTRING_ALLOC(&server_name,
1748 silc_free(id_string);
1750 silc_free(server_name);
1754 if (id_len > buffer->len) {
1755 silc_free(id_string);
1756 silc_free(server_name);
1761 server_name[255] = '\0';
1764 server_id = silc_id_str2id(id_string, id_len, SILC_ID_SERVER);
1766 silc_free(id_string);
1767 silc_free(server_name);
1770 silc_free(id_string);
1772 /* Check that we do not have this ID already */
1773 server_entry = silc_idlist_find_server_by_id(server->local_list,
1774 server_id, TRUE, NULL);
1776 silc_idcache_del_by_context(server->local_list->servers, server_entry);
1778 server_entry = silc_idlist_find_server_by_id(server->global_list,
1779 server_id, TRUE, NULL);
1781 silc_idcache_del_by_context(server->global_list->servers, server_entry);
1784 /* Update server entry */
1785 idata->status |= SILC_IDLIST_STATUS_REGISTERED;
1786 new_server->server_name = server_name;
1787 new_server->id = server_id;
1789 SILC_LOG_DEBUG(("New server id(%s)",
1790 silc_id_render(server_id, SILC_ID_SERVER)));
1792 /* Add again the entry to the ID cache. */
1793 silc_idcache_add(local ? server->local_list->servers :
1794 server->global_list->servers, server_name, server_id,
1795 new_server, 0, NULL);
1797 /* Distribute the information about new server in the SILC network
1798 to our router. If we are normal server we won't send anything
1799 since this connection must be our router connection. */
1800 if (server->server_type == SILC_ROUTER && !server->standalone &&
1801 server->router->connection != sock)
1802 silc_server_send_new_id(server, server->router->connection,
1803 TRUE, new_server->id, SILC_ID_SERVER,
1804 silc_id_get_len(server_id, SILC_ID_SERVER));
1806 if (server->server_type == SILC_ROUTER)
1807 server->stat.cell_servers++;
1809 /* Check whether this router connection has been replaced by an
1810 backup router. If it has been then we'll disable the server and will
1811 ignore everything it will send until the backup router resuming
1812 protocol has been completed. */
1813 if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
1814 silc_server_backup_replaced_get(server, server_id, NULL)) {
1815 /* Send packet to the server indicating that it cannot use this
1816 connection as it has been replaced by backup router. */
1817 SilcBuffer packet = silc_buffer_alloc(2);
1818 silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1819 silc_buffer_format(packet,
1820 SILC_STR_UI_CHAR(SILC_SERVER_BACKUP_REPLACED),
1821 SILC_STR_UI_CHAR(0),
1823 silc_server_packet_send(server, sock,
1824 SILC_PACKET_RESUME_ROUTER, 0,
1825 packet->data, packet->len, TRUE);
1826 silc_buffer_free(packet);
1828 /* Mark the router disabled. The data sent earlier will go but nothing
1829 after this does not go to this connection. */
1830 idata->status |= SILC_IDLIST_STATUS_DISABLED;
1832 /* If it is router announce our stuff to it. */
1833 if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
1834 server->server_type == SILC_ROUTER) {
1835 silc_server_announce_servers(server, FALSE, 0, sock);
1836 silc_server_announce_clients(server, 0, sock);
1837 silc_server_announce_channels(server, 0, sock);
1844 /* Processes incoming New ID packet. New ID Payload is used to distribute
1845 information about newly registered clients and servers. */
1847 static void silc_server_new_id_real(SilcServer server,
1848 SilcSocketConnection sock,
1849 SilcPacketContext *packet,
1852 SilcBuffer buffer = packet->buffer;
1854 SilcServerEntry router, server_entry;
1855 SilcSocketConnection router_sock;
1860 SILC_LOG_DEBUG(("Processing new ID"));
1862 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
1863 server->server_type == SILC_SERVER ||
1864 packet->src_id_type != SILC_ID_SERVER)
1867 idp = silc_id_payload_parse(buffer->data, buffer->len);
1871 id_type = silc_id_payload_get_type(idp);
1873 /* Normal server cannot have other normal server connections */
1874 server_entry = (SilcServerEntry)sock->user_data;
1875 if (id_type == SILC_ID_SERVER && sock->type == SILC_SOCKET_TYPE_SERVER &&
1876 server_entry->server_type == SILC_SERVER)
1879 id = silc_id_payload_get_id(idp);
1883 /* If the packet is coming from server then use the sender as the
1884 origin of the the packet. If it came from router then check the real
1885 sender of the packet and use that as the origin. */
1886 if (sock->type == SILC_SOCKET_TYPE_SERVER) {
1887 id_list = server->local_list;
1889 router = sock->user_data;
1891 /* If the sender is backup router and ID is server (and we are not
1892 backup router) then switch the entry to global list. */
1893 if (server_entry->server_type == SILC_BACKUP_ROUTER &&
1894 id_type == SILC_ID_SERVER &&
1895 server->id_entry->server_type != SILC_BACKUP_ROUTER) {
1896 id_list = server->global_list;
1897 router_sock = server->router ? server->router->connection : sock;
1900 void *sender_id = silc_id_str2id(packet->src_id, packet->src_id_len,
1901 packet->src_id_type);
1902 router = silc_idlist_find_server_by_id(server->global_list,
1903 sender_id, TRUE, NULL);
1905 router = silc_idlist_find_server_by_id(server->local_list,
1906 sender_id, TRUE, NULL);
1907 silc_free(sender_id);
1911 id_list = server->global_list;
1915 case SILC_ID_CLIENT:
1917 SilcClientEntry entry;
1919 /* Check that we do not have this client already */
1920 entry = silc_idlist_find_client_by_id(server->global_list,
1921 id, server->server_type,
1924 entry = silc_idlist_find_client_by_id(server->local_list,
1925 id, server->server_type,
1928 SILC_LOG_DEBUG(("Ignoring client that we already have"));
1932 SILC_LOG_DEBUG(("New client id(%s) from [%s] %s",
1933 silc_id_render(id, SILC_ID_CLIENT),
1934 sock->type == SILC_SOCKET_TYPE_SERVER ?
1935 "Server" : "Router", sock->hostname));
1937 /* As a router we keep information of all global information in our
1938 global list. Cell wide information however is kept in the local
1940 entry = silc_idlist_add_client(id_list, NULL, NULL, NULL,
1941 id, router, NULL, 0);
1943 SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
1945 /* Inform the sender that the ID is not usable */
1946 silc_server_send_notify_signoff(server, sock, FALSE, id, NULL);
1949 entry->nickname = NULL;
1950 entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
1952 if (sock->type == SILC_SOCKET_TYPE_SERVER)
1953 server->stat.cell_clients++;
1954 server->stat.clients++;
1958 case SILC_ID_SERVER:
1960 SilcServerEntry entry;
1962 /* If the ID is mine, ignore it. */
1963 if (SILC_ID_SERVER_COMPARE(id, server->id)) {
1964 SILC_LOG_DEBUG(("Ignoring my own ID as new ID"));
1968 /* If the ID is the sender's ID, ignore it (we have it already) */
1969 if (SILC_ID_SERVER_COMPARE(id, router->id)) {
1970 SILC_LOG_DEBUG(("Ignoring sender's own ID"));
1974 /* Check that we do not have this server already */
1975 entry = silc_idlist_find_server_by_id(server->global_list,
1976 id, server->server_type,
1979 entry = silc_idlist_find_server_by_id(server->local_list,
1980 id, server->server_type,
1983 SILC_LOG_DEBUG(("Ignoring server that we already have"));
1987 SILC_LOG_DEBUG(("New server id(%s) from [%s] %s",
1988 silc_id_render(id, SILC_ID_SERVER),
1989 sock->type == SILC_SOCKET_TYPE_SERVER ?
1990 "Server" : "Router", sock->hostname));
1992 /* As a router we keep information of all global information in our
1993 global list. Cell wide information however is kept in the local
1995 entry = silc_idlist_add_server(id_list, NULL, 0, id, router,
1998 SILC_LOG_ERROR(("Could not add new server to the ID Cache"));
2001 entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
2003 if (sock->type == SILC_SOCKET_TYPE_SERVER)
2004 server->stat.cell_servers++;
2005 server->stat.servers++;
2009 case SILC_ID_CHANNEL:
2010 SILC_LOG_ERROR(("Channel cannot be registered with NEW_ID packet"));
2019 /* If the sender of this packet is server and we are router we need to
2020 broadcast this packet to other routers in the network. */
2021 if (broadcast && !server->standalone && server->server_type == SILC_ROUTER &&
2022 sock->type == SILC_SOCKET_TYPE_SERVER &&
2023 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2024 SILC_LOG_DEBUG(("Broadcasting received New ID packet"));
2025 silc_server_packet_send(server, server->router->connection,
2027 packet->flags | SILC_PACKET_FLAG_BROADCAST,
2028 buffer->data, buffer->len, FALSE);
2029 silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
2030 packet->type, packet->flags,
2031 packet->buffer->data, packet->buffer->len,
2036 silc_id_payload_free(idp);
2040 /* Processes incoming New ID packet. New ID Payload is used to distribute
2041 information about newly registered clients and servers. */
2043 void silc_server_new_id(SilcServer server, SilcSocketConnection sock,
2044 SilcPacketContext *packet)
2046 silc_server_new_id_real(server, sock, packet, TRUE);
2049 /* Receoved New Id List packet, list of New ID payloads inside one
2050 packet. Process the New ID payloads one by one. */
2052 void silc_server_new_id_list(SilcServer server, SilcSocketConnection sock,
2053 SilcPacketContext *packet)
2055 SilcPacketContext *new_id;
2059 SILC_LOG_DEBUG(("Processing New ID List"));
2061 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2062 packet->src_id_type != SILC_ID_SERVER)
2065 /* If the sender of this packet is server and we are router we need to
2066 broadcast this packet to other routers in the network. Broadcast
2067 this list packet instead of multiple New ID packets. */
2068 if (!server->standalone && server->server_type == SILC_ROUTER &&
2069 sock->type == SILC_SOCKET_TYPE_SERVER &&
2070 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2071 SILC_LOG_DEBUG(("Broadcasting received New ID List packet"));
2072 silc_server_packet_send(server, server->router->connection,
2074 packet->flags | SILC_PACKET_FLAG_BROADCAST,
2075 packet->buffer->data, packet->buffer->len, FALSE);
2076 silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
2077 packet->type, packet->flags,
2078 packet->buffer->data, packet->buffer->len,
2082 /* Make copy of the original packet context, except for the actual
2083 data buffer, which we will here now fetch from the original buffer. */
2084 new_id = silc_packet_context_alloc();
2085 new_id->type = SILC_PACKET_NEW_ID;
2086 new_id->flags = packet->flags;
2087 new_id->src_id = packet->src_id;
2088 new_id->src_id_len = packet->src_id_len;
2089 new_id->src_id_type = packet->src_id_type;
2090 new_id->dst_id = packet->dst_id;
2091 new_id->dst_id_len = packet->dst_id_len;
2092 new_id->dst_id_type = packet->dst_id_type;
2094 idp = silc_buffer_alloc(256);
2095 new_id->buffer = idp;
2097 while (packet->buffer->len) {
2098 SILC_GET16_MSB(id_len, packet->buffer->data + 2);
2099 if ((id_len > packet->buffer->len) ||
2100 (id_len > idp->truelen))
2103 silc_buffer_pull_tail(idp, 4 + id_len);
2104 silc_buffer_put(idp, packet->buffer->data, 4 + id_len);
2106 /* Process the New ID */
2107 silc_server_new_id_real(server, sock, new_id, FALSE);
2109 silc_buffer_push_tail(idp, 4 + id_len);
2110 silc_buffer_pull(packet->buffer, 4 + id_len);
2113 silc_buffer_free(idp);
2117 /* Received New Channel packet. Information about new channels in the
2118 network are distributed using this packet. Save the information about
2119 the new channel. This usually comes from router but also normal server
2120 can send this to notify channels it has when it connects to us. */
2122 void silc_server_new_channel(SilcServer server,
2123 SilcSocketConnection sock,
2124 SilcPacketContext *packet)
2126 SilcChannelPayload payload;
2127 SilcChannelID *channel_id;
2133 SilcServerEntry server_entry;
2134 SilcChannelEntry channel;
2136 SILC_LOG_DEBUG(("Processing New Channel"));
2138 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2139 packet->src_id_type != SILC_ID_SERVER ||
2140 server->server_type == SILC_SERVER)
2143 /* Parse the channel payload */
2144 payload = silc_channel_payload_parse(packet->buffer->data,
2145 packet->buffer->len);
2149 /* Get the channel ID */
2150 channel_id = silc_channel_get_id_parse(payload);
2152 silc_channel_payload_free(payload);
2156 channel_name = silc_channel_get_name(payload, &name_len);
2158 channel_name[255] = '\0';
2160 id = silc_channel_get_id(payload, &id_len);
2162 server_entry = (SilcServerEntry)sock->user_data;
2164 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
2165 /* Add the channel to global list as it is coming from router. It
2166 cannot be our own channel as it is coming from router. */
2168 /* Check that we don't already have this channel */
2169 channel = silc_idlist_find_channel_by_name(server->local_list,
2170 channel_name, NULL);
2172 channel = silc_idlist_find_channel_by_name(server->global_list,
2173 channel_name, NULL);
2175 SILC_LOG_DEBUG(("New channel id(%s) from [Router] %s",
2176 silc_id_render(channel_id, SILC_ID_CHANNEL),
2179 silc_idlist_add_channel(server->global_list, strdup(channel_name),
2180 0, channel_id, sock->user_data, NULL, NULL, 0);
2181 server->stat.channels++;
2184 /* The channel is coming from our server, thus it is in our cell
2185 we will add it to our local list. */
2188 SILC_LOG_DEBUG(("Channel id(%s) from [Server] %s",
2189 silc_id_render(channel_id, SILC_ID_CHANNEL),
2192 /* Check that we don't already have this channel */
2193 channel = silc_idlist_find_channel_by_name(server->local_list,
2194 channel_name, NULL);
2196 channel = silc_idlist_find_channel_by_name(server->global_list,
2197 channel_name, NULL);
2199 /* If the channel does not exist, then create it. This creates a new
2200 key to the channel as well that we will send to the server. */
2202 /* The protocol says that the Channel ID's IP address must be based
2203 on the router's IP address. Check whether the ID is based in our
2204 IP and if it is not then create a new ID and enforce the server
2205 to switch the ID. */
2206 if (server_entry->server_type != SILC_BACKUP_ROUTER &&
2207 !SILC_ID_COMPARE(channel_id, server->id, server->id->ip.data_len)) {
2209 SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
2211 if (silc_id_create_channel_id(server, server->id, server->rng, &tmp)) {
2212 silc_server_send_notify_channel_change(server, sock, FALSE,
2214 silc_free(channel_id);
2219 /* Create the channel with the provided Channel ID */
2220 channel = silc_server_create_new_channel_with_id(server, NULL, NULL,
2224 silc_channel_payload_free(payload);
2225 silc_free(channel_id);
2229 /* Get the mode and set it to the channel */
2230 channel->mode = silc_channel_get_mode(payload);
2232 /* Send the new channel key to the server */
2233 chk = silc_channel_key_payload_encode(id_len, id,
2234 strlen(channel->channel_key->
2236 channel->channel_key->cipher->name,
2237 channel->key_len / 8,
2239 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
2240 chk->data, chk->len, FALSE);
2241 silc_buffer_free(chk);
2244 /* The channel exist by that name, check whether the ID's match.
2245 If they don't then we'll force the server to use the ID we have.
2246 We also create a new key for the channel. */
2247 SilcBuffer users = NULL, users_modes = NULL;
2249 if (!SILC_ID_CHANNEL_COMPARE(channel_id, channel->id)) {
2250 /* They don't match, send CHANNEL_CHANGE notify to the server to
2251 force the ID change. */
2252 SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
2253 silc_server_send_notify_channel_change(server, sock, FALSE,
2254 channel_id, channel->id);
2257 /* If the mode is different from what we have then enforce the
2259 mode = silc_channel_get_mode(payload);
2260 if (channel->mode != mode) {
2261 SILC_LOG_DEBUG(("Forcing the server to change channel mode"));
2262 silc_server_send_notify_cmode(server, sock, FALSE, channel,
2263 channel->mode, server->id,
2265 channel->cipher, channel->hmac_name,
2266 channel->passphrase);
2269 /* Create new key for the channel and send it to the server and
2270 everybody else possibly on the channel. */
2272 if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
2273 if (!silc_server_create_channel_key(server, channel, 0))
2276 /* Send to the channel */
2277 silc_server_send_channel_key(server, sock, channel, FALSE);
2278 id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
2279 id_len = SILC_ID_CHANNEL_LEN;
2281 /* Send to the server */
2282 chk = silc_channel_key_payload_encode(id_len, id,
2283 strlen(channel->channel_key->
2285 channel->channel_key->
2287 channel->key_len / 8,
2289 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
2290 chk->data, chk->len, FALSE);
2291 silc_buffer_free(chk);
2295 silc_free(channel_id);
2297 /* Since the channel is coming from server and we also know about it
2298 then send the JOIN notify to the server so that it see's our
2299 users on the channel "joining" the channel. */
2300 silc_server_announce_get_channel_users(server, channel, &users,
2303 silc_buffer_push(users, users->data - users->head);
2304 silc_server_packet_send(server, sock,
2305 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
2306 users->data, users->len, FALSE);
2307 silc_buffer_free(users);
2310 silc_buffer_push(users_modes, users_modes->data - users_modes->head);
2311 silc_server_packet_send_dest(server, sock,
2312 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
2313 channel->id, SILC_ID_CHANNEL,
2315 users_modes->len, FALSE);
2316 silc_buffer_free(users_modes);
2321 silc_channel_payload_free(payload);
2324 /* Received New Channel List packet, list of New Channel List payloads inside
2325 one packet. Process the New Channel payloads one by one. */
2327 void silc_server_new_channel_list(SilcServer server,
2328 SilcSocketConnection sock,
2329 SilcPacketContext *packet)
2331 SilcPacketContext *new;
2335 SILC_LOG_DEBUG(("Processing New Channel List"));
2337 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2338 packet->src_id_type != SILC_ID_SERVER ||
2339 server->server_type == SILC_SERVER)
2342 /* If the sender of this packet is server and we are router we need to
2343 broadcast this packet to other routers in the network. Broadcast
2344 this list packet instead of multiple New Channel packets. */
2345 if (!server->standalone && server->server_type == SILC_ROUTER &&
2346 sock->type == SILC_SOCKET_TYPE_SERVER &&
2347 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2348 SILC_LOG_DEBUG(("Broadcasting received New Channel List packet"));
2349 silc_server_packet_send(server, server->router->connection,
2351 packet->flags | SILC_PACKET_FLAG_BROADCAST,
2352 packet->buffer->data, packet->buffer->len, FALSE);
2353 silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
2354 packet->type, packet->flags,
2355 packet->buffer->data, packet->buffer->len,
2359 /* Make copy of the original packet context, except for the actual
2360 data buffer, which we will here now fetch from the original buffer. */
2361 new = silc_packet_context_alloc();
2362 new->type = SILC_PACKET_NEW_CHANNEL;
2363 new->flags = packet->flags;
2364 new->src_id = packet->src_id;
2365 new->src_id_len = packet->src_id_len;
2366 new->src_id_type = packet->src_id_type;
2367 new->dst_id = packet->dst_id;
2368 new->dst_id_len = packet->dst_id_len;
2369 new->dst_id_type = packet->dst_id_type;
2371 buffer = silc_buffer_alloc(512);
2372 new->buffer = buffer;
2374 while (packet->buffer->len) {
2375 SILC_GET16_MSB(len1, packet->buffer->data);
2376 if ((len1 > packet->buffer->len) ||
2377 (len1 > buffer->truelen))
2380 SILC_GET16_MSB(len2, packet->buffer->data + 2 + len1);
2381 if ((len2 > packet->buffer->len) ||
2382 (len2 > buffer->truelen))
2385 silc_buffer_pull_tail(buffer, 8 + len1 + len2);
2386 silc_buffer_put(buffer, packet->buffer->data, 8 + len1 + len2);
2388 /* Process the New Channel */
2389 silc_server_new_channel(server, sock, new);
2391 silc_buffer_push_tail(buffer, 8 + len1 + len2);
2392 silc_buffer_pull(packet->buffer, 8 + len1 + len2);
2395 silc_buffer_free(buffer);
2399 /* Received key agreement packet. This packet is never for us. It is to
2400 the client in the packet's destination ID. Sending of this sort of packet
2401 equals sending private message, ie. it is sent point to point from
2402 one client to another. */
2404 void silc_server_key_agreement(SilcServer server,
2405 SilcSocketConnection sock,
2406 SilcPacketContext *packet)
2408 SilcSocketConnection dst_sock;
2409 SilcIDListData idata;
2411 SILC_LOG_DEBUG(("Start"));
2413 if (packet->src_id_type != SILC_ID_CLIENT ||
2414 packet->dst_id_type != SILC_ID_CLIENT)
2417 if (!packet->dst_id)
2420 /* Get the route to the client */
2421 dst_sock = silc_server_get_client_route(server, packet->dst_id,
2422 packet->dst_id_len, NULL, &idata);
2426 /* Relay the packet */
2427 silc_server_relay_packet(server, dst_sock, idata->send_key,
2428 idata->hmac_send, idata->psn_send++,
2432 /* Received connection auth request packet that is used during connection
2433 phase to resolve the mandatory authentication method. This packet can
2434 actually be received at anytime but usually it is used only during
2435 the connection authentication phase. Now, protocol says that this packet
2436 can come from client or server, however, we support only this coming
2437 from client and expect that server always knows what authentication
2440 void silc_server_connection_auth_request(SilcServer server,
2441 SilcSocketConnection sock,
2442 SilcPacketContext *packet)
2444 SilcServerConfigSectionClientConnection *client = NULL;
2447 SilcAuthMethod auth_meth;
2449 SILC_LOG_DEBUG(("Start"));
2451 if (packet->src_id_type && packet->src_id_type != SILC_ID_CLIENT)
2454 /* Parse the payload */
2455 ret = silc_buffer_unformat(packet->buffer,
2456 SILC_STR_UI_SHORT(&conn_type),
2457 SILC_STR_UI_SHORT(NULL),
2462 if (conn_type != SILC_SOCKET_TYPE_CLIENT)
2465 /* Get the authentication method for the client */
2466 auth_meth = SILC_AUTH_NONE;
2467 port = server->sockets[server->sock]->port; /* Listenning port */
2468 client = silc_server_config_find_client_conn(server->config,
2472 client = silc_server_config_find_client_conn(server->config,
2476 auth_meth = client->auth_meth;
2478 /* Send it back to the client */
2479 silc_server_send_connection_auth_request(server, sock,
2484 /* Received REKEY packet. The sender of the packet wants to regenerate
2485 its session keys. This starts the REKEY protocol. */
2487 void silc_server_rekey(SilcServer server,
2488 SilcSocketConnection sock,
2489 SilcPacketContext *packet)
2491 SilcProtocol protocol;
2492 SilcServerRekeyInternalContext *proto_ctx;
2493 SilcIDListData idata = (SilcIDListData)sock->user_data;
2495 SILC_LOG_DEBUG(("Start"));
2497 /* Allocate internal protocol context. This is sent as context
2499 proto_ctx = silc_calloc(1, sizeof(*proto_ctx));
2500 proto_ctx->server = (void *)server;
2501 proto_ctx->sock = sock;
2502 proto_ctx->responder = TRUE;
2503 proto_ctx->pfs = idata->rekey->pfs;
2505 /* Perform rekey protocol. Will call the final callback after the
2506 protocol is over. */
2507 silc_protocol_alloc(SILC_PROTOCOL_SERVER_REKEY,
2508 &protocol, proto_ctx, silc_server_rekey_final);
2509 sock->protocol = protocol;
2511 if (proto_ctx->pfs == FALSE)
2512 /* Run the protocol */
2513 silc_protocol_execute(protocol, server->schedule, 0, 0);
2516 /* Received file transger packet. This packet is never for us. It is to
2517 the client in the packet's destination ID. Sending of this sort of packet
2518 equals sending private message, ie. it is sent point to point from
2519 one client to another. */
2521 void silc_server_ftp(SilcServer server,
2522 SilcSocketConnection sock,
2523 SilcPacketContext *packet)
2525 SilcSocketConnection dst_sock;
2526 SilcIDListData idata;
2528 SILC_LOG_DEBUG(("Start"));
2530 if (packet->src_id_type != SILC_ID_CLIENT ||
2531 packet->dst_id_type != SILC_ID_CLIENT)
2534 if (!packet->dst_id)
2537 /* Get the route to the client */
2538 dst_sock = silc_server_get_client_route(server, packet->dst_id,
2539 packet->dst_id_len, NULL, &idata);
2543 /* Relay the packet */
2544 silc_server_relay_packet(server, dst_sock, idata->send_key,
2545 idata->hmac_send, idata->psn_send++,