5 Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
7 Copyright (C) 1997 - 2000 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 send packets.
25 #include "serverincludes.h"
26 #include "server_internal.h"
28 /* Routine that sends packet or marks packet to be sent. This is used
29 directly only in special cases. Normal cases should use
30 silc_server_packet_send. Returns < 0 error. */
32 int silc_server_packet_send_real(SilcServer server,
33 SilcSocketConnection sock,
39 ret = silc_packet_send(sock, force_send);
43 /* Mark that there is some outgoing data available for this connection.
44 This call sets the connection both for input and output (the input
45 is set always and this call keeps the input setting, actually).
46 Actual data sending is performed by silc_server_packet_process. */
47 SILC_SET_CONNECTION_FOR_OUTPUT(sock->sock);
49 /* Mark to socket that data is pending in outgoing buffer. This flag
50 is needed if new data is added to the buffer before the earlier
51 put data is sent to the network. */
52 SILC_SET_OUTBUF_PENDING(sock);
57 /* Assembles a new packet to be sent out to network. This doesn't actually
58 send the packet but creates the packet and fills the outgoing data
59 buffer and marks the packet ready to be sent to network. However, If
60 argument force_send is TRUE the packet is sent immediately and not put
61 to queue. Normal case is that the packet is not sent immediately. */
63 void silc_server_packet_send(SilcServer server,
64 SilcSocketConnection sock,
66 SilcPacketFlags flags,
68 unsigned int data_len,
72 SilcIdType dst_id_type = SILC_ID_NONE;
77 /* Get data used in the packet sending, keys and stuff */
79 case SILC_SOCKET_TYPE_CLIENT:
80 dst_id = ((SilcClientEntry)sock->user_data)->id;
81 dst_id_type = SILC_ID_CLIENT;
83 case SILC_SOCKET_TYPE_SERVER:
84 case SILC_SOCKET_TYPE_ROUTER:
85 dst_id = ((SilcServerEntry)sock->user_data)->id;
86 dst_id_type = SILC_ID_SERVER;
92 silc_server_packet_send_dest(server, sock, type, flags, dst_id,
93 dst_id_type, data, data_len, force_send);
96 /* Assembles a new packet to be sent out to network. This doesn't actually
97 send the packet but creates the packet and fills the outgoing data
98 buffer and marks the packet ready to be sent to network. However, If
99 argument force_send is TRUE the packet is sent immediately and not put
100 to queue. Normal case is that the packet is not sent immediately.
101 Destination information is sent as argument for this function. */
103 void silc_server_packet_send_dest(SilcServer server,
104 SilcSocketConnection sock,
106 SilcPacketFlags flags,
108 SilcIdType dst_id_type,
110 unsigned int data_len,
113 SilcPacketContext packetdata;
114 SilcIDListData idata;
115 SilcCipher cipher = NULL;
116 SilcHmac hmac = NULL;
117 unsigned char *dst_id_data = NULL;
118 unsigned int dst_id_len = 0;
120 SILC_LOG_DEBUG(("Sending packet, type %d", type));
122 /* Get data used in the packet sending, keys and stuff */
123 idata = (SilcIDListData)sock->user_data;
126 dst_id_data = silc_id_id2str(dst_id, dst_id_type);
127 dst_id_len = silc_id_get_len(dst_id_type);
130 /* Set the packet context pointers */
131 packetdata.type = type;
132 packetdata.flags = flags;
133 packetdata.src_id = silc_id_id2str(server->id, server->id_type);
134 packetdata.src_id_len = SILC_ID_SERVER_LEN;
135 packetdata.src_id_type = server->id_type;
136 packetdata.dst_id = dst_id_data;
137 packetdata.dst_id_len = dst_id_len;
138 packetdata.dst_id_type = dst_id_type;
139 packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
140 packetdata.src_id_len + dst_id_len;
141 packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen);
142 packetdata.rng = server->rng;
144 /* Prepare outgoing data buffer for packet sending */
145 silc_packet_send_prepare(sock,
146 SILC_PACKET_HEADER_LEN +
147 packetdata.src_id_len +
148 packetdata.dst_id_len,
152 SILC_LOG_DEBUG(("Putting data to outgoing buffer, len %d", data_len));
154 packetdata.buffer = sock->outbuf;
156 /* Put the data to the buffer */
157 if (data && data_len)
158 silc_buffer_put(sock->outbuf, data, data_len);
160 /* Create the outgoing packet */
161 silc_packet_assemble(&packetdata);
164 cipher = idata->send_key;
168 /* Encrypt the packet */
169 silc_packet_encrypt(cipher, hmac, sock->outbuf, sock->outbuf->len);
171 SILC_LOG_HEXDUMP(("Outgoing packet, len %d", sock->outbuf->len),
172 sock->outbuf->data, sock->outbuf->len);
174 /* Now actually send the packet */
175 silc_server_packet_send_real(server, sock, force_send);
177 if (packetdata.src_id)
178 silc_free(packetdata.src_id);
179 if (packetdata.dst_id)
180 silc_free(packetdata.dst_id);
183 /* Broadcast received packet to our primary route. This function is used
184 by router to further route received broadcast packet. It is expected
185 that the broadcast flag from the packet is checked before calling this
186 function. This does not test or set the broadcast flag. */
188 void silc_server_packet_broadcast(SilcServer server,
189 SilcSocketConnection sock,
190 SilcPacketContext *packet)
192 SilcBuffer buffer = packet->buffer;
193 SilcIDListData idata;
196 SILC_LOG_DEBUG(("Broadcasting received broadcast packet"));
198 /* If the packet is originated from our primary route we are
199 not allowed to send the packet. */
200 id = silc_id_str2id(packet->src_id, packet->src_id_type);
201 if (id && SILC_ID_SERVER_COMPARE(id, server->router->id)) {
202 idata = (SilcIDListData)sock->user_data;
204 silc_buffer_push(buffer, buffer->data - buffer->head);
205 silc_packet_send_prepare(sock, 0, 0, buffer->len);
206 silc_buffer_put(sock->outbuf, buffer->data, buffer->len);
207 silc_packet_encrypt(idata->send_key, idata->hmac,
208 sock->outbuf, sock->outbuf->len);
210 SILC_LOG_HEXDUMP(("Broadcasted packet, len %d", sock->outbuf->len),
211 sock->outbuf->data, sock->outbuf->len);
213 /* Now actually send the packet */
214 silc_server_packet_send_real(server, sock, TRUE);
219 SILC_LOG_DEBUG(("Will not broadcast to primary route since it is the "
220 "original sender of this packet"));
224 /* Routes received packet to `sock'. This is used to route the packets that
225 router receives but are not destined to it. */
227 void silc_server_packet_route(SilcServer server,
228 SilcSocketConnection sock,
229 SilcPacketContext *packet)
231 SilcBuffer buffer = packet->buffer;
232 SilcIDListData idata;
234 SILC_LOG_DEBUG(("Routing received packet"));
236 idata = (SilcIDListData)sock->user_data;
238 silc_buffer_push(buffer, buffer->data - buffer->head);
239 silc_packet_send_prepare(sock, 0, 0, buffer->len);
240 silc_buffer_put(sock->outbuf, buffer->data, buffer->len);
241 silc_packet_encrypt(idata->send_key, idata->hmac,
242 sock->outbuf, sock->outbuf->len);
244 SILC_LOG_HEXDUMP(("Routed packet, len %d", sock->outbuf->len),
245 sock->outbuf->data, sock->outbuf->len);
247 /* Now actually send the packet */
248 silc_server_packet_send_real(server, sock, TRUE);
251 /* Internal routine to actually create the channel packet and send it
252 to network. This is common function in channel message sending. If
253 `channel_message' is TRUE this encrypts the message as it is strictly
254 a channel message. If FALSE normal encryption process is used. */
257 silc_server_packet_send_to_channel_real(SilcServer server,
258 SilcSocketConnection sock,
259 SilcPacketContext *packet,
263 unsigned int data_len,
267 packet->truelen = data_len + SILC_PACKET_HEADER_LEN +
268 packet->src_id_len + packet->dst_id_len;
270 /* Prepare outgoing data buffer for packet sending */
271 silc_packet_send_prepare(sock,
272 SILC_PACKET_HEADER_LEN +
278 packet->buffer = sock->outbuf;
280 /* Put the data to buffer, assemble and encrypt the packet. The packet
281 is encrypted with normal session key shared with the client. */
282 silc_buffer_put(sock->outbuf, data, data_len);
283 silc_packet_assemble(packet);
285 silc_packet_encrypt(cipher, hmac, sock->outbuf, SILC_PACKET_HEADER_LEN +
286 packet->src_id_len + packet->dst_id_len +
289 silc_packet_encrypt(cipher, hmac, sock->outbuf, sock->outbuf->len);
291 SILC_LOG_HEXDUMP(("Channel packet, len %d", sock->outbuf->len),
292 sock->outbuf->data, sock->outbuf->len);
294 /* Now actually send the packet */
295 silc_server_packet_send_real(server, sock, force_send);
298 /* This routine is used by the server to send packets to channel. The
299 packet sent with this function is distributed to all clients on
300 the channel. Usually this is used to send notify messages to the
301 channel, things like notify about new user joining to the channel.
302 If `route' is FALSE then the packet is sent only locally and will not
303 be routed anywhere (for router locally means cell wide). */
305 void silc_server_packet_send_to_channel(SilcServer server,
306 SilcChannelEntry channel,
310 unsigned int data_len,
313 SilcSocketConnection sock = NULL;
314 SilcPacketContext packetdata;
315 SilcClientEntry client = NULL;
316 SilcServerEntry *routed = NULL;
317 SilcChannelClientEntry chl;
318 SilcIDListData idata;
319 unsigned int routed_count = 0;
321 /* This doesn't send channel message packets */
322 if (type == SILC_PACKET_CHANNEL_MESSAGE)
325 SILC_LOG_DEBUG(("Sending packet to channel"));
327 /* Set the packet context pointers. */
328 packetdata.flags = 0;
329 packetdata.type = type;
330 packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
331 packetdata.src_id_len = SILC_ID_SERVER_LEN;
332 packetdata.src_id_type = SILC_ID_SERVER;
333 packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
334 packetdata.dst_id_len = SILC_ID_CHANNEL_LEN;
335 packetdata.dst_id_type = SILC_ID_CHANNEL;
336 packetdata.rng = server->rng;
337 packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
338 packetdata.src_id_len + packetdata.dst_id_len;
339 packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen);
341 /* If there are global users in the channel we will send the message
342 first to our router for further routing. */
343 if (route && server->server_type == SILC_SERVER && !server->standalone &&
344 channel->global_users) {
345 SilcServerEntry router;
347 /* Get data used in packet header encryption, keys and stuff. */
348 router = server->router;
349 sock = (SilcSocketConnection)router->connection;
350 idata = (SilcIDListData)router;
352 SILC_LOG_DEBUG(("Sending channel message to router for routing"));
354 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
355 idata->send_key, idata->hmac,
356 data, data_len, FALSE, force_send);
359 /* Send the message to clients on the channel's client list. */
360 silc_list_start(channel->user_list);
361 while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END) {
362 client = chl->client;
364 /* If client has router set it is not locally connected client and
365 we will route the message to the router set in the client. Though,
366 send locally connected server in all cases. */
367 if (server->server_type == SILC_ROUTER && client && client->router &&
368 ((!route && client->router->router == server->id_entry) || route)) {
371 /* Check if we have sent the packet to this route already */
372 for (k = 0; k < routed_count; k++)
373 if (routed[k] == client->router)
375 if (k < routed_count)
378 /* Get data used in packet header encryption, keys and stuff. */
379 sock = (SilcSocketConnection)client->router->connection;
380 idata = (SilcIDListData)client->router;
382 /* Send the packet */
383 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
384 idata->send_key, idata->hmac,
385 data, data_len, FALSE,
388 /* We want to make sure that the packet is routed to same router
389 only once. Mark this route as sent route. */
391 routed = silc_realloc(routed, sizeof(*routed) * (k + 1));
392 routed[k] = client->router;
398 if (client && client->router)
401 /* Send to locally connected client */
404 /* Get data used in packet header encryption, keys and stuff. */
405 sock = (SilcSocketConnection)client->connection;
406 idata = (SilcIDListData)client;
408 /* Send the packet */
409 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
410 idata->send_key, idata->hmac,
411 data, data_len, FALSE,
418 silc_free(packetdata.src_id);
419 silc_free(packetdata.dst_id);
422 /* This routine is explicitly used to relay messages to some channel.
423 Packets sent with this function we have received earlier and are
424 totally encrypted. This just sends the packet to all clients on
425 the channel. If the sender of the packet is someone on the channel
426 the message will not be sent to that client. The SILC Packet header
427 is encrypted with the session key shared between us and the client.
428 MAC is also computed before encrypting the header. Rest of the
429 packet will be untouched. */
431 void silc_server_packet_relay_to_channel(SilcServer server,
432 SilcSocketConnection sender_sock,
433 SilcChannelEntry channel,
435 SilcIdType sender_type,
437 unsigned int data_len,
441 SilcSocketConnection sock = NULL;
442 SilcPacketContext packetdata;
443 SilcClientEntry client = NULL;
444 SilcServerEntry *routed = NULL;
445 SilcChannelClientEntry chl;
446 unsigned int routed_count = 0;
447 SilcIDListData idata;
449 SILC_LOG_DEBUG(("Relaying packet to channel"));
451 /* Set the packet context pointers. */
452 packetdata.flags = 0;
453 packetdata.type = SILC_PACKET_CHANNEL_MESSAGE;
454 packetdata.src_id = silc_id_id2str(sender, sender_type);
455 packetdata.src_id_len = silc_id_get_len(sender_type);
456 packetdata.src_id_type = sender_type;
457 packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
458 packetdata.dst_id_len = SILC_ID_CHANNEL_LEN;
459 packetdata.dst_id_type = SILC_ID_CHANNEL;
460 packetdata.rng = server->rng;
461 packetdata.padlen = SILC_PACKET_PADLEN((SILC_PACKET_HEADER_LEN +
462 packetdata.src_id_len +
463 packetdata.dst_id_len));
465 /* If there are global users in the channel we will send the message
466 first to our router for further routing. */
467 if (server->server_type == SILC_SERVER && !server->standalone &&
468 channel->global_users) {
469 SilcServerEntry router;
471 router = server->router;
473 /* Check that the sender is not our router. */
474 if (sender_sock != (SilcSocketConnection)router->connection) {
476 /* Get data used in packet header encryption, keys and stuff. */
477 sock = (SilcSocketConnection)router->connection;
478 idata = (SilcIDListData)router;
480 SILC_LOG_DEBUG(("Sending channel message to router for routing"));
482 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
483 idata->send_key, idata->hmac,
484 data, data_len, TRUE,
489 /* Send the message to clients on the channel's client list. */
490 silc_list_start(channel->user_list);
491 while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END) {
492 client = chl->client;
496 /* If sender is one on the channel do not send it the packet. */
497 if (!found && !SILC_ID_CLIENT_COMPARE(client->id, sender)) {
502 /* If the client has set router it means that it is not locally
503 connected client and we will route the packet further. */
504 if (server->server_type == SILC_ROUTER && client->router) {
507 /* Sender maybe server as well so we want to make sure that
508 we won't send the message to the server it came from. */
509 if (!found && !SILC_ID_SERVER_COMPARE(client->router->id, sender)) {
514 /* Check if we have sent the packet to this route already */
515 for (k = 0; k < routed_count; k++)
516 if (routed[k] == client->router)
518 if (k < routed_count)
521 /* Get data used in packet header encryption, keys and stuff. */
522 sock = (SilcSocketConnection)client->router->connection;
523 idata = (SilcIDListData)client->router;
525 /* Send the packet */
526 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
527 idata->send_key, idata->hmac,
528 data, data_len, TRUE,
531 /* We want to make sure that the packet is routed to same router
532 only once. Mark this route as sent route. */
534 routed = silc_realloc(routed, sizeof(*routed) * (k + 1));
535 routed[k] = client->router;
541 if (server->server_type == SILC_SERVER && client->router)
544 /* Get data used in packet header encryption, keys and stuff. */
545 sock = (SilcSocketConnection)client->connection;
546 idata = (SilcIDListData)client;
548 SILC_LOG_DEBUG(("Sending packet to client %s (%s)",
549 sock->hostname, sock->ip));
551 /* Send the packet */
552 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
553 idata->send_key, idata->hmac,
554 data, data_len, TRUE,
559 silc_free(packetdata.src_id);
560 silc_free(packetdata.dst_id);
563 /* This function is used to send packets strictly to all local clients
564 on a particular channel. This is used for example to distribute new
565 channel key to all our locally connected clients on the channel.
566 The packets are always encrypted with the session key shared between
567 the client, this means these are not _to the channel_ but _to the client_
570 void silc_server_packet_send_local_channel(SilcServer server,
571 SilcChannelEntry channel,
573 SilcPacketFlags flags,
575 unsigned int data_len,
578 SilcChannelClientEntry chl;
579 SilcSocketConnection sock = NULL;
581 SILC_LOG_DEBUG(("Start"));
583 /* Send the message to clients on the channel's client list. */
584 silc_list_start(channel->user_list);
585 while ((chl = silc_list_get(channel->user_list)) != SILC_LIST_END) {
587 sock = (SilcSocketConnection)chl->client->connection;
589 /* Send the packet to the client */
590 silc_server_packet_send_dest(server, sock, type, flags, chl->client->id,
591 SILC_ID_CLIENT, data, data_len,
597 /* Routine used to send (relay, route) private messages to some destination.
598 If the private message key does not exist then the message is re-encrypted,
599 otherwise we just pass it along. This really is not used to send new
600 private messages (as server does not send them) but to relay received
603 void silc_server_send_private_message(SilcServer server,
604 SilcSocketConnection dst_sock,
607 SilcPacketContext *packet)
609 SilcBuffer buffer = packet->buffer;
611 /* Send and re-encrypt if private messge key does not exist */
612 if ((packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY) == FALSE) {
614 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
615 + packet->dst_id_len + packet->padlen);
616 silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
617 silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
619 /* Re-encrypt packet */
620 silc_packet_encrypt(cipher, hmac, dst_sock->outbuf, buffer->len);
622 /* Send the packet */
623 silc_server_packet_send_real(server, dst_sock, FALSE);
626 /* Key exist so just send it */
627 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
628 + packet->dst_id_len + packet->padlen);
629 silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
630 silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
631 silc_server_packet_send_real(server, dst_sock, FALSE);
635 /* Sends current motd to client */
637 void silc_server_send_motd(SilcServer server,
638 SilcSocketConnection sock)
643 if (server->config && server->config->motd &&
644 server->config->motd->motd_file) {
646 motd = silc_file_read(server->config->motd->motd_file, &motd_len);
650 silc_server_send_notify(server, sock, SILC_NOTIFY_TYPE_MOTD, 1,
656 /* Sends error message. Error messages may or may not have any
659 void silc_server_send_error(SilcServer server,
660 SilcSocketConnection sock,
661 const char *fmt, ...)
664 unsigned char buf[4096];
666 memset(buf, 0, sizeof(buf));
668 vsprintf(buf, fmt, ap);
671 silc_server_packet_send(server, sock, SILC_PACKET_ERROR, 0,
672 buf, strlen(buf), FALSE);
675 /* Sends notify message. If format is TRUE the variable arguments are
676 formatted and the formatted string is sent as argument payload. If it is
677 FALSE then each argument is sent as separate argument and their format
678 in the argument list must be { argument data, argument length }. */
680 void silc_server_send_notify(SilcServer server,
681 SilcSocketConnection sock,
683 unsigned int argc, ...)
690 packet = silc_notify_payload_encode(type, argc, ap);
691 silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY, 0,
692 packet->data, packet->len, FALSE);
693 silc_buffer_free(packet);
696 /* Sends notify message destined to specific entity. */
698 void silc_server_send_notify_dest(SilcServer server,
699 SilcSocketConnection sock,
701 SilcIdType dest_id_type,
703 unsigned int argc, ...)
710 packet = silc_notify_payload_encode(type, argc, ap);
711 silc_server_packet_send_dest(server, sock, SILC_PACKET_NOTIFY, 0,
712 dest_id, dest_id_type,
713 packet->data, packet->len, FALSE);
714 silc_buffer_free(packet);
717 /* Sends notify message to a channel. The notify message sent is
718 distributed to all clients on the channel. If `router_notify' is TRUE
719 then the notify may be routed to primary route or to some other routers.
720 If FALSE it is assured that the notify is sent only locally. */
722 void silc_server_send_notify_to_channel(SilcServer server,
723 SilcChannelEntry channel,
724 unsigned char route_notify,
726 unsigned int argc, ...)
733 packet = silc_notify_payload_encode(type, argc, ap);
734 silc_server_packet_send_to_channel(server, channel,
735 SILC_PACKET_NOTIFY, route_notify,
736 packet->data, packet->len, FALSE);
737 silc_buffer_free(packet);
740 /* Send notify message to all clients the client has joined. It is quaranteed
741 that the message is sent only once to a client (ie. if a client is joined
742 on two same channel it will receive only one notify message). Also, this
743 sends only to local clients (locally connected if we are server, and to
744 local servers if we are router). */
746 void silc_server_send_notify_on_channels(SilcServer server,
747 SilcClientEntry client,
749 unsigned int argc, ...)
752 SilcSocketConnection sock = NULL;
753 SilcPacketContext packetdata;
755 SilcClientEntry *sent_clients = NULL;
756 unsigned int sent_clients_count = 0;
757 SilcServerEntry *routed = NULL;
758 unsigned int routed_count = 0;
759 SilcChannelEntry channel;
760 SilcChannelClientEntry chl, chl2;
761 SilcIDListData idata;
764 unsigned int data_len;
765 int force_send = FALSE;
768 SILC_LOG_DEBUG(("Start"));
770 if (!silc_list_count(client->channels))
774 packet = silc_notify_payload_encode(type, argc, ap);
776 data_len = packet->len;
778 /* Set the packet context pointers. */
779 packetdata.flags = 0;
780 packetdata.type = SILC_PACKET_NOTIFY;
781 packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
782 packetdata.src_id_len = SILC_ID_SERVER_LEN;
783 packetdata.src_id_type = SILC_ID_SERVER;
784 packetdata.rng = server->rng;
786 silc_list_start(client->channels);
787 while ((chl = silc_list_get(client->channels)) != SILC_LIST_END) {
788 channel = chl->channel;
790 /* Send the message to all clients on the channel's client list. */
791 silc_list_start(channel->user_list);
792 while ((chl2 = silc_list_get(channel->user_list)) != SILC_LIST_END) {
795 /* Check if we have sent the packet to this client already */
796 for (k = 0; k < sent_clients_count; k++)
797 if (sent_clients[k] == c)
799 if (k < sent_clients_count)
802 /* If we are router and if this client has router set it is not
803 locally connected client and we will route the message to the
804 router set in the client. */
805 if (c && c->router && server->server_type == SILC_ROUTER) {
806 /* Check if we have sent the packet to this route already */
807 for (k = 0; k < routed_count; k++)
808 if (routed[k] == c->router)
810 if (k < routed_count)
813 /* Get data used in packet header encryption, keys and stuff. */
814 sock = (SilcSocketConnection)c->router->connection;
815 idata = (SilcIDListData)c->router;
817 packetdata.dst_id = silc_id_id2str(c->router->id, SILC_ID_SERVER);
818 packetdata.dst_id_len = SILC_ID_SERVER_LEN;
819 packetdata.dst_id_type = SILC_ID_SERVER;
820 packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
821 packetdata.src_id_len + packetdata.dst_id_len;
822 packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen);
824 /* Send the packet */
825 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
826 idata->send_key, idata->hmac,
827 data, data_len, FALSE,
830 silc_free(packetdata.dst_id);
832 /* We want to make sure that the packet is routed to same router
833 only once. Mark this route as sent route. */
835 routed = silc_realloc(routed, sizeof(*routed) * (k + 1));
836 routed[k] = c->router;
842 if (server->server_type == SILC_SERVER && client->router)
845 /* Send to locally connected client */
848 /* Get data used in packet header encryption, keys and stuff. */
849 sock = (SilcSocketConnection)c->connection;
850 idata = (SilcIDListData)c;
852 packetdata.dst_id = silc_id_id2str(c->id, SILC_ID_CLIENT);
853 packetdata.dst_id_len = SILC_ID_CLIENT_LEN;
854 packetdata.dst_id_type = SILC_ID_CLIENT;
855 packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
856 packetdata.src_id_len + packetdata.dst_id_len;
857 packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen);
859 /* Send the packet */
860 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
861 idata->send_key, idata->hmac,
862 data, data_len, FALSE,
865 silc_free(packetdata.dst_id);
867 /* Make sure that we send the notify only once per client. */
868 sent_clients = silc_realloc(sent_clients, sizeof(*sent_clients) *
869 (sent_clients_count + 1));
870 sent_clients[sent_clients_count] = c;
871 sent_clients_count++;
878 if (sent_clients_count)
879 silc_free(sent_clients);
880 silc_free(packetdata.src_id);
883 /* Sends New ID Payload to remote end. The packet is used to distribute
884 information about new registered clients, servers, channel etc. usually
885 to routers so that they can keep these information up to date.
886 If the argument `broadcast' is TRUE then the packet is sent as
889 void silc_server_send_new_id(SilcServer server,
890 SilcSocketConnection sock,
892 void *id, SilcIdType id_type,
897 SILC_LOG_DEBUG(("Start"));
899 idp = silc_id_payload_encode(id, id_type);
900 silc_server_packet_send(server, sock, SILC_PACKET_NEW_ID,
901 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
902 idp->data, idp->len, FALSE);
903 silc_buffer_free(idp);
906 /* Sends Replace ID payload to remote end. This is used to replace old
907 ID with new ID sent in the packet. This is called for example when
908 user changes nickname and we create new ID for the user. If the
909 argument `broadcast' is TRUE then the packet is sent as
911 /* XXX It would be expected that the new id is same type as the old
914 void silc_server_send_replace_id(SilcServer server,
915 SilcSocketConnection sock,
917 void *old_id, SilcIdType old_id_type,
918 unsigned int old_id_len,
919 void *new_id, SilcIdType new_id_type,
920 unsigned int new_id_len)
926 SILC_LOG_DEBUG(("Start"));
928 oid = silc_id_id2str(old_id, old_id_type);
932 nid = silc_id_id2str(new_id, new_id_type);
936 packet = silc_buffer_alloc(2 + 2 + 2 + 2 + old_id_len + new_id_len);
937 silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
938 silc_buffer_format(packet,
939 SILC_STR_UI_SHORT(old_id_type),
940 SILC_STR_UI_SHORT(old_id_len),
941 SILC_STR_UI_XNSTRING(oid, old_id_len),
942 SILC_STR_UI_SHORT(new_id_type),
943 SILC_STR_UI_SHORT(new_id_len),
944 SILC_STR_UI_XNSTRING(nid, new_id_len),
947 silc_server_packet_send(server, sock, SILC_PACKET_REPLACE_ID,
948 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
949 packet->data, packet->len, FALSE);
952 silc_buffer_free(packet);
955 /* This function is used to send Remove Channel User payload. This may sent
956 by server but is usually used only by router to notify other routers that
957 user has left a channel. Normal server sends this packet to its router
958 to notify that the router should not hold a record about this client
959 on a channel anymore. Router distributes it further to other routers. */
961 void silc_server_send_remove_channel_user(SilcServer server,
962 SilcSocketConnection sock,
964 void *client_id, void *channel_id)
967 unsigned char *clid, *chid;
969 SILC_LOG_DEBUG(("Start"));
971 clid = silc_id_id2str(client_id, SILC_ID_CLIENT);
975 chid = silc_id_id2str(channel_id, SILC_ID_CHANNEL);
979 packet = silc_buffer_alloc(2 + 2 + SILC_ID_CLIENT_LEN + SILC_ID_CHANNEL_LEN);
980 silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
981 silc_buffer_format(packet,
982 SILC_STR_UI_SHORT(SILC_ID_CLIENT_LEN),
983 SILC_STR_UI_XNSTRING(clid, SILC_ID_CLIENT_LEN),
984 SILC_STR_UI_SHORT(SILC_ID_CHANNEL_LEN),
985 SILC_STR_UI_XNSTRING(chid, SILC_ID_CHANNEL_LEN),
988 silc_server_packet_send(server, sock, SILC_PACKET_REMOVE_CHANNEL_USER,
989 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
990 packet->data, packet->len, FALSE);
993 silc_buffer_free(packet);
996 /* Send New Channel Payload to notify about newly created channel in the
997 SILC network. Normal server nevers sends this packet. Router uses this
998 to notify other routers in the network about new channel. This packet
1001 void silc_server_send_new_channel(SilcServer server,
1002 SilcSocketConnection sock,
1006 unsigned int channel_id_len)
1010 unsigned int name_len = strlen(channel_name);
1012 SILC_LOG_DEBUG(("Start"));
1014 cid = silc_id_id2str(channel_id, SILC_ID_CHANNEL);
1018 packet = silc_buffer_alloc(2 + 2 + name_len + channel_id_len);
1019 silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1020 silc_buffer_format(packet,
1021 SILC_STR_UI_SHORT(name_len),
1022 SILC_STR_UI_XNSTRING(channel_name, name_len),
1023 SILC_STR_UI_SHORT(channel_id_len),
1024 SILC_STR_UI_XNSTRING(cid, channel_id_len),
1027 silc_server_packet_send(server, sock, SILC_PACKET_NEW_CHANNEL,
1028 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1029 packet->data, packet->len, FALSE);
1032 silc_buffer_free(packet);
1035 /* Send New Channel User payload to notify routers in the network about new
1036 user on the channel. The packet is may be broadcasted. Normal server
1037 can send this but must not receive. Router can send and receive it. */
1039 void silc_server_send_new_channel_user(SilcServer server,
1040 SilcSocketConnection sock,
1043 unsigned int channel_id_len,
1045 unsigned int client_id_len)
1048 unsigned char *clid, *chid;
1050 SILC_LOG_DEBUG(("Start"));
1052 chid = silc_id_id2str(channel_id, SILC_ID_CHANNEL);
1056 clid = silc_id_id2str(client_id, SILC_ID_CLIENT);
1060 packet = silc_buffer_alloc(2 + 2 + channel_id_len + client_id_len);
1061 silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1062 silc_buffer_format(packet,
1063 SILC_STR_UI_SHORT(channel_id_len),
1064 SILC_STR_UI_XNSTRING(chid, channel_id_len),
1065 SILC_STR_UI_SHORT(client_id_len),
1066 SILC_STR_UI_XNSTRING(clid, client_id_len),
1069 silc_server_packet_send(server, sock, SILC_PACKET_NEW_CHANNEL_USER,
1070 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1071 packet->data, packet->len, FALSE);
1074 silc_buffer_free(packet);
1077 /* Send Channel Key payload to distribute the new channel key. Normal server
1078 sends this to router when new client joins to existing channel. Router
1079 sends this to the local server who sent the join command in case where
1080 the channel did not exist yet. Both normal and router servers uses this
1081 also to send this to locally connected clients on the channel. This
1082 must not be broadcasted packet. Routers do not send this to each other. */
1084 void silc_server_send_channel_key(SilcServer server,
1085 SilcChannelEntry channel,
1086 unsigned char route)
1089 unsigned char *chid;
1090 unsigned int tmp_len;
1092 SILC_LOG_DEBUG(("Start"));
1094 chid = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
1098 /* Encode channel key packet */
1099 tmp_len = strlen(channel->channel_key->cipher->name);
1100 packet = silc_channel_key_payload_encode(SILC_ID_CHANNEL_LEN, chid, tmp_len,
1101 channel->channel_key->cipher->name,
1102 channel->key_len / 8, channel->key);
1104 silc_server_packet_send_to_channel(server, channel, SILC_PACKET_CHANNEL_KEY,
1105 route, packet->data, packet->len, FALSE);
1106 silc_buffer_free(packet);
1110 /* Generic function to send any command. The arguments must be sent already
1111 encoded into correct form in correct order. */
1113 void silc_server_send_command(SilcServer server,
1114 SilcSocketConnection sock,
1115 SilcCommand command,
1116 unsigned int argc, ...)
1123 packet = silc_command_payload_encode_vap(command, 0, argc, ap);
1124 silc_server_packet_send(server, sock, SILC_PACKET_COMMAND, 0,
1125 packet->data, packet->len, TRUE);
1126 silc_buffer_free(packet);
1129 /* Function used to send REMOVE_ID packet. The packet is used to notify
1130 routers that certain ID should be removed. After that the ID will become
1131 invalid. If the argument `broadcast' is TRUE then the packet is sent as
1132 broadcast packet. */
1134 void silc_server_send_remove_id(SilcServer server,
1135 SilcSocketConnection sock,
1137 void *id, unsigned int id_len,
1142 SILC_LOG_DEBUG(("Start"));
1144 idp = silc_id_payload_encode(id, id_type);
1145 silc_server_packet_send(server, sock, SILC_PACKET_REMOVE_ID,
1146 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1147 idp->data, idp->len, FALSE);
1148 silc_buffer_free(idp);