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;
41 SilcClientID *client_id, *client_id2;
42 SilcChannelEntry channel;
43 SilcClientEntry client;
44 SilcChannelClientEntry chl;
49 SILC_LOG_DEBUG(("Start"));
51 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
52 packet->src_id_type != SILC_ID_SERVER)
55 /* If we are router and this packet is not already broadcast packet
56 we will broadcast it. The sending socket really cannot be router or
57 the router is buggy. If this packet is coming from router then it must
58 have the broadcast flag set already and we won't do anything. */
59 if (!server->standalone && server->server_type == SILC_ROUTER &&
60 sock->type == SILC_SOCKET_TYPE_SERVER &&
61 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
62 SILC_LOG_DEBUG(("Broadcasting received Notify packet"));
63 silc_server_packet_send(server, server->router->connection, packet->type,
64 packet->flags | SILC_PACKET_FLAG_BROADCAST,
65 packet->buffer->data, packet->buffer->len, FALSE);
68 payload = silc_notify_payload_parse(packet->buffer);
72 type = silc_notify_get_type(payload);
73 args = silc_notify_get_args(payload);
78 case SILC_NOTIFY_TYPE_JOIN:
80 * Distribute the notify to local clients on the channel
82 SILC_LOG_DEBUG(("JOIN notify"));
85 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
88 channel_id = silc_id_payload_parse_id(tmp, tmp_len);
92 /* Get channel entry */
93 channel = silc_idlist_find_channel_by_id(server->local_list,
96 channel = silc_idlist_find_channel_by_id(server->global_list,
99 silc_free(channel_id);
103 silc_free(channel_id);
106 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
109 client_id = silc_id_payload_parse_id(tmp, tmp_len);
113 /* Send to channel */
114 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
115 FALSE, packet->buffer->data,
116 packet->buffer->len, FALSE);
118 /* If the the client is not in local list we check global list (ie. the
119 channel will be global channel) and if it does not exist then create
120 entry for the client. */
121 client = silc_idlist_find_client_by_id(server->local_list,
124 client = silc_idlist_find_client_by_id(server->global_list,
127 /* If router did not find the client the it is bogus */
128 if (server->server_type == SILC_ROUTER)
132 silc_idlist_add_client(server->global_list, NULL, NULL, NULL,
133 silc_id_dup(client_id, SILC_ID_CLIENT),
134 sock->user_data, NULL);
136 silc_free(client_id);
142 /* Do not add client to channel if it is there already */
143 if (silc_server_client_on_channel(client, channel))
146 if (server->server_type == SILC_SERVER &&
147 sock->type == SILC_SOCKET_TYPE_ROUTER)
148 /* The channel is global now */
149 channel->global_users = TRUE;
151 /* JOIN the global client to the channel (local clients (if router
152 created the channel) is joined in the pending JOIN command). */
153 chl = silc_calloc(1, sizeof(*chl));
154 chl->client = client;
155 chl->channel = channel;
156 silc_list_add(channel->user_list, chl);
157 silc_list_add(client->channels, chl);
158 silc_free(client_id);
162 case SILC_NOTIFY_TYPE_LEAVE:
164 * Distribute the notify to local clients on the channel
166 SILC_LOG_DEBUG(("LEAVE notify"));
168 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
169 packet->dst_id_type);
173 /* Get channel entry */
174 channel = silc_idlist_find_channel_by_id(server->local_list,
177 silc_free(channel_id);
182 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
184 silc_free(channel_id);
187 client_id = silc_id_payload_parse_id(tmp, tmp_len);
189 silc_free(channel_id);
193 /* Send to channel */
194 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
195 FALSE, packet->buffer->data,
196 packet->buffer->len, FALSE);
198 /* Get client entry */
199 client = silc_idlist_find_client_by_id(server->global_list,
202 client = silc_idlist_find_client_by_id(server->local_list,
205 silc_free(client_id);
206 silc_free(channel_id);
210 silc_free(client_id);
212 /* Remove the user from channel */
213 silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
216 case SILC_NOTIFY_TYPE_SIGNOFF:
218 * Distribute the notify to local clients on the channel
220 SILC_LOG_DEBUG(("SIGNOFF notify"));
223 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
226 client_id = silc_id_payload_parse_id(tmp, tmp_len);
230 /* Get client entry */
231 client = silc_idlist_find_client_by_id(server->global_list,
234 client = silc_idlist_find_client_by_id(server->local_list,
237 silc_free(client_id);
241 silc_free(client_id);
243 /* Get signoff message */
244 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
248 /* Remove the client from all channels */
249 silc_server_remove_from_channels(server, NULL, client, tmp);
251 /* Remove the client entry */
252 if (!silc_idlist_del_client(server->global_list, client))
253 silc_idlist_del_client(server->local_list, client);
256 case SILC_NOTIFY_TYPE_TOPIC_SET:
258 * Distribute the notify to local clients on the channel
261 SILC_LOG_DEBUG(("TOPIC SET notify"));
263 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
264 packet->dst_id_type);
268 /* Get channel entry */
269 channel = silc_idlist_find_channel_by_id(server->local_list,
272 channel = silc_idlist_find_channel_by_id(server->global_list,
275 silc_free(channel_id);
281 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
283 silc_free(channel_id);
288 silc_free(channel->topic);
289 channel->topic = silc_calloc(tmp_len, sizeof(*channel->topic));
290 memcpy(channel->topic, tmp, tmp_len);
292 /* Send the same notify to the channel */
293 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
294 FALSE, packet->buffer->data,
295 packet->buffer->len, FALSE);
296 silc_free(channel_id);
299 case SILC_NOTIFY_TYPE_NICK_CHANGE:
302 * Distribute the notify to local clients on the channel
304 unsigned char *id, *id2;
306 SILC_LOG_DEBUG(("NICK CHANGE notify"));
308 /* Get old client ID */
309 id = silc_argument_get_arg_type(args, 1, &tmp_len);
312 client_id = silc_id_payload_parse_id(id, tmp_len);
316 /* Get new client ID */
317 id2 = silc_argument_get_arg_type(args, 2, &tmp_len);
320 client_id2 = silc_id_payload_parse_id(id2, tmp_len);
324 SILC_LOG_DEBUG(("Old Client ID id(%s)",
325 silc_id_render(client_id, SILC_ID_CLIENT)));
326 SILC_LOG_DEBUG(("New Client ID id(%s)",
327 silc_id_render(client_id2, SILC_ID_CLIENT)));
329 /* Replace the Client ID */
330 client = silc_idlist_replace_client_id(server->global_list, client_id,
333 client = silc_idlist_replace_client_id(server->local_list, client_id,
337 /* The nickname is not valid anymore, set it NULL. This causes that
338 the nickname will be queried if someone wants to know it. */
339 if (client->nickname)
340 silc_free(client->nickname);
341 client->nickname = NULL;
343 /* Send the NICK_CHANGE notify type to local clients on the channels
344 this client is joined to. */
345 silc_server_send_notify_on_channels(server, client,
346 SILC_NOTIFY_TYPE_NICK_CHANGE, 2,
351 silc_free(client_id);
353 silc_free(client_id2);
357 case SILC_NOTIFY_TYPE_CMODE_CHANGE:
359 * Distribute the notify to local clients on the channel
362 SILC_LOG_DEBUG(("CMODE CHANGE notify"));
364 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
365 packet->dst_id_type);
369 /* Get channel entry */
370 channel = silc_idlist_find_channel_by_id(server->local_list,
373 channel = silc_idlist_find_channel_by_id(server->global_list,
376 silc_free(channel_id);
381 /* Send the same notify to the channel */
382 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
383 FALSE, packet->buffer->data,
384 packet->buffer->len, FALSE);
387 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
389 silc_free(channel_id);
393 SILC_GET32_MSB(mode, tmp);
396 channel->mode = mode;
397 silc_free(channel_id);
400 case SILC_NOTIFY_TYPE_CUMODE_CHANGE:
402 * Distribute the notify to local clients on the channel
405 SILC_LOG_DEBUG(("CUMODE CHANGE notify"));
407 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
408 packet->dst_id_type);
412 /* Get channel entry */
413 channel = silc_idlist_find_channel_by_id(server->local_list,
416 channel = silc_idlist_find_channel_by_id(server->global_list,
419 silc_free(channel_id);
425 tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
427 silc_free(channel_id);
431 SILC_GET32_MSB(mode, tmp);
433 /* Get target client */
434 tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
437 client_id = silc_id_payload_parse_id(tmp, tmp_len);
441 /* Get client entry */
442 client = silc_idlist_find_client_by_id(server->global_list,
445 client = silc_idlist_find_client_by_id(server->local_list,
448 silc_free(client_id);
452 silc_free(client_id);
454 /* Get entry to the channel user list */
455 silc_list_start(channel->user_list);
456 while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END)
457 if (chl->client == client) {
458 /* Change the mode */
463 /* Send the same notify to the channel */
464 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
465 FALSE, packet->buffer->data,
466 packet->buffer->len, FALSE);
467 silc_free(channel_id);
470 case SILC_NOTIFY_TYPE_INVITE:
471 SILC_LOG_DEBUG(("INVITE notify (not-impl XXX)"));
474 case SILC_NOTIFY_TYPE_CHANNEL_CHANGE:
475 SILC_LOG_DEBUG(("CHANNEL CHANGE notify (not-impl XXX)"));
478 case SILC_NOTIFY_TYPE_SERVER_SIGNOFF:
479 SILC_LOG_DEBUG(("SERVER SIGNOFF notify (not-impl XXX)"));
482 case SILC_NOTIFY_TYPE_KICKED:
484 * Distribute the notify to local clients on the channel
487 SILC_LOG_DEBUG(("KICKED notify"));
489 channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
490 packet->dst_id_type);
494 /* Get channel entry */
495 channel = silc_idlist_find_channel_by_id(server->local_list,
498 channel = silc_idlist_find_channel_by_id(server->global_list,
501 silc_free(channel_id);
505 silc_free(channel_id);
508 tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
511 client_id = silc_id_payload_parse_id(tmp, tmp_len);
515 /* Send to channel */
516 silc_server_packet_send_to_channel(server, sock, channel, packet->type,
517 FALSE, packet->buffer->data,
518 packet->buffer->len, FALSE);
520 /* If the the client is not in local list we check global list */
521 client = silc_idlist_find_client_by_id(server->local_list,
524 client = silc_idlist_find_client_by_id(server->global_list,
527 silc_free(client_id);
532 /* Remove the client from channel */
533 silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
537 /* Ignore rest of the notify types for now */
538 case SILC_NOTIFY_TYPE_NONE:
539 case SILC_NOTIFY_TYPE_MOTD:
546 silc_notify_payload_free(payload);
549 void silc_server_notify_list(SilcServer server,
550 SilcSocketConnection sock,
551 SilcPacketContext *packet)
553 SilcPacketContext *new;
557 SILC_LOG_DEBUG(("Processing New Notify List"));
559 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
560 packet->src_id_type != SILC_ID_SERVER)
563 /* Make copy of the original packet context, except for the actual
564 data buffer, which we will here now fetch from the original buffer. */
565 new = silc_packet_context_alloc();
566 new->type = SILC_PACKET_NOTIFY;
567 new->flags = packet->flags;
568 new->src_id = packet->src_id;
569 new->src_id_len = packet->src_id_len;
570 new->src_id_type = packet->src_id_type;
571 new->dst_id = packet->dst_id;
572 new->dst_id_len = packet->dst_id_len;
573 new->dst_id_type = packet->dst_id_type;
575 buffer = silc_buffer_alloc(1024);
576 new->buffer = buffer;
578 while (packet->buffer->len) {
579 SILC_GET16_MSB(len, packet->buffer->data + 2);
580 if (len > packet->buffer->len)
583 if (len > buffer->truelen) {
584 silc_buffer_free(buffer);
585 buffer = silc_buffer_alloc(1024 + len);
588 silc_buffer_pull_tail(buffer, len);
589 silc_buffer_put(buffer, packet->buffer->data, len);
591 /* Process the Notify */
592 silc_server_notify(server, sock, new);
594 silc_buffer_push_tail(buffer, len);
595 silc_buffer_pull(packet->buffer, len);
598 silc_buffer_free(buffer);
602 /* Received private message. This resolves the destination of the message
603 and sends the packet. This is used by both server and router. If the
604 destination is our locally connected client this sends the packet to
605 the client. This may also send the message for further routing if
606 the destination is not in our server (or router). */
608 void silc_server_private_message(SilcServer server,
609 SilcSocketConnection sock,
610 SilcPacketContext *packet)
613 SilcServerEntry router;
614 SilcSocketConnection dst_sock;
615 SilcClientEntry client;
616 SilcIDListData idata;
618 SILC_LOG_DEBUG(("Start"));
623 /* Decode destination Client ID */
624 id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CLIENT);
626 SILC_LOG_ERROR(("Could not decode destination Client ID, dropped"));
630 /* If the destination belongs to our server we don't have to route
631 the message anywhere but to send it to the local destination. */
632 client = silc_idlist_find_client_by_id(server->local_list, id, NULL);
634 /* It exists, now deliver the message to the destination */
635 dst_sock = (SilcSocketConnection)client->connection;
637 /* If we are router and the client has router then the client is in
638 our cell but not directly connected to us. */
639 if (server->server_type == SILC_ROUTER && client->router) {
640 /* We are of course in this case the client's router thus the real
641 "router" of the client is the server who owns the client. Thus
642 we will send the packet to that server. */
643 router = (SilcServerEntry)client->router;
644 idata = (SilcIDListData)router;
646 silc_server_send_private_message(server, router->connection,
653 /* Seems that client really is directly connected to us */
654 idata = (SilcIDListData)client;
655 silc_server_send_private_message(server, dst_sock,
657 idata->hmac, packet);
661 /* Destination belongs to someone not in this server. If we are normal
662 server our action is to send the packet to our router. */
663 if (server->server_type == SILC_SERVER && !server->standalone) {
664 router = server->router;
666 /* Send to primary route */
668 dst_sock = (SilcSocketConnection)router->connection;
669 idata = (SilcIDListData)router;
670 silc_server_send_private_message(server, dst_sock,
672 idata->hmac, packet);
677 /* We are router and we will perform route lookup for the destination
678 and send the message to fastest route. */
679 if (server->server_type == SILC_ROUTER && !server->standalone) {
680 /* Check first that the ID is valid */
681 client = silc_idlist_find_client_by_id(server->global_list, id, NULL);
683 dst_sock = silc_server_route_get(server, id, SILC_ID_CLIENT);
684 router = (SilcServerEntry)dst_sock->user_data;
685 idata = (SilcIDListData)router;
687 /* Get fastest route and send packet. */
689 silc_server_send_private_message(server, dst_sock,
691 idata->hmac, packet);
697 silc_server_send_error(server, sock,
698 "No such nickname: Private message not sent");
701 /* Processes incoming command reply packet. The command reply packet may
702 be destined to one of our clients or it may directly for us. We will
703 call the command reply routine after processing the packet. */
705 void silc_server_command_reply(SilcServer server,
706 SilcSocketConnection sock,
707 SilcPacketContext *packet)
709 SilcBuffer buffer = packet->buffer;
710 SilcClientEntry client = NULL;
711 SilcSocketConnection dst_sock;
712 SilcIDListData idata;
713 SilcClientID *id = NULL;
715 SILC_LOG_DEBUG(("Start"));
717 /* Source must be server or router */
718 if (packet->src_id_type != SILC_ID_SERVER &&
719 sock->type != SILC_SOCKET_TYPE_ROUTER)
722 if (packet->dst_id_type == SILC_ID_CHANNEL)
725 if (packet->dst_id_type == SILC_ID_CLIENT) {
726 /* Destination must be one of ours */
727 id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CLIENT);
730 client = silc_idlist_find_client_by_id(server->local_list, id, NULL);
732 SILC_LOG_ERROR(("Cannot process command reply to unknown client"));
738 if (packet->dst_id_type == SILC_ID_SERVER) {
739 /* For now this must be for us */
740 if (SILC_ID_SERVER_COMPARE(packet->dst_id, server->id_string)) {
741 SILC_LOG_ERROR(("Cannot process command reply to unknown server"));
746 /* Execute command reply locally for the command */
747 silc_server_command_reply_process(server, sock, buffer);
749 if (packet->dst_id_type == SILC_ID_CLIENT && client && id) {
750 /* Relay the packet to the client */
752 dst_sock = (SilcSocketConnection)client->connection;
753 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
754 + packet->dst_id_len + packet->padlen);
756 silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
757 silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
759 idata = (SilcIDListData)client;
762 silc_packet_encrypt(idata->send_key, idata->hmac, dst_sock->outbuf,
765 /* Send the packet */
766 silc_server_packet_send_real(server, dst_sock, TRUE);
772 /* Process received channel message. The message can be originated from
775 void silc_server_channel_message(SilcServer server,
776 SilcSocketConnection sock,
777 SilcPacketContext *packet)
779 SilcChannelEntry channel = NULL;
780 SilcChannelClientEntry chl;
781 SilcChannelID *id = NULL;
784 SILC_LOG_DEBUG(("Processing channel message"));
787 if (packet->dst_id_type != SILC_ID_CHANNEL) {
788 SILC_LOG_DEBUG(("Received bad message for channel, dropped"));
792 /* Find channel entry */
793 id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CHANNEL);
796 channel = silc_idlist_find_channel_by_id(server->local_list, id, NULL);
798 channel = silc_idlist_find_channel_by_id(server->global_list, id, NULL);
800 SILC_LOG_DEBUG(("Could not find channel"));
805 /* See that this client is on the channel. If the message is coming
806 from router we won't do the check as the message is from client that
807 we don't know about. Also, if the original sender is not client
808 (as it can be server as well) we don't do the check. */
809 sender = silc_id_str2id(packet->src_id, packet->src_id_len,
810 packet->src_id_type);
813 if (sock->type != SILC_SOCKET_TYPE_ROUTER &&
814 packet->src_id_type == SILC_ID_CLIENT) {
815 silc_list_start(channel->user_list);
816 while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END) {
817 if (chl->client && !SILC_ID_CLIENT_COMPARE(chl->client->id, sender))
820 if (chl == SILC_LIST_END) {
821 SILC_LOG_DEBUG(("Client not on channel"));
826 /* Distribute the packet to our local clients. This will send the
827 packet for further routing as well, if needed. */
828 silc_server_packet_relay_to_channel(server, sock, channel, sender,
830 packet->buffer->data,
831 packet->buffer->len, FALSE);
840 /* Received channel key packet. We distribute the key to all of our locally
841 connected clients on the channel. */
843 void silc_server_channel_key(SilcServer server,
844 SilcSocketConnection sock,
845 SilcPacketContext *packet)
847 SilcBuffer buffer = packet->buffer;
848 SilcChannelEntry channel;
850 if (packet->src_id_type != SILC_ID_SERVER)
853 /* Save the channel key */
854 channel = silc_server_save_channel_key(server, buffer, NULL);
858 /* Distribute the key to everybody who is on the channel. If we are router
859 we will also send it to locally connected servers. */
860 silc_server_send_channel_key(server, sock, channel, FALSE);
863 /* Received New Client packet and processes it. Creates Client ID for the
864 client. Client becomes registered after calling this functions. */
866 SilcClientEntry silc_server_new_client(SilcServer server,
867 SilcSocketConnection sock,
868 SilcPacketContext *packet)
870 SilcBuffer buffer = packet->buffer;
871 SilcClientEntry client;
872 SilcIDCacheEntry cache;
873 SilcClientID *client_id;
875 SilcIDListData idata;
876 char *username = NULL, *realname = NULL, *id_string;
879 SILC_LOG_DEBUG(("Creating new client"));
881 if (sock->type != SILC_SOCKET_TYPE_CLIENT)
884 /* Take client entry */
885 client = (SilcClientEntry)sock->user_data;
886 idata = (SilcIDListData)client;
888 /* Fetch the old client cache entry so that we can update it. */
889 if (!silc_idcache_find_by_context(server->local_list->clients,
890 sock->user_data, &cache)) {
891 SILC_LOG_ERROR(("Lost client's cache entry - bad thing"));
895 /* Parse incoming packet */
896 ret = silc_buffer_unformat(buffer,
897 SILC_STR_UI16_STRING_ALLOC(&username),
898 SILC_STR_UI16_STRING_ALLOC(&realname),
912 silc_server_disconnect_remote(server, sock, "Server closed connection: "
913 "Incomplete client information");
917 /* Create Client ID */
918 silc_id_create_client_id(server->id, server->rng, server->md5hash,
919 username, &client_id);
921 /* Update client entry */
922 idata->registered = TRUE;
923 client->nickname = strdup(username);
924 client->username = username;
925 client->userinfo = realname ? realname : strdup(" ");
926 client->id = client_id;
928 /* Update the cache entry */
929 cache->id = (void *)client_id;
930 cache->type = SILC_ID_CLIENT;
931 cache->data = username;
932 silc_idcache_sort_by_data(server->local_list->clients);
934 /* Notify our router about new client on the SILC network */
935 if (!server->standalone)
936 silc_server_send_new_id(server, (SilcSocketConnection)
937 server->router->connection,
938 server->server_type == SILC_ROUTER ? TRUE : FALSE,
939 client->id, SILC_ID_CLIENT, SILC_ID_CLIENT_LEN);
941 /* Send the new client ID to the client. */
942 id_string = silc_id_id2str(client->id, SILC_ID_CLIENT);
943 reply = silc_buffer_alloc(2 + 2 + SILC_ID_CLIENT_LEN);
944 silc_buffer_pull_tail(reply, SILC_BUFFER_END(reply));
945 silc_buffer_format(reply,
946 SILC_STR_UI_SHORT(SILC_ID_CLIENT),
947 SILC_STR_UI_SHORT(SILC_ID_CLIENT_LEN),
948 SILC_STR_UI_XNSTRING(id_string, SILC_ID_CLIENT_LEN),
950 silc_server_packet_send(server, sock, SILC_PACKET_NEW_ID, 0,
951 reply->data, reply->len, FALSE);
952 silc_free(id_string);
953 silc_buffer_free(reply);
955 /* Send some nice info to the client */
956 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
957 ("Welcome to the SILC Network %s@%s",
958 username, sock->hostname));
959 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
960 ("Your host is %s, running version %s",
961 server->config->server_info->server_name,
963 if (server->server_type == SILC_ROUTER) {
964 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
965 ("There are %d clients on %d servers in SILC "
966 "Network", server->stat.clients,
967 server->stat.servers + 1));
968 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
969 ("There are %d clients on %d server in our cell",
970 server->stat.cell_clients,
971 server->stat.cell_servers + 1));
972 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
973 ("I have %d clients, %d channels, %d servers and "
975 server->stat.my_clients,
976 server->stat.my_channels,
977 server->stat.my_servers,
978 server->stat.my_routers));
979 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
980 ("%d server operators and %d router operators "
982 server->stat.my_server_ops,
983 server->stat.my_router_ops));
985 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
986 ("I have %d clients and %d channels formed",
987 server->stat.my_clients,
988 server->stat.my_channels));
989 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
990 ("%d operators online",
991 server->stat.my_server_ops));
993 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
994 ("Your connection is secured with %s cipher, "
995 "key length %d bits",
996 idata->send_key->cipher->name,
997 idata->send_key->cipher->key_len));
998 SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
999 ("Your current nickname is %s",
1003 silc_server_send_motd(server, sock);
1008 /* Create new server. This processes received New Server packet and
1009 saves the received Server ID. The server is our locally connected
1010 server thus we save all the information and save it to local list.
1011 This funtion can be used by both normal server and router server.
1012 If normal server uses this it means that its router has connected
1013 to the server. If router uses this it means that one of the cell's
1014 servers is connected to the router. */
1016 SilcServerEntry silc_server_new_server(SilcServer server,
1017 SilcSocketConnection sock,
1018 SilcPacketContext *packet)
1020 SilcBuffer buffer = packet->buffer;
1021 SilcServerEntry new_server;
1022 SilcIDCacheEntry cache;
1023 SilcServerID *server_id;
1024 SilcIDListData idata;
1025 unsigned char *server_name, *id_string;
1026 unsigned short id_len;
1029 SILC_LOG_DEBUG(("Creating new server"));
1031 if (sock->type != SILC_SOCKET_TYPE_SERVER &&
1032 sock->type != SILC_SOCKET_TYPE_ROUTER)
1035 /* Take server entry */
1036 new_server = (SilcServerEntry)sock->user_data;
1037 idata = (SilcIDListData)new_server;
1039 /* Fetch the old server cache entry so that we can update it. */
1040 if (!silc_idcache_find_by_context(server->local_list->servers,
1041 sock->user_data, &cache)) {
1042 SILC_LOG_ERROR(("Lost server's cache entry - bad thing"));
1046 /* Parse the incoming packet */
1047 ret = silc_buffer_unformat(buffer,
1048 SILC_STR_UI16_NSTRING_ALLOC(&id_string, &id_len),
1049 SILC_STR_UI16_STRING_ALLOC(&server_name),
1053 silc_free(id_string);
1055 silc_free(server_name);
1059 if (id_len > buffer->len) {
1060 silc_free(id_string);
1061 silc_free(server_name);
1066 server_id = silc_id_str2id(id_string, id_len, SILC_ID_SERVER);
1068 silc_free(id_string);
1069 silc_free(server_name);
1072 silc_free(id_string);
1074 /* Update client entry */
1075 idata->registered = TRUE;
1076 new_server->server_name = server_name;
1077 new_server->id = server_id;
1079 /* Update the cache entry */
1080 cache->id = (void *)server_id;
1081 cache->type = SILC_ID_SERVER;
1082 cache->data = server_name;
1083 silc_idcache_sort_by_data(server->local_list->servers);
1085 /* Distribute the information about new server in the SILC network
1086 to our router. If we are normal server we won't send anything
1087 since this connection must be our router connection. */
1088 if (server->server_type == SILC_ROUTER && !server->standalone &&
1089 server->router->connection != sock)
1090 silc_server_send_new_id(server, server->router->connection,
1091 TRUE, new_server->id, SILC_ID_SERVER,
1092 SILC_ID_SERVER_LEN);
1094 if (server->server_type == SILC_ROUTER)
1095 server->stat.cell_servers++;
1100 /* Processes incoming New ID packet. New ID Payload is used to distribute
1101 information about newly registered clients and servers. */
1103 static void silc_server_new_id_real(SilcServer server,
1104 SilcSocketConnection sock,
1105 SilcPacketContext *packet,
1108 SilcBuffer buffer = packet->buffer;
1110 SilcServerEntry router;
1111 SilcSocketConnection router_sock;
1114 unsigned char *hash = NULL;
1117 SILC_LOG_DEBUG(("Processing new ID"));
1119 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
1120 server->server_type == SILC_SERVER ||
1121 packet->src_id_type != SILC_ID_SERVER)
1124 idp = silc_id_payload_parse(buffer);
1128 id_type = silc_id_payload_get_type(idp);
1130 /* Normal server cannot have other normal server connections */
1131 if (id_type == SILC_ID_SERVER && sock->type == SILC_SOCKET_TYPE_SERVER)
1134 id = silc_id_payload_get_id(idp);
1138 /* If the sender of this packet is server and we are router we need to
1139 broadcast this packet to other routers in the network. */
1140 if (broadcast && !server->standalone && server->server_type == SILC_ROUTER &&
1141 sock->type == SILC_SOCKET_TYPE_SERVER &&
1142 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
1143 SILC_LOG_DEBUG(("Broadcasting received New ID packet"));
1144 silc_server_packet_send(server, server->router->connection,
1146 packet->flags | SILC_PACKET_FLAG_BROADCAST,
1147 buffer->data, buffer->len, FALSE);
1150 if (sock->type == SILC_SOCKET_TYPE_SERVER)
1151 id_list = server->local_list;
1153 id_list = server->global_list;
1156 router = sock->user_data;
1159 case SILC_ID_CLIENT:
1161 SilcClientEntry entry;
1163 SILC_LOG_DEBUG(("New client id(%s) from [%s] %s",
1164 silc_id_render(id, SILC_ID_CLIENT),
1165 sock->type == SILC_SOCKET_TYPE_SERVER ?
1166 "Server" : "Router", sock->hostname));
1168 /* As a router we keep information of all global information in our
1169 global list. Cell wide information however is kept in the local
1170 list. The client is put to global list and we will take the hash
1171 value of the Client ID and save it to the ID Cache system for fast
1172 searching in the future. */
1173 hash = silc_calloc(sizeof(((SilcClientID *)id)->hash),
1174 sizeof(unsigned char));
1175 memcpy(hash, ((SilcClientID *)id)->hash,
1176 sizeof(((SilcClientID *)id)->hash));
1177 entry = silc_idlist_add_client(id_list, hash, NULL, NULL, id,
1179 entry->nickname = NULL;
1181 if (sock->type == SILC_SOCKET_TYPE_SERVER)
1182 server->stat.cell_clients++;
1183 server->stat.clients++;
1186 /* XXX Adding two ID's with same IP number replaces the old entry thus
1187 gives wrong route. Thus, now disabled until figured out a better way
1188 to do this or when removed the whole thing. This could be removed
1189 because entry->router->connection gives always the most optimal route
1190 for the ID anyway (unless new routes (faster perhaps) are established
1191 after receiving this ID, this we don't know however). */
1192 /* Add route cache for this ID */
1193 silc_server_route_add(silc_server_route_hash(
1194 ((SilcClientID *)id)->ip.s_addr,
1195 server->id->port), ((SilcClientID *)id)->ip.s_addr,
1201 case SILC_ID_SERVER:
1202 SILC_LOG_DEBUG(("New server id(%s) from [%s] %s",
1203 silc_id_render(id, SILC_ID_SERVER),
1204 sock->type == SILC_SOCKET_TYPE_SERVER ?
1205 "Server" : "Router", sock->hostname));
1207 /* As a router we keep information of all global information in our global
1208 list. Cell wide information however is kept in the local list. */
1209 silc_idlist_add_server(id_list, NULL, 0, id, router, router_sock);
1211 if (sock->type == SILC_SOCKET_TYPE_SERVER)
1212 server->stat.cell_servers++;
1213 server->stat.servers++;
1216 /* Add route cache for this ID */
1217 silc_server_route_add(silc_server_route_hash(
1218 ((SilcServerID *)id)->ip.s_addr,
1219 ((SilcServerID *)id)->port),
1220 ((SilcServerID *)id)->ip.s_addr,
1225 case SILC_ID_CHANNEL:
1226 SILC_LOG_ERROR(("Channel cannot be registered with NEW_ID packet"));
1234 silc_id_payload_free(idp);
1238 /* Processes incoming New ID packet. New ID Payload is used to distribute
1239 information about newly registered clients and servers. */
1241 void silc_server_new_id(SilcServer server, SilcSocketConnection sock,
1242 SilcPacketContext *packet)
1244 silc_server_new_id_real(server, sock, packet, TRUE);
1247 /* Receoved New Id List packet, list of New ID payloads inside one
1248 packet. Process the New ID payloads one by one. */
1250 void silc_server_new_id_list(SilcServer server, SilcSocketConnection sock,
1251 SilcPacketContext *packet)
1253 SilcPacketContext *new_id;
1255 unsigned short id_len;
1257 SILC_LOG_DEBUG(("Processing New ID List"));
1259 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
1260 packet->src_id_type != SILC_ID_SERVER)
1263 /* If the sender of this packet is server and we are router we need to
1264 broadcast this packet to other routers in the network. Broadcast
1265 this list packet instead of multiple New ID packets. */
1266 if (!server->standalone && server->server_type == SILC_ROUTER &&
1267 sock->type == SILC_SOCKET_TYPE_SERVER &&
1268 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
1269 SILC_LOG_DEBUG(("Broadcasting received New ID List packet"));
1270 silc_server_packet_send(server, server->router->connection,
1272 packet->flags | SILC_PACKET_FLAG_BROADCAST,
1273 packet->buffer->data, packet->buffer->len, FALSE);
1276 /* Make copy of the original packet context, except for the actual
1277 data buffer, which we will here now fetch from the original buffer. */
1278 new_id = silc_packet_context_alloc();
1279 new_id->type = SILC_PACKET_NEW_ID;
1280 new_id->flags = packet->flags;
1281 new_id->src_id = packet->src_id;
1282 new_id->src_id_len = packet->src_id_len;
1283 new_id->src_id_type = packet->src_id_type;
1284 new_id->dst_id = packet->dst_id;
1285 new_id->dst_id_len = packet->dst_id_len;
1286 new_id->dst_id_type = packet->dst_id_type;
1288 idp = silc_buffer_alloc(256);
1289 new_id->buffer = idp;
1291 while (packet->buffer->len) {
1292 SILC_GET16_MSB(id_len, packet->buffer->data + 2);
1293 if ((id_len > packet->buffer->len) ||
1294 (id_len > idp->truelen))
1297 silc_buffer_pull_tail(idp, 4 + id_len);
1298 silc_buffer_put(idp, packet->buffer->data, 4 + id_len);
1300 /* Process the New ID */
1301 silc_server_new_id_real(server, sock, new_id, FALSE);
1303 silc_buffer_push_tail(idp, 4 + id_len);
1304 silc_buffer_pull(packet->buffer, 4 + id_len);
1307 silc_buffer_free(idp);
1311 /* Received New Channel packet. Information about new channels in the
1312 network are distributed using this packet. Save the information about
1313 the new channel. This usually comes from router but also normal server
1314 can send this to notify channels it has when it connects to us. */
1316 void silc_server_new_channel(SilcServer server,
1317 SilcSocketConnection sock,
1318 SilcPacketContext *packet)
1321 SilcChannelID *channel_id;
1322 unsigned short channel_id_len;
1326 SILC_LOG_DEBUG(("Processing New Channel"));
1328 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
1329 packet->src_id_type != SILC_ID_SERVER ||
1330 server->server_type == SILC_SERVER)
1334 ret = silc_buffer_unformat(packet->buffer,
1335 SILC_STR_UI16_STRING_ALLOC(&channel_name),
1336 SILC_STR_UI16_NSTRING_ALLOC(&id, &channel_id_len),
1340 silc_free(channel_name);
1346 /* Decode the channel ID */
1347 channel_id = silc_id_str2id(id, channel_id_len, SILC_ID_CHANNEL);
1351 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
1352 /* Add the server to global list as it is coming from router. It
1353 cannot be our own channel as it is coming from router. */
1355 SILC_LOG_DEBUG(("New channel id(%s) from [Router] %s",
1356 silc_id_render(channel_id, SILC_ID_CHANNEL),
1359 silc_idlist_add_channel(server->global_list, channel_name, 0, channel_id,
1360 server->router->connection, NULL);
1362 server->stat.channels++;
1364 /* The channel is coming from our server, thus it is in our cell
1365 we will add it to our local list. */
1366 SilcChannelEntry channel;
1369 SILC_LOG_DEBUG(("New channel id(%s) from [Server] %s",
1370 silc_id_render(channel_id, SILC_ID_CHANNEL),
1373 /* Check that we don't already have this channel */
1374 channel = silc_idlist_find_channel_by_name(server->local_list,
1375 channel_name, NULL);
1377 channel = silc_idlist_find_channel_by_name(server->global_list,
1378 channel_name, NULL);
1380 /* If the channel does not exist, then create it. We create the channel
1381 with the channel ID provided by the server. This creates a new
1382 key to the channel as well that we will send to the server. */
1384 channel = silc_server_create_new_channel_with_id(server, NULL,
1390 /* Send the new channel key to the server */
1391 chk = silc_channel_key_payload_encode(channel_id_len, id,
1392 strlen(channel->channel_key->
1394 channel->channel_key->cipher->name,
1395 channel->key_len / 8,
1397 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
1398 chk->data, chk->len, FALSE);
1399 silc_buffer_free(chk);
1402 /* The channel exist by that name, check whether the ID's match.
1403 If they don't then we'll force the server to use the ID we have.
1404 We also create a new key for the channel. */
1406 if (SILC_ID_CHANNEL_COMPARE(channel_id, channel->id)) {
1407 /* They don't match, send CHANNEL_CHANGE notify to the server to
1408 force the ID change. */
1409 SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
1410 silc_server_send_notify_channel_change(server, sock, FALSE,
1413 SILC_ID_CHANNEL_LEN);
1416 /* Create new key for the channel and send it to the server and
1417 everybody else possibly on the channel. */
1419 silc_server_create_channel_key(server, channel, 0);
1421 /* Send to the channel */
1422 silc_server_send_channel_key(server, sock, channel, FALSE);
1424 /* Send to the server */
1425 chk = silc_channel_key_payload_encode(channel_id_len, id,
1426 strlen(channel->channel_key->
1428 channel->channel_key->cipher->name,
1429 channel->key_len / 8,
1431 silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
1432 chk->data, chk->len, FALSE);
1433 silc_buffer_free(chk);
1435 /* Since the channel is coming from server and we also know about it
1436 then send the JOIN notify to the server so that it see's our
1437 users on the channel "joining" the channel. */
1445 /* Received New Channel List packet, list of New Channel List payloads inside
1446 one packet. Process the New Channel payloads one by one. */
1448 void silc_server_new_channel_list(SilcServer server,
1449 SilcSocketConnection sock,
1450 SilcPacketContext *packet)
1452 SilcPacketContext *new;
1454 unsigned short len1, len2;
1456 SILC_LOG_DEBUG(("Processing New Channel List"));
1458 if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
1459 packet->src_id_type != SILC_ID_SERVER ||
1460 server->server_type == SILC_SERVER)
1463 /* If the sender of this packet is server and we are router we need to
1464 broadcast this packet to other routers in the network. Broadcast
1465 this list packet instead of multiple New Channel packets. */
1466 if (!server->standalone && server->server_type == SILC_ROUTER &&
1467 sock->type == SILC_SOCKET_TYPE_SERVER &&
1468 !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
1469 SILC_LOG_DEBUG(("Broadcasting received New Channel List packet"));
1470 silc_server_packet_send(server, server->router->connection,
1472 packet->flags | SILC_PACKET_FLAG_BROADCAST,
1473 packet->buffer->data, packet->buffer->len, FALSE);
1476 /* Make copy of the original packet context, except for the actual
1477 data buffer, which we will here now fetch from the original buffer. */
1478 new = silc_packet_context_alloc();
1479 new->type = SILC_PACKET_NEW_CHANNEL;
1480 new->flags = packet->flags;
1481 new->src_id = packet->src_id;
1482 new->src_id_len = packet->src_id_len;
1483 new->src_id_type = packet->src_id_type;
1484 new->dst_id = packet->dst_id;
1485 new->dst_id_len = packet->dst_id_len;
1486 new->dst_id_type = packet->dst_id_type;
1488 buffer = silc_buffer_alloc(512);
1489 new->buffer = buffer;
1491 while (packet->buffer->len) {
1492 SILC_GET16_MSB(len1, packet->buffer->data);
1493 if ((len1 > packet->buffer->len) ||
1494 (len1 > buffer->truelen))
1497 SILC_GET16_MSB(len2, packet->buffer->data + 2 + len1);
1498 if ((len2 > packet->buffer->len) ||
1499 (len2 > buffer->truelen))
1502 silc_buffer_pull_tail(buffer, 4 + len1 + len2);
1503 silc_buffer_put(buffer, packet->buffer->data, 4 + len1 + len2);
1505 /* Process the New Channel */
1506 silc_server_new_channel(server, sock, new);
1508 silc_buffer_push_tail(buffer, 4 + len1 + len2);
1509 silc_buffer_pull(packet->buffer, 4 + len1 + len2);
1512 silc_buffer_free(buffer);