5 Author: Pekka Riikonen <priikone@silcnet.org>
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 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,
38 /* If disconnecting, ignore the data */
39 if (SILC_IS_DISCONNECTING(sock))
42 /* If rekey protocol is active we must assure that all packets are
43 sent through packet queue. */
44 if (SILC_SERVER_IS_REKEY(sock))
47 /* If outbound data is already pending do not force send */
48 if (SILC_IS_OUTBUF_PENDING(sock))
52 ret = silc_packet_send(sock, force_send);
56 /* Mark that there is some outgoing data available for this connection.
57 This call sets the connection both for input and output (the input
58 is set always and this call keeps the input setting, actually).
59 Actual data sending is performed by silc_server_packet_process. */
60 SILC_SET_CONNECTION_FOR_OUTPUT(server->schedule, sock->sock);
62 /* Mark to socket that data is pending in outgoing buffer. This flag
63 is needed if new data is added to the buffer before the earlier
64 put data is sent to the network. */
65 SILC_SET_OUTBUF_PENDING(sock);
70 /* Assembles a new packet to be sent out to network. This doesn't actually
71 send the packet but creates the packet and fills the outgoing data
72 buffer and marks the packet ready to be sent to network. However, If
73 argument force_send is TRUE the packet is sent immediately and not put
74 to queue. Normal case is that the packet is not sent immediately. */
76 void silc_server_packet_send(SilcServer server,
77 SilcSocketConnection sock,
79 SilcPacketFlags flags,
85 SilcIdType dst_id_type = SILC_ID_NONE;
86 SilcIDListData idata = (SilcIDListData)sock->user_data;
91 /* If disconnecting, ignore the data */
92 if (SILC_IS_DISCONNECTING(sock))
95 /* If entry is disabled do not sent anything. */
96 if (idata && idata->status & SILC_IDLIST_STATUS_DISABLED)
99 /* Get data used in the packet sending, keys and stuff */
101 case SILC_SOCKET_TYPE_CLIENT:
102 if (sock->user_data) {
103 dst_id = ((SilcClientEntry)sock->user_data)->id;
104 dst_id_type = SILC_ID_CLIENT;
107 case SILC_SOCKET_TYPE_SERVER:
108 case SILC_SOCKET_TYPE_ROUTER:
109 if (sock->user_data) {
110 dst_id = ((SilcServerEntry)sock->user_data)->id;
111 dst_id_type = SILC_ID_SERVER;
118 silc_server_packet_send_dest(server, sock, type, flags, dst_id,
119 dst_id_type, data, data_len, force_send);
122 /* Assembles a new packet to be sent out to network. This doesn't actually
123 send the packet but creates the packet and fills the outgoing data
124 buffer and marks the packet ready to be sent to network. However, If
125 argument force_send is TRUE the packet is sent immediately and not put
126 to queue. Normal case is that the packet is not sent immediately.
127 Destination information is sent as argument for this function. */
129 void silc_server_packet_send_dest(SilcServer server,
130 SilcSocketConnection sock,
132 SilcPacketFlags flags,
134 SilcIdType dst_id_type,
139 SilcPacketContext packetdata;
140 SilcIDListData idata = (SilcIDListData)sock->user_data;
141 SilcCipher cipher = NULL;
142 SilcHmac hmac = NULL;
144 unsigned char *dst_id_data = NULL;
145 uint32 dst_id_len = 0;
148 /* If disconnecting, ignore the data */
149 if (SILC_IS_DISCONNECTING(sock))
152 /* If entry is disabled do not sent anything. */
153 if (idata && idata->status & SILC_IDLIST_STATUS_DISABLED)
156 SILC_LOG_DEBUG(("Sending packet, type %d", type));
159 dst_id_data = silc_id_id2str(dst_id, dst_id_type);
160 dst_id_len = silc_id_get_len(dst_id, dst_id_type);
164 cipher = idata->send_key;
165 hmac = idata->hmac_send;
166 sequence = idata->psn_send++;
167 block_len = silc_cipher_get_block_len(cipher);
170 /* Set the packet context pointers */
171 packetdata.type = type;
172 packetdata.flags = flags;
173 packetdata.src_id = silc_id_id2str(server->id, server->id_type);
174 packetdata.src_id_len = silc_id_get_len(server->id, server->id_type);
175 packetdata.src_id_type = server->id_type;
176 packetdata.dst_id = dst_id_data;
177 packetdata.dst_id_len = dst_id_len;
178 packetdata.dst_id_type = dst_id_type;
179 packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
180 packetdata.src_id_len + dst_id_len;
181 packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen, block_len);
183 /* Prepare outgoing data buffer for packet sending */
184 silc_packet_send_prepare(sock,
185 SILC_PACKET_HEADER_LEN +
186 packetdata.src_id_len +
187 packetdata.dst_id_len,
191 SILC_LOG_DEBUG(("Putting data to outgoing buffer, len %d", data_len));
193 packetdata.buffer = sock->outbuf;
195 /* Put the data to the buffer */
196 if (data && data_len)
197 silc_buffer_put(sock->outbuf, data, data_len);
199 /* Create the outgoing packet */
200 silc_packet_assemble(&packetdata, cipher);
202 /* Encrypt the packet */
203 silc_packet_encrypt(cipher, hmac, sequence, sock->outbuf, sock->outbuf->len);
205 SILC_LOG_HEXDUMP(("Outgoing packet (%d), len %d", sequence,
207 sock->outbuf->data, sock->outbuf->len);
209 /* Now actually send the packet */
210 silc_server_packet_send_real(server, sock, force_send);
212 if (packetdata.src_id)
213 silc_free(packetdata.src_id);
214 if (packetdata.dst_id)
215 silc_free(packetdata.dst_id);
218 /* Assembles a new packet to be sent out to network. This doesn't actually
219 send the packet but creates the packet and fills the outgoing data
220 buffer and marks the packet ready to be sent to network. However, If
221 argument force_send is TRUE the packet is sent immediately and not put
222 to queue. Normal case is that the packet is not sent immediately.
223 The source and destination information is sent as argument for this
226 void silc_server_packet_send_srcdest(SilcServer server,
227 SilcSocketConnection sock,
229 SilcPacketFlags flags,
231 SilcIdType src_id_type,
233 SilcIdType dst_id_type,
238 SilcPacketContext packetdata;
239 SilcIDListData idata;
240 SilcCipher cipher = NULL;
241 SilcHmac hmac = NULL;
243 unsigned char *dst_id_data = NULL;
244 uint32 dst_id_len = 0;
245 unsigned char *src_id_data = NULL;
246 uint32 src_id_len = 0;
249 SILC_LOG_DEBUG(("Sending packet, type %d", type));
251 /* Get data used in the packet sending, keys and stuff */
252 idata = (SilcIDListData)sock->user_data;
255 dst_id_data = silc_id_id2str(dst_id, dst_id_type);
256 dst_id_len = silc_id_get_len(dst_id, dst_id_type);
260 src_id_data = silc_id_id2str(src_id, src_id_type);
261 src_id_len = silc_id_get_len(src_id, src_id_type);
265 cipher = idata->send_key;
266 hmac = idata->hmac_send;
267 sequence = idata->psn_send++;
268 block_len = silc_cipher_get_block_len(cipher);
271 /* Set the packet context pointers */
272 packetdata.type = type;
273 packetdata.flags = flags;
274 packetdata.src_id = src_id_data;
275 packetdata.src_id_len = src_id_len;
276 packetdata.src_id_type = src_id_type;
277 packetdata.dst_id = dst_id_data;
278 packetdata.dst_id_len = dst_id_len;
279 packetdata.dst_id_type = dst_id_type;
280 packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
281 packetdata.src_id_len + dst_id_len;
282 packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen, block_len);
284 /* Prepare outgoing data buffer for packet sending */
285 silc_packet_send_prepare(sock,
286 SILC_PACKET_HEADER_LEN +
287 packetdata.src_id_len +
288 packetdata.dst_id_len,
292 SILC_LOG_DEBUG(("Putting data to outgoing buffer, len %d", data_len));
294 packetdata.buffer = sock->outbuf;
296 /* Put the data to the buffer */
297 if (data && data_len)
298 silc_buffer_put(sock->outbuf, data, data_len);
300 /* Create the outgoing packet */
301 silc_packet_assemble(&packetdata, cipher);
303 /* Encrypt the packet */
304 silc_packet_encrypt(cipher, hmac, sequence, sock->outbuf, sock->outbuf->len);
306 SILC_LOG_HEXDUMP(("Outgoing packet (%d), len %d", sequence,
308 sock->outbuf->data, sock->outbuf->len);
310 /* Now actually send the packet */
311 silc_server_packet_send_real(server, sock, force_send);
313 if (packetdata.src_id)
314 silc_free(packetdata.src_id);
315 if (packetdata.dst_id)
316 silc_free(packetdata.dst_id);
319 /* Broadcast received packet to our primary route. This function is used
320 by router to further route received broadcast packet. It is expected
321 that the broadcast flag from the packet is checked before calling this
322 function. This does not test or set the broadcast flag. */
324 void silc_server_packet_broadcast(SilcServer server,
325 SilcSocketConnection sock,
326 SilcPacketContext *packet)
328 SilcBuffer buffer = packet->buffer;
329 SilcIDListData idata;
332 SILC_LOG_DEBUG(("Broadcasting received broadcast packet"));
334 /* If the packet is originated from our primary route we are
335 not allowed to send the packet. */
336 id = silc_id_str2id(packet->src_id, packet->src_id_len, packet->src_id_type);
337 if (id && !SILC_ID_SERVER_COMPARE(id, server->router->id)) {
338 idata = (SilcIDListData)sock->user_data;
340 silc_buffer_push(buffer, buffer->data - buffer->head);
341 silc_packet_send_prepare(sock, 0, 0, buffer->len);
342 silc_buffer_put(sock->outbuf, buffer->data, buffer->len);
343 silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
344 sock->outbuf, sock->outbuf->len);
346 SILC_LOG_HEXDUMP(("Broadcasted packet (%d), len %d", idata->psn_send - 1,
348 sock->outbuf->data, sock->outbuf->len);
350 /* Now actually send the packet */
351 silc_server_packet_send_real(server, sock, TRUE);
356 SILC_LOG_DEBUG(("Will not broadcast to primary route since it is the "
357 "original sender of this packet"));
361 /* Routes received packet to `sock'. This is used to route the packets that
362 router receives but are not destined to it. */
364 void silc_server_packet_route(SilcServer server,
365 SilcSocketConnection sock,
366 SilcPacketContext *packet)
368 SilcBuffer buffer = packet->buffer;
369 SilcIDListData idata;
371 SILC_LOG_DEBUG(("Routing received packet"));
373 idata = (SilcIDListData)sock->user_data;
375 silc_buffer_push(buffer, buffer->data - buffer->head);
376 silc_packet_send_prepare(sock, 0, 0, buffer->len);
377 silc_buffer_put(sock->outbuf, buffer->data, buffer->len);
378 silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
379 sock->outbuf, sock->outbuf->len);
381 SILC_LOG_HEXDUMP(("Routed packet (%d), len %d", idata->psn_send - 1,
383 sock->outbuf->data, sock->outbuf->len);
385 /* Now actually send the packet */
386 silc_server_packet_send_real(server, sock, TRUE);
389 /* This routine can be used to send a packet to table of clients provided
390 in `clients'. If `route' is FALSE the packet is routed only to local
391 clients (for server locally connected, and for router local cell). */
393 void silc_server_packet_send_clients(SilcServer server,
394 SilcClientEntry *clients,
395 uint32 clients_count,
397 SilcPacketFlags flags,
403 SilcSocketConnection sock = NULL;
404 SilcClientEntry client = NULL;
405 SilcServerEntry *routed = NULL;
406 uint32 routed_count = 0;
410 SILC_LOG_DEBUG(("Sending packet to list of clients"));
412 /* Send to all clients in table */
413 for (i = 0; i < clients_count; i++) {
416 /* If client has router set it is not locally connected client and
417 we will route the message to the router set in the client. Though,
418 send locally connected server in all cases. */
419 if (server->server_type == SILC_ROUTER && client->router &&
420 ((!route && client->router->router == server->id_entry) || route)) {
422 /* Check if we have sent the packet to this route already */
423 for (k = 0; k < routed_count; k++)
424 if (routed[k] == client->router)
426 if (k < routed_count)
429 /* Route only once to router */
430 sock = (SilcSocketConnection)client->router->connection;
431 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
437 /* Send the packet */
438 silc_server_packet_send_dest(server, sock, type, flags,
439 client->router->id, SILC_ID_SERVER,
440 data, data_len, force_send);
442 /* Mark this route routed already */
443 routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
444 routed[routed_count++] = client->router;
451 /* Send to locally connected client */
452 sock = (SilcSocketConnection)client->connection;
453 silc_server_packet_send_dest(server, sock, type, flags,
454 client->id, SILC_ID_CLIENT,
455 data, data_len, force_send);
461 /* Internal routine to actually create the channel packet and send it
462 to network. This is common function in channel message sending. If
463 `channel_message' is TRUE this encrypts the message as it is strictly
464 a channel message. If FALSE normal encryption process is used. */
467 silc_server_packet_send_to_channel_real(SilcServer server,
468 SilcSocketConnection sock,
469 SilcPacketContext *packet,
475 bool channel_message,
483 packet->truelen = data_len + SILC_PACKET_HEADER_LEN +
484 packet->src_id_len + packet->dst_id_len;
486 block_len = cipher ? silc_cipher_get_block_len(cipher) : 0;
488 packet->padlen = SILC_PACKET_PADLEN((SILC_PACKET_HEADER_LEN +
490 packet->dst_id_len), block_len);
492 packet->padlen = SILC_PACKET_PADLEN(packet->truelen, block_len);
494 /* Prepare outgoing data buffer for packet sending */
495 silc_packet_send_prepare(sock,
496 SILC_PACKET_HEADER_LEN +
502 packet->buffer = sock->outbuf;
504 /* Put the data to buffer, assemble and encrypt the packet. The packet
505 is encrypted with normal session key shared with the client, unless
506 the `channel_message' is TRUE. */
507 silc_buffer_put(sock->outbuf, data, data_len);
508 silc_packet_assemble(packet, cipher);
510 silc_packet_encrypt(cipher, hmac, sequence, sock->outbuf,
511 SILC_PACKET_HEADER_LEN + packet->src_id_len +
512 packet->dst_id_len + packet->padlen);
514 silc_packet_encrypt(cipher, hmac, sequence, sock->outbuf,
517 SILC_LOG_HEXDUMP(("Channel packet (%d), len %d", sequence,
519 sock->outbuf->data, sock->outbuf->len);
521 /* Now actually send the packet */
522 silc_server_packet_send_real(server, sock, force_send);
525 /* This routine is used by the server to send packets to channel. The
526 packet sent with this function is distributed to all clients on
527 the channel. Usually this is used to send notify messages to the
528 channel, things like notify about new user joining to the channel.
529 If `route' is FALSE then the packet is sent only locally and will not
530 be routed anywhere (for router locally means cell wide). If `sender'
531 is provided then the packet is not sent to that connection since it
532 originally came from it. If `send_to_clients' is FALSE then the
533 packet is not sent clients, only servers. */
535 void silc_server_packet_send_to_channel(SilcServer server,
536 SilcSocketConnection sender,
537 SilcChannelEntry channel,
544 SilcSocketConnection sock = NULL;
545 SilcPacketContext packetdata;
546 SilcClientEntry client = NULL;
547 SilcServerEntry *routed = NULL;
548 SilcChannelClientEntry chl;
549 SilcHashTableList htl;
550 SilcIDListData idata;
551 uint32 routed_count = 0;
555 /* This doesn't send channel message packets */
556 assert(type != SILC_PACKET_CHANNEL_MESSAGE);
558 SILC_LOG_DEBUG(("Sending packet to channel"));
560 /* Set the packet context pointers. */
561 packetdata.flags = 0;
562 packetdata.type = type;
563 packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
564 packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
565 packetdata.src_id_type = SILC_ID_SERVER;
566 packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
567 packetdata.dst_id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
568 packetdata.dst_id_type = SILC_ID_CHANNEL;
570 /* If there are global users in the channel we will send the message
571 first to our router for further routing. */
572 if (route && server->server_type != SILC_ROUTER && !server->standalone &&
573 channel->global_users) {
574 SilcServerEntry router;
576 /* Get data used in packet header encryption, keys and stuff. */
577 router = server->router;
578 sock = (SilcSocketConnection)router->connection;
579 idata = (SilcIDListData)router;
581 if (sock != sender) {
582 SILC_LOG_DEBUG(("Sending packet to router for routing"));
584 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
588 data, data_len, FALSE,
593 routed = silc_calloc(silc_hash_table_count(channel->user_list),
596 /* Send the message to clients on the channel's client list. */
597 silc_hash_table_list(channel->user_list, &htl);
598 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
599 client = chl->client;
603 /* If client has router set it is not locally connected client and
604 we will route the message to the router set in the client. Though,
605 send locally connected server in all cases. */
606 if (server->server_type == SILC_ROUTER && client->router &&
607 ((!route && client->router->router == server->id_entry) || route)) {
609 /* Check if we have sent the packet to this route already */
610 for (k = 0; k < routed_count; k++)
611 if (routed[k] == client->router)
613 if (k < routed_count)
616 /* Get data used in packet header encryption, keys and stuff. */
617 sock = (SilcSocketConnection)client->router->connection;
618 idata = (SilcIDListData)client->router;
620 if (sender && sock == sender)
623 /* Route only once to router */
624 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
630 /* Send the packet */
631 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
635 data, data_len, FALSE,
638 /* Mark this route routed already */
639 routed[routed_count++] = client->router;
646 /* Send to locally connected client */
648 /* Get data used in packet header encryption, keys and stuff. */
649 sock = (SilcSocketConnection)client->connection;
650 idata = (SilcIDListData)client;
652 if (sender && sock == sender)
655 /* Send the packet */
656 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
660 data, data_len, FALSE,
664 silc_hash_table_list_reset(&htl);
666 silc_free(packetdata.src_id);
667 silc_free(packetdata.dst_id);
670 /* This checks whether the relayed packet came from router. If it did
671 then we'll need to encrypt it with the channel key. This is called
672 from the silc_server_packet_relay_to_channel. */
675 silc_server_packet_relay_to_channel_encrypt(SilcServer server,
676 SilcSocketConnection sock,
677 SilcChannelEntry channel,
679 unsigned int data_len)
681 /* If we are router and the packet came from router and private key
682 has not been set for the channel then we must encrypt the packet
683 as it was decrypted with the session key shared between us and the
684 router which sent it. This is so, because cells does not share the
686 if (server->server_type == SILC_ROUTER &&
687 sock->type == SILC_SOCKET_TYPE_ROUTER &&
688 !(channel->mode & SILC_CHANNEL_MODE_PRIVKEY) &&
689 channel->channel_key) {
694 iv_len = silc_cipher_get_block_len(channel->channel_key);
695 if (channel->iv[0] == '\0')
696 for (i = 0; i < iv_len; i++) channel->iv[i] =
697 silc_rng_get_byte(server->rng);
699 silc_hash_make(server->md5hash, channel->iv, iv_len, channel->iv);
701 /* Encode new payload. This encrypts it also. */
702 SILC_GET16_MSB(flags, data);
703 SILC_GET16_MSB(dlen, data + 2);
705 if (dlen > data_len) {
706 SILC_LOG_WARNING(("Corrupted channel message, cannot relay it"));
710 chp = silc_channel_message_payload_encode(flags, dlen, data + 4,
712 channel->channel_key,
714 memcpy(data, chp->data, chp->len);
715 silc_buffer_free(chp);
721 /* This routine is explicitly used to relay messages to some channel.
722 Packets sent with this function we have received earlier and are
723 totally encrypted. This just sends the packet to all clients on
724 the channel. If the sender of the packet is someone on the channel
725 the message will not be sent to that client. The SILC Packet header
726 is encrypted with the session key shared between us and the client.
727 MAC is also computed before encrypting the header. Rest of the
728 packet will be untouched. */
730 void silc_server_packet_relay_to_channel(SilcServer server,
731 SilcSocketConnection sender_sock,
732 SilcChannelEntry channel,
734 SilcIdType sender_type,
741 SilcSocketConnection sock = NULL;
742 SilcPacketContext packetdata;
743 SilcClientEntry client = NULL;
744 SilcServerEntry *routed = NULL;
745 SilcChannelClientEntry chl;
746 uint32 routed_count = 0;
747 SilcIDListData idata;
748 SilcHashTableList htl;
752 SILC_LOG_DEBUG(("Relaying packet to channel"));
754 /* This encrypts the packet, if needed. It will be encrypted if
755 it came from the router thus it needs to be encrypted with the
756 channel key. If the channel key does not exist, then we know we
757 don't have a single local user on the channel. */
758 if (!silc_server_packet_relay_to_channel_encrypt(server, sender_sock,
763 /* Set the packet context pointers. */
764 packetdata.flags = 0;
765 packetdata.type = SILC_PACKET_CHANNEL_MESSAGE;
766 packetdata.src_id = silc_id_id2str(sender, sender_type);
767 packetdata.src_id_len = silc_id_get_len(sender, sender_type);
768 packetdata.src_id_type = sender_type;
769 packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
770 packetdata.dst_id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
771 packetdata.dst_id_type = SILC_ID_CHANNEL;
773 /* If there are global users in the channel we will send the message
774 first to our router for further routing. */
775 if (server->server_type != SILC_ROUTER && !server->standalone &&
776 channel->global_users) {
777 SilcServerEntry router = server->router;
779 /* Check that the sender is not our router. */
780 if (sender_sock != (SilcSocketConnection)router->connection) {
782 /* Get data used in packet header encryption, keys and stuff. */
783 sock = (SilcSocketConnection)router->connection;
784 idata = (SilcIDListData)router;
786 SILC_LOG_DEBUG(("Sending channel message to router for routing"));
788 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
792 data, data_len, TRUE,
797 routed = silc_calloc(silc_hash_table_count(channel->user_list),
800 /* Mark that to the route the original sender if from is not routed */
801 if (sender_type == SILC_ID_CLIENT) {
802 client = (SilcClientEntry)sender_entry;
803 if (client->router) {
804 routed[routed_count++] = client->router;
805 SILC_LOG_DEBUG(("************* router %s",
806 silc_id_render(client->router->id, SILC_ID_SERVER)));
810 /* Send the message to clients on the channel's client list. */
811 silc_hash_table_list(channel->user_list, &htl);
812 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
813 client = chl->client;
817 /* Do not send to the sender */
818 if (!found && client == sender_entry) {
823 /* If the client has set router it means that it is not locally
824 connected client and we will route the packet further. */
825 if (server->server_type == SILC_ROUTER && client->router) {
827 /* Sender maybe server as well so we want to make sure that
828 we won't send the message to the server it came from. */
829 if (!found && SILC_ID_SERVER_COMPARE(client->router->id, sender)) {
831 routed[routed_count++] = client->router;
835 /* Check if we have sent the packet to this route already */
836 for (k = 0; k < routed_count; k++)
837 if (routed[k] == client->router)
839 if (k < routed_count)
842 /* Get data used in packet header encryption, keys and stuff. */
843 sock = (SilcSocketConnection)client->router->connection;
844 idata = (SilcIDListData)client->router;
846 /* Do not send to the sender. Check first whether the true
847 sender's router is same as this client's router. Also check
848 if the sender socket is the same as this client's router
851 ((SilcClientEntry)sender_entry)->router == client->router)
853 if (sender_sock && sock == sender_sock)
856 SILC_LOG_DEBUG(("Relaying packet to client ID(%s) %s (%s)",
857 silc_id_render(client->id, SILC_ID_CLIENT),
858 sock->hostname, sock->ip));
860 /* Mark this route routed already. */
861 routed[routed_count++] = client->router;
863 /* If the remote connection is router then we'll decrypt the
864 channel message and re-encrypt it with the session key shared
865 between us and the remote router. This is done because the
866 channel keys are cell specific and we have different channel
867 key than the remote router has. */
868 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
872 SILC_LOG_DEBUG(("Remote is router, encrypt with session key"));
875 /* If private key mode is not set then decrypt the packet
877 if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
878 unsigned char *tmp = silc_calloc(data_len, sizeof(*data));
879 memcpy(tmp, data, data_len);
881 /* Decrypt the channel message (we don't check the MAC) */
882 if (channel->channel_key &&
883 !silc_channel_message_payload_decrypt(tmp, data_len,
884 channel->channel_key,
886 memset(tmp, 0, data_len);
891 /* Now re-encrypt and send it to the router */
892 silc_server_packet_send_srcdest(server, sock,
893 SILC_PACKET_CHANNEL_MESSAGE, 0,
895 channel->id, SILC_ID_CHANNEL,
896 tmp, data_len, force_send);
898 /* Free the copy of the channel message */
899 memset(tmp, 0, data_len);
902 /* Private key mode is set, we don't have the channel key, so
903 just re-encrypt the entire packet and send it to the router. */
904 silc_server_packet_send_srcdest(server, sock,
905 SILC_PACKET_CHANNEL_MESSAGE, 0,
907 channel->id, SILC_ID_CHANNEL,
908 data, data_len, force_send);
913 /* Send the packet (to normal server) */
914 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
918 data, data_len, TRUE,
927 /* Get data used in packet header encryption, keys and stuff. */
928 sock = (SilcSocketConnection)client->connection;
929 idata = (SilcIDListData)client;
931 if (sender_sock && sock == sender_sock)
934 SILC_LOG_DEBUG(("Sending packet to client ID(%s) %s (%s)",
935 silc_id_render(client->id, SILC_ID_CLIENT),
936 sock->hostname, sock->ip));
938 /* Send the packet */
939 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
943 data, data_len, TRUE,
947 silc_hash_table_list_reset(&htl);
949 silc_free(packetdata.src_id);
950 silc_free(packetdata.dst_id);
953 /* This function is used to send packets strictly to all local clients
954 on a particular channel. This is used for example to distribute new
955 channel key to all our locally connected clients on the channel.
956 The packets are always encrypted with the session key shared between
957 the client, this means these are not _to the channel_ but _to the client_
960 void silc_server_packet_send_local_channel(SilcServer server,
961 SilcChannelEntry channel,
963 SilcPacketFlags flags,
968 SilcChannelClientEntry chl;
969 SilcHashTableList htl;
970 SilcSocketConnection sock = NULL;
972 SILC_LOG_DEBUG(("Start"));
974 /* Send the message to clients on the channel's client list. */
975 silc_hash_table_list(channel->user_list, &htl);
976 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
977 if (chl->client && !chl->client->router) {
978 sock = (SilcSocketConnection)chl->client->connection;
980 /* Send the packet to the client */
981 silc_server_packet_send_dest(server, sock, type, flags, chl->client->id,
982 SILC_ID_CLIENT, data, data_len,
986 silc_hash_table_list_reset(&htl);
989 /* Routine used to send (relay, route) private messages to some destination.
990 If the private message key does not exist then the message is re-encrypted,
991 otherwise we just pass it along. This really is not used to send new
992 private messages (as server does not send them) but to relay received
995 void silc_server_send_private_message(SilcServer server,
996 SilcSocketConnection dst_sock,
1000 SilcPacketContext *packet)
1002 SilcBuffer buffer = packet->buffer;
1004 /* Re-encrypt and send if private messge key does not exist */
1005 if (!(packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY)) {
1007 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1008 + packet->dst_id_len + packet->padlen);
1009 silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
1010 silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
1012 /* Re-encrypt packet */
1013 silc_packet_encrypt(cipher, hmac, sequence, dst_sock->outbuf, buffer->len);
1015 /* Send the packet */
1016 silc_server_packet_send_real(server, dst_sock, FALSE);
1019 /* Key exist so encrypt just header and send it */
1020 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1021 + packet->dst_id_len + packet->padlen);
1022 silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
1023 silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
1025 /* Encrypt header */
1026 silc_packet_encrypt(cipher, hmac, sequence, dst_sock->outbuf,
1027 SILC_PACKET_HEADER_LEN + packet->src_id_len +
1028 packet->dst_id_len + packet->padlen);
1030 silc_server_packet_send_real(server, dst_sock, FALSE);
1034 /* Sends current motd to client */
1036 void silc_server_send_motd(SilcServer server,
1037 SilcSocketConnection sock)
1039 char *motd, *motd_file = NULL;
1043 motd_file = server->config->server_info->motd_file;
1046 motd = silc_file_readfile(motd_file, &motd_len);
1050 silc_server_send_notify(server, sock, FALSE, SILC_NOTIFY_TYPE_MOTD, 1,
1056 /* Sends error message. Error messages may or may not have any
1059 void silc_server_send_error(SilcServer server,
1060 SilcSocketConnection sock,
1061 const char *fmt, ...)
1064 unsigned char buf[4096];
1066 memset(buf, 0, sizeof(buf));
1068 vsprintf(buf, fmt, ap);
1071 silc_server_packet_send(server, sock, SILC_PACKET_ERROR, 0,
1072 buf, strlen(buf), FALSE);
1075 /* Sends notify message. If format is TRUE the variable arguments are
1076 formatted and the formatted string is sent as argument payload. If it is
1077 FALSE then each argument is sent as separate argument and their format
1078 in the argument list must be { argument data, argument length }. */
1080 void silc_server_send_notify(SilcServer server,
1081 SilcSocketConnection sock,
1083 SilcNotifyType type,
1091 packet = silc_notify_payload_encode(type, argc, ap);
1092 silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
1093 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1094 packet->data, packet->len, FALSE);
1096 /* Send to backup routers if this is being broadcasted to primary
1098 if (server->router && server->router->connection &&
1099 sock == server->router->connection && broadcast)
1100 silc_server_backup_send(server, NULL, SILC_PACKET_NOTIFY, 0,
1101 packet->data, packet->len, FALSE, TRUE);
1103 silc_buffer_free(packet);
1107 /* Sends notify message and gets the arguments from the `args' Argument
1110 void silc_server_send_notify_args(SilcServer server,
1111 SilcSocketConnection sock,
1113 SilcNotifyType type,
1119 packet = silc_notify_payload_encode_args(type, argc, args);
1120 silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
1121 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1122 packet->data, packet->len, FALSE);
1123 silc_buffer_free(packet);
1126 /* Send CHANNEL_CHANGE notify type. This tells the receiver to replace the
1127 `old_id' with the `new_id'. */
1129 void silc_server_send_notify_channel_change(SilcServer server,
1130 SilcSocketConnection sock,
1132 SilcChannelID *old_id,
1133 SilcChannelID *new_id)
1135 SilcBuffer idp1, idp2;
1137 idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CHANNEL);
1138 idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CHANNEL);
1140 silc_server_send_notify(server, sock, broadcast,
1141 SILC_NOTIFY_TYPE_CHANNEL_CHANGE,
1142 2, idp1->data, idp1->len, idp2->data, idp2->len);
1143 silc_buffer_free(idp1);
1144 silc_buffer_free(idp2);
1147 /* Send NICK_CHANGE notify type. This tells the receiver to replace the
1148 `old_id' with the `new_id'. */
1150 void silc_server_send_notify_nick_change(SilcServer server,
1151 SilcSocketConnection sock,
1153 SilcClientID *old_id,
1154 SilcClientID *new_id)
1156 SilcBuffer idp1, idp2;
1158 idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CLIENT);
1159 idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CLIENT);
1161 silc_server_send_notify(server, sock, broadcast,
1162 SILC_NOTIFY_TYPE_NICK_CHANGE,
1163 2, idp1->data, idp1->len, idp2->data, idp2->len);
1164 silc_buffer_free(idp1);
1165 silc_buffer_free(idp2);
1168 /* Sends JOIN notify type. This tells that new client by `client_id' ID
1169 has joined to the `channel'. */
1171 void silc_server_send_notify_join(SilcServer server,
1172 SilcSocketConnection sock,
1174 SilcChannelEntry channel,
1175 SilcClientID *client_id)
1177 SilcBuffer idp1, idp2;
1179 idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1180 idp2 = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1181 silc_server_send_notify(server, sock, broadcast, SILC_NOTIFY_TYPE_JOIN,
1182 2, idp1->data, idp1->len,
1183 idp2->data, idp2->len);
1184 silc_buffer_free(idp1);
1185 silc_buffer_free(idp2);
1188 /* Sends LEAVE notify type. This tells that `client_id' has left the
1189 `channel'. The Notify packet is always destined to the channel. */
1191 void silc_server_send_notify_leave(SilcServer server,
1192 SilcSocketConnection sock,
1194 SilcChannelEntry channel,
1195 SilcClientID *client_id)
1199 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1200 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1201 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_LEAVE,
1202 1, idp->data, idp->len);
1203 silc_buffer_free(idp);
1206 /* Sends CMODE_CHANGE notify type. This tells that `client_id' changed the
1207 `channel' mode to `mode. The Notify packet is always destined to
1210 void silc_server_send_notify_cmode(SilcServer server,
1211 SilcSocketConnection sock,
1213 SilcChannelEntry channel,
1215 void *id, SilcIdType id_type,
1216 char *cipher, char *hmac,
1220 unsigned char mode[4];
1222 idp = silc_id_payload_encode((void *)id, id_type);
1223 SILC_PUT32_MSB(mode_mask, mode);
1225 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1226 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_CMODE_CHANGE,
1227 5, idp->data, idp->len,
1229 cipher, cipher ? strlen(cipher) : 0,
1230 hmac, hmac ? strlen(hmac) : 0,
1231 passphrase, passphrase ?
1232 strlen(passphrase) : 0);
1233 silc_buffer_free(idp);
1236 /* Sends CUMODE_CHANGE notify type. This tells that `client_id' changed the
1237 `target' client's mode on `channel'. The notify packet is always
1238 destined to the channel. */
1240 void silc_server_send_notify_cumode(SilcServer server,
1241 SilcSocketConnection sock,
1243 SilcChannelEntry channel,
1245 void *id, SilcIdType id_type,
1246 SilcClientID *target)
1248 SilcBuffer idp1, idp2;
1249 unsigned char mode[4];
1251 idp1 = silc_id_payload_encode((void *)id, id_type);
1252 idp2 = silc_id_payload_encode((void *)target, SILC_ID_CLIENT);
1253 SILC_PUT32_MSB(mode_mask, mode);
1255 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1257 SILC_NOTIFY_TYPE_CUMODE_CHANGE, 3,
1258 idp1->data, idp1->len,
1260 idp2->data, idp2->len);
1261 silc_buffer_free(idp1);
1262 silc_buffer_free(idp2);
1265 /* Sends SIGNOFF notify type. This tells that `client_id' client has
1266 left SILC network. This function is used only between server and router
1267 traffic. This is not used to send the notify to the channel for
1268 client. The `message may be NULL. */
1270 void silc_server_send_notify_signoff(SilcServer server,
1271 SilcSocketConnection sock,
1273 SilcClientID *client_id,
1274 const char *message)
1278 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1279 silc_server_send_notify(server, sock, broadcast,
1280 SILC_NOTIFY_TYPE_SIGNOFF,
1281 message ? 2 : 1, idp->data, idp->len,
1282 message, message ? strlen(message): 0);
1283 silc_buffer_free(idp);
1286 /* Sends TOPIC_SET notify type. This tells that `id' changed
1287 the `channel's topic to `topic'. The Notify packet is always destined
1288 to the channel. This function is used to send the topic set notifies
1291 void silc_server_send_notify_topic_set(SilcServer server,
1292 SilcSocketConnection sock,
1294 SilcChannelEntry channel,
1295 void *id, SilcIdType id_type,
1300 idp = silc_id_payload_encode(id, id_type);
1301 silc_server_send_notify_dest(server, sock, broadcast,
1302 (void *)channel->id, SILC_ID_CHANNEL,
1303 SILC_NOTIFY_TYPE_TOPIC_SET,
1305 idp->data, idp->len,
1306 topic, topic ? strlen(topic) : 0);
1307 silc_buffer_free(idp);
1310 /* Send KICKED notify type. This tells that the `client_id' on `channel'
1311 was kicked off the channel. The `comment' may indicate the reason
1312 for the kicking. This function is used only between server and router
1315 void silc_server_send_notify_kicked(SilcServer server,
1316 SilcSocketConnection sock,
1318 SilcChannelEntry channel,
1319 SilcClientID *client_id,
1320 SilcClientID *kicker,
1326 idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1327 idp2 = silc_id_payload_encode((void *)kicker, SILC_ID_CLIENT);
1328 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1329 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_KICKED, 3,
1330 idp1->data, idp1->len,
1331 comment, comment ? strlen(comment) : 0,
1332 idp2->data, idp2->len);
1333 silc_buffer_free(idp1);
1334 silc_buffer_free(idp2);
1337 /* Send KILLED notify type. This tells that the `client_id' client was
1338 killed from the network. The `comment' may indicate the reason
1341 void silc_server_send_notify_killed(SilcServer server,
1342 SilcSocketConnection sock,
1344 SilcClientID *client_id,
1349 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1350 silc_server_send_notify_dest(server, sock, broadcast, (void *)client_id,
1351 SILC_ID_CLIENT, SILC_NOTIFY_TYPE_KILLED,
1352 comment ? 2 : 1, idp->data, idp->len,
1353 comment, comment ? strlen(comment) : 0);
1354 silc_buffer_free(idp);
1357 /* Sends UMODE_CHANGE notify type. This tells that `client_id' client's
1358 user mode in the SILC Network was changed. This function is used to
1359 send the packet between routers as broadcast packet. */
1361 void silc_server_send_notify_umode(SilcServer server,
1362 SilcSocketConnection sock,
1364 SilcClientID *client_id,
1368 unsigned char mode[4];
1370 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1371 SILC_PUT32_MSB(mode_mask, mode);
1373 silc_server_send_notify(server, sock, broadcast,
1374 SILC_NOTIFY_TYPE_UMODE_CHANGE, 2,
1375 idp->data, idp->len,
1377 silc_buffer_free(idp);
1380 /* Sends BAN notify type. This tells that ban has been either `add'ed
1381 or `del'eted on the `channel. This function is used to send the packet
1382 between routers as broadcast packet. */
1384 void silc_server_send_notify_ban(SilcServer server,
1385 SilcSocketConnection sock,
1387 SilcChannelEntry channel,
1388 char *add, char *del)
1392 idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1393 silc_server_send_notify(server, sock, broadcast,
1394 SILC_NOTIFY_TYPE_BAN, 3,
1395 idp->data, idp->len,
1396 add, add ? strlen(add) : 0,
1397 del, del ? strlen(del) : 0);
1398 silc_buffer_free(idp);
1401 /* Sends INVITE notify type. This tells that invite has been either `add'ed
1402 or `del'eted on the `channel. The sender of the invite is the `client_id'.
1403 This function is used to send the packet between routers as broadcast
1406 void silc_server_send_notify_invite(SilcServer server,
1407 SilcSocketConnection sock,
1409 SilcChannelEntry channel,
1410 SilcClientID *client_id,
1411 char *add, char *del)
1413 SilcBuffer idp, idp2;
1415 idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1416 idp2 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1417 silc_server_send_notify(server, sock, broadcast,
1418 SILC_NOTIFY_TYPE_INVITE, 5,
1419 idp->data, idp->len,
1420 channel->channel_name, strlen(channel->channel_name),
1421 idp2->data, idp2->len,
1422 add, add ? strlen(add) : 0,
1423 del, del ? strlen(del) : 0);
1424 silc_buffer_free(idp);
1425 silc_buffer_free(idp2);
1428 /* Sends notify message destined to specific entity. */
1430 void silc_server_send_notify_dest(SilcServer server,
1431 SilcSocketConnection sock,
1434 SilcIdType dest_id_type,
1435 SilcNotifyType type,
1443 packet = silc_notify_payload_encode(type, argc, ap);
1444 silc_server_packet_send_dest(server, sock, SILC_PACKET_NOTIFY,
1445 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1446 dest_id, dest_id_type,
1447 packet->data, packet->len, FALSE);
1448 silc_buffer_free(packet);
1452 /* Sends notify message to a channel. The notify message sent is
1453 distributed to all clients on the channel. If `route_notify' is TRUE
1454 then the notify may be routed to primary route or to some other routers.
1455 If FALSE it is assured that the notify is sent only locally. If `sender'
1456 is provided then the packet is not sent to that connection since it
1457 originally came from it. */
1459 void silc_server_send_notify_to_channel(SilcServer server,
1460 SilcSocketConnection sender,
1461 SilcChannelEntry channel,
1463 SilcNotifyType type,
1471 packet = silc_notify_payload_encode(type, argc, ap);
1472 silc_server_packet_send_to_channel(server, sender, channel,
1473 SILC_PACKET_NOTIFY, route_notify,
1474 packet->data, packet->len, FALSE);
1475 silc_buffer_free(packet);
1479 /* Send notify message to all channels the client has joined. It is quaranteed
1480 that the message is sent only once to a client (ie. if a client is joined
1481 on two same channel it will receive only one notify message). Also, this
1482 sends only to local clients (locally connected if we are server, and to
1483 local servers if we are router). If `sender' is provided the packet is
1484 not sent to that client at all. */
1486 void silc_server_send_notify_on_channels(SilcServer server,
1487 SilcClientEntry sender,
1488 SilcClientEntry client,
1489 SilcNotifyType type,
1493 SilcSocketConnection sock = NULL;
1494 SilcPacketContext packetdata;
1496 SilcClientEntry *sent_clients = NULL;
1497 uint32 sent_clients_count = 0;
1498 SilcServerEntry *routed = NULL;
1499 uint32 routed_count = 0;
1500 SilcHashTableList htl, htl2;
1501 SilcChannelEntry channel;
1502 SilcChannelClientEntry chl, chl2;
1503 SilcIDListData idata;
1505 unsigned char *data;
1507 bool force_send = FALSE;
1510 SILC_LOG_DEBUG(("Start"));
1512 if (!silc_hash_table_count(client->channels))
1516 packet = silc_notify_payload_encode(type, argc, ap);
1517 data = packet->data;
1518 data_len = packet->len;
1520 /* Set the packet context pointers. */
1521 packetdata.flags = 0;
1522 packetdata.type = SILC_PACKET_NOTIFY;
1523 packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
1524 packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
1525 packetdata.src_id_type = SILC_ID_SERVER;
1527 silc_hash_table_list(client->channels, &htl);
1528 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
1529 channel = chl->channel;
1531 /* Send the message to all clients on the channel's client list. */
1532 silc_hash_table_list(channel->user_list, &htl2);
1533 while (silc_hash_table_get(&htl2, NULL, (void *)&chl2)) {
1536 if (sender && c == sender)
1539 /* Check if we have sent the packet to this client already */
1540 for (k = 0; k < sent_clients_count; k++)
1541 if (sent_clients[k] == c)
1543 if (k < sent_clients_count)
1546 /* If we are router and if this client has router set it is not
1547 locally connected client and we will route the message to the
1548 router set in the client. */
1549 if (c && c->router && server->server_type == SILC_ROUTER) {
1550 /* Check if we have sent the packet to this route already */
1551 for (k = 0; k < routed_count; k++)
1552 if (routed[k] == c->router)
1554 if (k < routed_count)
1557 /* Get data used in packet header encryption, keys and stuff. */
1558 sock = (SilcSocketConnection)c->router->connection;
1559 idata = (SilcIDListData)c->router;
1562 SILC_LOG_DEBUG(("*****************"));
1563 SILC_LOG_DEBUG(("client->router->id %s",
1564 silc_id_render(c->router->id, SILC_ID_SERVER)));
1565 SILC_LOG_DEBUG(("client->router->connection->user_data->id %s",
1566 silc_id_render(((SilcServerEntry)sock->user_data)->id, SILC_ID_SERVER)));
1569 packetdata.dst_id = silc_id_id2str(c->router->id, SILC_ID_SERVER);
1570 packetdata.dst_id_len = silc_id_get_len(c->router->id, SILC_ID_SERVER);
1571 packetdata.dst_id_type = SILC_ID_SERVER;
1573 /* Send the packet */
1574 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1578 data, data_len, FALSE,
1581 silc_free(packetdata.dst_id);
1583 /* We want to make sure that the packet is routed to same router
1584 only once. Mark this route as sent route. */
1585 routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
1586 routed[routed_count++] = c->router;
1593 /* Send to locally connected client */
1596 /* Get data used in packet header encryption, keys and stuff. */
1597 sock = (SilcSocketConnection)c->connection;
1598 idata = (SilcIDListData)c;
1600 packetdata.dst_id = silc_id_id2str(c->id, SILC_ID_CLIENT);
1601 packetdata.dst_id_len = silc_id_get_len(c->id, SILC_ID_CLIENT);
1602 packetdata.dst_id_type = SILC_ID_CLIENT;
1604 /* Send the packet */
1605 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1609 data, data_len, FALSE,
1612 silc_free(packetdata.dst_id);
1614 /* Make sure that we send the notify only once per client. */
1615 sent_clients = silc_realloc(sent_clients, sizeof(*sent_clients) *
1616 (sent_clients_count + 1));
1617 sent_clients[sent_clients_count++] = c;
1620 silc_hash_table_list_reset(&htl2);
1623 silc_hash_table_list_reset(&htl);
1625 silc_free(sent_clients);
1626 silc_free(packetdata.src_id);
1627 silc_buffer_free(packet);
1631 /* Sends New ID Payload to remote end. The packet is used to distribute
1632 information about new registered clients, servers, channel etc. usually
1633 to routers so that they can keep these information up to date.
1634 If the argument `broadcast' is TRUE then the packet is sent as
1635 broadcast packet. */
1637 void silc_server_send_new_id(SilcServer server,
1638 SilcSocketConnection sock,
1640 void *id, SilcIdType id_type,
1645 SILC_LOG_DEBUG(("Start"));
1647 idp = silc_id_payload_encode(id, id_type);
1648 silc_server_packet_send(server, sock, SILC_PACKET_NEW_ID,
1649 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1650 idp->data, idp->len, FALSE);
1652 /* Send to backup routers if this is being broadcasted to primary
1654 if (server->router && server->router->connection &&
1655 sock == server->router->connection && broadcast)
1656 silc_server_backup_send(server, NULL, SILC_PACKET_NEW_ID, 0,
1657 idp->data, idp->len, FALSE, TRUE);
1659 silc_buffer_free(idp);
1662 /* Send New Channel Payload to notify about newly created channel in the
1663 SILC network. Router uses this to notify other routers in the network
1664 about new channel. This packet is broadcasted by router. */
1666 void silc_server_send_new_channel(SilcServer server,
1667 SilcSocketConnection sock,
1671 uint32 channel_id_len,
1676 uint32 name_len = strlen(channel_name);
1678 SILC_LOG_DEBUG(("Start"));
1680 cid = silc_id_id2str(channel_id, SILC_ID_CHANNEL);
1684 /* Encode the channel payload */
1685 packet = silc_channel_payload_encode(channel_name, name_len,
1686 cid, channel_id_len, mode);
1688 silc_server_packet_send(server, sock, SILC_PACKET_NEW_CHANNEL,
1689 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1690 packet->data, packet->len, FALSE);
1692 /* Send to backup routers if this is being broadcasted to primary
1694 if (server->server_type == SILC_ROUTER &&
1695 server->router && server->router->connection &&
1696 sock == server->router->connection && broadcast)
1697 silc_server_backup_send(server, NULL, SILC_PACKET_NEW_CHANNEL, 0,
1698 packet->data, packet->len, FALSE, TRUE);
1701 silc_buffer_free(packet);
1704 /* Send Channel Key payload to distribute the new channel key. Normal server
1705 sends this to router when new client joins to existing channel. Router
1706 sends this to the local server who sent the join command in case where
1707 the channel did not exist yet. Both normal and router servers uses this
1708 also to send this to locally connected clients on the channel. This
1709 must not be broadcasted packet. Routers do not send this to each other.
1710 If `sender is provided then the packet is not sent to that connection since
1711 it originally came from it. */
1713 void silc_server_send_channel_key(SilcServer server,
1714 SilcSocketConnection sender,
1715 SilcChannelEntry channel,
1716 unsigned char route)
1719 unsigned char *chid;
1722 SILC_LOG_DEBUG(("Sending key to channel %s", channel->channel_name));
1724 chid = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
1728 /* Encode channel key packet */
1729 tmp_len = strlen(channel->channel_key->cipher->name);
1730 packet = silc_channel_key_payload_encode(silc_id_get_len(channel->id,
1733 channel->channel_key->cipher->name,
1734 channel->key_len / 8, channel->key);
1735 silc_server_packet_send_to_channel(server, sender, channel,
1736 SILC_PACKET_CHANNEL_KEY,
1737 route, packet->data, packet->len,
1739 silc_buffer_free(packet);
1743 /* Generic function to send any command. The arguments must be sent already
1744 encoded into correct form in correct order. */
1746 void silc_server_send_command(SilcServer server,
1747 SilcSocketConnection sock,
1748 SilcCommand command,
1757 packet = silc_command_payload_encode_vap(command, ident, argc, ap);
1758 silc_server_packet_send(server, sock, SILC_PACKET_COMMAND, 0,
1759 packet->data, packet->len, TRUE);
1760 silc_buffer_free(packet);
1764 /* Generic function to send any command reply. The arguments must be sent
1765 already encoded into correct form in correct order. */
1767 void silc_server_send_command_reply(SilcServer server,
1768 SilcSocketConnection sock,
1769 SilcCommand command,
1770 SilcCommandStatus status,
1779 packet = silc_command_reply_payload_encode_vap(command, status, ident,
1781 silc_server_packet_send(server, sock, SILC_PACKET_COMMAND_REPLY, 0,
1782 packet->data, packet->len, TRUE);
1783 silc_buffer_free(packet);
1787 /* Generic function to send any command reply. The arguments must be sent
1788 already encoded into correct form in correct order. */
1790 void silc_server_send_dest_command_reply(SilcServer server,
1791 SilcSocketConnection sock,
1793 SilcIdType dst_id_type,
1794 SilcCommand command,
1795 SilcCommandStatus status,
1804 packet = silc_command_reply_payload_encode_vap(command, status, ident,
1806 silc_server_packet_send_dest(server, sock, SILC_PACKET_COMMAND_REPLY, 0,
1807 dst_id, dst_id_type, packet->data,
1809 silc_buffer_free(packet);
1813 /* Send the heartbeat packet. */
1815 void silc_server_send_heartbeat(SilcServer server,
1816 SilcSocketConnection sock)
1818 silc_server_packet_send(server, sock, SILC_PACKET_HEARTBEAT, 0,
1822 /* Generic function to relay packet we've received. This is used to relay
1823 packets to a client but generally can be used to other purposes as well. */
1825 void silc_server_relay_packet(SilcServer server,
1826 SilcSocketConnection dst_sock,
1830 SilcPacketContext *packet,
1833 silc_buffer_push(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1834 + packet->dst_id_len + packet->padlen);
1836 silc_packet_send_prepare(dst_sock, 0, 0, packet->buffer->len);
1837 silc_buffer_put(dst_sock->outbuf, packet->buffer->data, packet->buffer->len);
1839 /* Re-encrypt packet */
1840 silc_packet_encrypt(cipher, hmac, sequence, dst_sock->outbuf,
1841 packet->buffer->len);
1843 /* Send the packet */
1844 silc_server_packet_send_real(server, dst_sock, force_send);
1846 silc_buffer_pull(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1847 + packet->dst_id_len + packet->padlen);
1850 /* Routine used to send the connection authentication packet. */
1852 void silc_server_send_connection_auth_request(SilcServer server,
1853 SilcSocketConnection sock,
1855 SilcAuthMethod auth_meth)
1859 packet = silc_buffer_alloc(4);
1860 silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1861 silc_buffer_format(packet,
1862 SILC_STR_UI_SHORT(conn_type),
1863 SILC_STR_UI_SHORT(auth_meth),
1866 silc_server_packet_send(server, sock, SILC_PACKET_CONNECTION_AUTH_REQUEST,
1867 0, packet->data, packet->len, FALSE);
1868 silc_buffer_free(packet);
1871 /* Purge the outgoing packet queue to the network if there is data. This
1872 function can be used to empty the packet queue. It is guaranteed that
1873 after this function returns the outgoing data queue is empty. */
1875 void silc_server_packet_queue_purge(SilcServer server,
1876 SilcSocketConnection sock)
1878 if (sock && SILC_IS_OUTBUF_PENDING(sock) &&
1879 (SILC_IS_DISCONNECTED(sock) == FALSE)) {
1880 server->stat.packets_sent++;
1882 if (sock->outbuf->data - sock->outbuf->head)
1883 silc_buffer_push(sock->outbuf, sock->outbuf->data - sock->outbuf->head);
1885 silc_packet_send(sock, TRUE);
1887 SILC_SET_CONNECTION_FOR_INPUT(server->schedule, sock->sock);
1888 SILC_UNSET_OUTBUF_PENDING(sock);
1889 silc_buffer_clear(sock->outbuf);