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,
479 packet->truelen = data_len + SILC_PACKET_HEADER_LEN +
480 packet->src_id_len + packet->dst_id_len;
482 block_len = cipher ? silc_cipher_get_block_len(cipher) : 0;
484 packet->padlen = SILC_PACKET_PADLEN((SILC_PACKET_HEADER_LEN +
486 packet->dst_id_len), block_len);
488 packet->padlen = SILC_PACKET_PADLEN(packet->truelen, block_len);
490 /* Prepare outgoing data buffer for packet sending */
491 silc_packet_send_prepare(sock,
492 SILC_PACKET_HEADER_LEN +
498 packet->buffer = sock->outbuf;
500 /* Put the data to buffer, assemble and encrypt the packet. The packet
501 is encrypted with normal session key shared with the client, unless
502 the `channel_message' is TRUE. */
503 silc_buffer_put(sock->outbuf, data, data_len);
504 silc_packet_assemble(packet, cipher);
506 silc_packet_encrypt(cipher, hmac, sequence, sock->outbuf,
507 SILC_PACKET_HEADER_LEN + packet->src_id_len +
508 packet->dst_id_len + packet->padlen);
510 silc_packet_encrypt(cipher, hmac, sequence, sock->outbuf,
513 SILC_LOG_HEXDUMP(("Channel packet (%d), len %d", sequence,
515 sock->outbuf->data, sock->outbuf->len);
517 /* Now actually send the packet */
518 silc_server_packet_send_real(server, sock, force_send);
521 /* This routine is used by the server to send packets to channel. The
522 packet sent with this function is distributed to all clients on
523 the channel. Usually this is used to send notify messages to the
524 channel, things like notify about new user joining to the channel.
525 If `route' is FALSE then the packet is sent only locally and will not
526 be routed anywhere (for router locally means cell wide). If `sender'
527 is provided then the packet is not sent to that connection since it
528 originally came from it. If `send_to_clients' is FALSE then the
529 packet is not sent clients, only servers. */
531 void silc_server_packet_send_to_channel(SilcServer server,
532 SilcSocketConnection sender,
533 SilcChannelEntry channel,
540 SilcSocketConnection sock = NULL;
541 SilcPacketContext packetdata;
542 SilcClientEntry client = NULL;
543 SilcServerEntry *routed = NULL;
544 SilcChannelClientEntry chl;
545 SilcHashTableList htl;
546 SilcIDListData idata;
547 uint32 routed_count = 0;
551 /* This doesn't send channel message packets */
552 assert(type != SILC_PACKET_CHANNEL_MESSAGE);
554 SILC_LOG_DEBUG(("Sending packet to channel"));
556 /* Set the packet context pointers. */
557 packetdata.flags = 0;
558 packetdata.type = type;
559 packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
560 packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
561 packetdata.src_id_type = SILC_ID_SERVER;
562 packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
563 packetdata.dst_id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
564 packetdata.dst_id_type = SILC_ID_CHANNEL;
566 /* If there are global users in the channel we will send the message
567 first to our router for further routing. */
568 if (route && server->server_type != SILC_ROUTER && !server->standalone &&
569 channel->global_users) {
570 SilcServerEntry router;
572 /* Get data used in packet header encryption, keys and stuff. */
573 router = server->router;
574 sock = (SilcSocketConnection)router->connection;
575 idata = (SilcIDListData)router;
577 if (sock != sender) {
578 SILC_LOG_DEBUG(("Sending packet to router for routing"));
580 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
584 data, data_len, FALSE,
589 routed = silc_calloc(silc_hash_table_count(channel->user_list),
592 /* Send the message to clients on the channel's client list. */
593 silc_hash_table_list(channel->user_list, &htl);
594 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
595 client = chl->client;
599 /* If client has router set it is not locally connected client and
600 we will route the message to the router set in the client. Though,
601 send locally connected server in all cases. */
602 if (server->server_type == SILC_ROUTER && client->router &&
603 ((!route && client->router->router == server->id_entry) || route)) {
605 /* Check if we have sent the packet to this route already */
606 for (k = 0; k < routed_count; k++)
607 if (routed[k] == client->router)
609 if (k < routed_count)
612 /* Get data used in packet header encryption, keys and stuff. */
613 sock = (SilcSocketConnection)client->router->connection;
614 idata = (SilcIDListData)client->router;
616 if (sender && sock == sender)
619 /* Route only once to router */
620 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
626 /* Send the packet */
627 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
631 data, data_len, FALSE,
634 /* Mark this route routed already */
635 routed[routed_count++] = client->router;
642 /* Send to locally connected client */
644 /* Get data used in packet header encryption, keys and stuff. */
645 sock = (SilcSocketConnection)client->connection;
646 idata = (SilcIDListData)client;
648 if (sender && sock == sender)
651 /* Send the packet */
652 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
656 data, data_len, FALSE,
661 silc_free(packetdata.src_id);
662 silc_free(packetdata.dst_id);
665 /* This checks whether the relayed packet came from router. If it did
666 then we'll need to encrypt it with the channel key. This is called
667 from the silc_server_packet_relay_to_channel. */
670 silc_server_packet_relay_to_channel_encrypt(SilcServer server,
671 SilcSocketConnection sock,
672 SilcChannelEntry channel,
674 unsigned int data_len)
676 /* If we are router and the packet came from router and private key
677 has not been set for the channel then we must encrypt the packet
678 as it was decrypted with the session key shared between us and the
679 router which sent it. This is so, because cells does not share the
681 if (server->server_type == SILC_ROUTER &&
682 sock->type == SILC_SOCKET_TYPE_ROUTER &&
683 !(channel->mode & SILC_CHANNEL_MODE_PRIVKEY) &&
684 channel->channel_key) {
689 iv_len = silc_cipher_get_block_len(channel->channel_key);
690 if (channel->iv[0] == '\0')
691 for (i = 0; i < iv_len; i++) channel->iv[i] =
692 silc_rng_get_byte(server->rng);
694 silc_hash_make(server->md5hash, channel->iv, iv_len, channel->iv);
696 /* Encode new payload. This encrypts it also. */
697 SILC_GET16_MSB(flags, data);
698 SILC_GET16_MSB(dlen, data + 2);
700 if (dlen > data_len) {
701 SILC_LOG_WARNING(("Corrupted channel message, cannot relay it"));
705 chp = silc_channel_message_payload_encode(flags, dlen, data + 4,
707 channel->channel_key,
709 memcpy(data, chp->data, chp->len);
710 silc_buffer_free(chp);
716 /* This routine is explicitly used to relay messages to some channel.
717 Packets sent with this function we have received earlier and are
718 totally encrypted. This just sends the packet to all clients on
719 the channel. If the sender of the packet is someone on the channel
720 the message will not be sent to that client. The SILC Packet header
721 is encrypted with the session key shared between us and the client.
722 MAC is also computed before encrypting the header. Rest of the
723 packet will be untouched. */
725 void silc_server_packet_relay_to_channel(SilcServer server,
726 SilcSocketConnection sender_sock,
727 SilcChannelEntry channel,
729 SilcIdType sender_type,
736 SilcSocketConnection sock = NULL;
737 SilcPacketContext packetdata;
738 SilcClientEntry client = NULL;
739 SilcServerEntry *routed = NULL;
740 SilcChannelClientEntry chl;
741 uint32 routed_count = 0;
742 SilcIDListData idata;
743 SilcHashTableList htl;
747 SILC_LOG_DEBUG(("Relaying packet to channel"));
749 /* This encrypts the packet, if needed. It will be encrypted if
750 it came from the router thus it needs to be encrypted with the
751 channel key. If the channel key does not exist, then we know we
752 don't have a single local user on the channel. */
753 if (!silc_server_packet_relay_to_channel_encrypt(server, sender_sock,
758 /* Set the packet context pointers. */
759 packetdata.flags = 0;
760 packetdata.type = SILC_PACKET_CHANNEL_MESSAGE;
761 packetdata.src_id = silc_id_id2str(sender, sender_type);
762 packetdata.src_id_len = silc_id_get_len(sender, sender_type);
763 packetdata.src_id_type = sender_type;
764 packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
765 packetdata.dst_id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
766 packetdata.dst_id_type = SILC_ID_CHANNEL;
768 /* If there are global users in the channel we will send the message
769 first to our router for further routing. */
770 if (server->server_type != SILC_ROUTER && !server->standalone &&
771 channel->global_users) {
772 SilcServerEntry router = server->router;
774 /* Check that the sender is not our router. */
775 if (sender_sock != (SilcSocketConnection)router->connection) {
777 /* Get data used in packet header encryption, keys and stuff. */
778 sock = (SilcSocketConnection)router->connection;
779 idata = (SilcIDListData)router;
781 SILC_LOG_DEBUG(("Sending channel message to router for routing"));
783 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
787 data, data_len, TRUE,
792 routed = silc_calloc(silc_hash_table_count(channel->user_list),
795 /* Mark that to the route the original sender if from is not routed */
796 if (sender_type == SILC_ID_CLIENT) {
797 client = (SilcClientEntry)sender_entry;
798 if (client->router) {
799 routed[routed_count++] = client->router;
800 SILC_LOG_DEBUG(("************* router %s",
801 silc_id_render(client->router->id, SILC_ID_SERVER)));
805 /* Send the message to clients on the channel's client list. */
806 silc_hash_table_list(channel->user_list, &htl);
807 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
808 client = chl->client;
812 /* Do not send to the sender */
813 if (!found && client == sender_entry) {
818 /* If the client has set router it means that it is not locally
819 connected client and we will route the packet further. */
820 if (server->server_type == SILC_ROUTER && client->router) {
822 /* Sender maybe server as well so we want to make sure that
823 we won't send the message to the server it came from. */
824 if (!found && SILC_ID_SERVER_COMPARE(client->router->id, sender)) {
826 routed[routed_count++] = client->router;
830 /* Check if we have sent the packet to this route already */
831 for (k = 0; k < routed_count; k++)
832 if (routed[k] == client->router)
834 if (k < routed_count)
837 /* Get data used in packet header encryption, keys and stuff. */
838 sock = (SilcSocketConnection)client->router->connection;
839 idata = (SilcIDListData)client->router;
841 /* Do not send to the sender. Check first whether the true
842 sender's router is same as this client's router. Also check
843 if the sender socket is the same as this client's router
846 ((SilcClientEntry)sender_entry)->router == client->router)
848 if (sender_sock && sock == sender_sock)
851 SILC_LOG_DEBUG(("Relaying packet to client ID(%s) %s (%s)",
852 silc_id_render(client->id, SILC_ID_CLIENT),
853 sock->hostname, sock->ip));
855 /* Mark this route routed already. */
856 routed[routed_count++] = client->router;
858 /* If the remote connection is router then we'll decrypt the
859 channel message and re-encrypt it with the session key shared
860 between us and the remote router. This is done because the
861 channel keys are cell specific and we have different channel
862 key than the remote router has. */
863 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
867 SILC_LOG_DEBUG(("Remote is router, encrypt with session key"));
870 /* If private key mode is not set then decrypt the packet
872 if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
873 unsigned char *tmp = silc_calloc(data_len, sizeof(*data));
874 memcpy(tmp, data, data_len);
876 /* Decrypt the channel message (we don't check the MAC) */
877 if (channel->channel_key &&
878 !silc_channel_message_payload_decrypt(tmp, data_len,
879 channel->channel_key,
881 memset(tmp, 0, data_len);
886 /* Now re-encrypt and send it to the router */
887 silc_server_packet_send_srcdest(server, sock,
888 SILC_PACKET_CHANNEL_MESSAGE, 0,
890 channel->id, SILC_ID_CHANNEL,
891 tmp, data_len, force_send);
893 /* Free the copy of the channel message */
894 memset(tmp, 0, data_len);
897 /* Private key mode is set, we don't have the channel key, so
898 just re-encrypt the entire packet and send it to the router. */
899 silc_server_packet_send_srcdest(server, sock,
900 SILC_PACKET_CHANNEL_MESSAGE, 0,
902 channel->id, SILC_ID_CHANNEL,
903 data, data_len, force_send);
908 /* Send the packet (to normal server) */
909 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
913 data, data_len, TRUE,
922 /* Get data used in packet header encryption, keys and stuff. */
923 sock = (SilcSocketConnection)client->connection;
924 idata = (SilcIDListData)client;
926 if (sender_sock && sock == sender_sock)
929 SILC_LOG_DEBUG(("Sending packet to client ID(%s) %s (%s)",
930 silc_id_render(client->id, SILC_ID_CLIENT),
931 sock->hostname, sock->ip));
933 /* Send the packet */
934 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
938 data, data_len, TRUE,
943 silc_free(packetdata.src_id);
944 silc_free(packetdata.dst_id);
947 /* This function is used to send packets strictly to all local clients
948 on a particular channel. This is used for example to distribute new
949 channel key to all our locally connected clients on the channel.
950 The packets are always encrypted with the session key shared between
951 the client, this means these are not _to the channel_ but _to the client_
954 void silc_server_packet_send_local_channel(SilcServer server,
955 SilcChannelEntry channel,
957 SilcPacketFlags flags,
962 SilcChannelClientEntry chl;
963 SilcHashTableList htl;
964 SilcSocketConnection sock = NULL;
966 SILC_LOG_DEBUG(("Start"));
968 /* Send the message to clients on the channel's client list. */
969 silc_hash_table_list(channel->user_list, &htl);
970 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
971 if (chl->client && !chl->client->router) {
972 sock = (SilcSocketConnection)chl->client->connection;
974 /* Send the packet to the client */
975 silc_server_packet_send_dest(server, sock, type, flags, chl->client->id,
976 SILC_ID_CLIENT, data, data_len,
982 /* Routine used to send (relay, route) private messages to some destination.
983 If the private message key does not exist then the message is re-encrypted,
984 otherwise we just pass it along. This really is not used to send new
985 private messages (as server does not send them) but to relay received
988 void silc_server_send_private_message(SilcServer server,
989 SilcSocketConnection dst_sock,
993 SilcPacketContext *packet)
995 SilcBuffer buffer = packet->buffer;
997 /* Re-encrypt and send if private messge key does not exist */
998 if (!(packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY)) {
1000 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1001 + packet->dst_id_len + packet->padlen);
1002 silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
1003 silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
1005 /* Re-encrypt packet */
1006 silc_packet_encrypt(cipher, hmac, sequence, dst_sock->outbuf, buffer->len);
1008 /* Send the packet */
1009 silc_server_packet_send_real(server, dst_sock, FALSE);
1012 /* Key exist so encrypt just header and send it */
1013 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1014 + packet->dst_id_len + packet->padlen);
1015 silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
1016 silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
1018 /* Encrypt header */
1019 silc_packet_encrypt(cipher, hmac, sequence, dst_sock->outbuf,
1020 SILC_PACKET_HEADER_LEN + packet->src_id_len +
1021 packet->dst_id_len + packet->padlen);
1023 silc_server_packet_send_real(server, dst_sock, FALSE);
1027 /* Sends current motd to client */
1029 void silc_server_send_motd(SilcServer server,
1030 SilcSocketConnection sock)
1035 if (server->config && server->config->motd &&
1036 server->config->motd->motd_file) {
1038 motd = silc_file_readfile(server->config->motd->motd_file, &motd_len);
1042 silc_server_send_notify(server, sock, FALSE, SILC_NOTIFY_TYPE_MOTD, 1,
1048 /* Sends error message. Error messages may or may not have any
1051 void silc_server_send_error(SilcServer server,
1052 SilcSocketConnection sock,
1053 const char *fmt, ...)
1056 unsigned char buf[4096];
1058 memset(buf, 0, sizeof(buf));
1060 vsprintf(buf, fmt, ap);
1063 silc_server_packet_send(server, sock, SILC_PACKET_ERROR, 0,
1064 buf, strlen(buf), FALSE);
1067 /* Sends notify message. If format is TRUE the variable arguments are
1068 formatted and the formatted string is sent as argument payload. If it is
1069 FALSE then each argument is sent as separate argument and their format
1070 in the argument list must be { argument data, argument length }. */
1072 void silc_server_send_notify(SilcServer server,
1073 SilcSocketConnection sock,
1075 SilcNotifyType type,
1083 packet = silc_notify_payload_encode(type, argc, ap);
1084 silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
1085 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1086 packet->data, packet->len, FALSE);
1088 /* Send to backup routers if this is being broadcasted to primary
1090 if (server->router && server->router->connection &&
1091 sock == server->router->connection && broadcast)
1092 silc_server_backup_send(server, NULL, SILC_PACKET_NOTIFY, 0,
1093 packet->data, packet->len, FALSE, TRUE);
1095 silc_buffer_free(packet);
1099 /* Sends notify message and gets the arguments from the `args' Argument
1102 void silc_server_send_notify_args(SilcServer server,
1103 SilcSocketConnection sock,
1105 SilcNotifyType type,
1111 packet = silc_notify_payload_encode_args(type, argc, args);
1112 silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
1113 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1114 packet->data, packet->len, FALSE);
1115 silc_buffer_free(packet);
1118 /* Send CHANNEL_CHANGE notify type. This tells the receiver to replace the
1119 `old_id' with the `new_id'. */
1121 void silc_server_send_notify_channel_change(SilcServer server,
1122 SilcSocketConnection sock,
1124 SilcChannelID *old_id,
1125 SilcChannelID *new_id)
1127 SilcBuffer idp1, idp2;
1129 idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CHANNEL);
1130 idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CHANNEL);
1132 silc_server_send_notify(server, sock, broadcast,
1133 SILC_NOTIFY_TYPE_CHANNEL_CHANGE,
1134 2, idp1->data, idp1->len, idp2->data, idp2->len);
1135 silc_buffer_free(idp1);
1136 silc_buffer_free(idp2);
1139 /* Send NICK_CHANGE notify type. This tells the receiver to replace the
1140 `old_id' with the `new_id'. */
1142 void silc_server_send_notify_nick_change(SilcServer server,
1143 SilcSocketConnection sock,
1145 SilcClientID *old_id,
1146 SilcClientID *new_id)
1148 SilcBuffer idp1, idp2;
1150 idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CLIENT);
1151 idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CLIENT);
1153 silc_server_send_notify(server, sock, broadcast,
1154 SILC_NOTIFY_TYPE_NICK_CHANGE,
1155 2, idp1->data, idp1->len, idp2->data, idp2->len);
1156 silc_buffer_free(idp1);
1157 silc_buffer_free(idp2);
1160 /* Sends JOIN notify type. This tells that new client by `client_id' ID
1161 has joined to the `channel'. */
1163 void silc_server_send_notify_join(SilcServer server,
1164 SilcSocketConnection sock,
1166 SilcChannelEntry channel,
1167 SilcClientID *client_id)
1169 SilcBuffer idp1, idp2;
1171 idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1172 idp2 = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1173 silc_server_send_notify(server, sock, broadcast, SILC_NOTIFY_TYPE_JOIN,
1174 2, idp1->data, idp1->len,
1175 idp2->data, idp2->len);
1176 silc_buffer_free(idp1);
1177 silc_buffer_free(idp2);
1180 /* Sends LEAVE notify type. This tells that `client_id' has left the
1181 `channel'. The Notify packet is always destined to the channel. */
1183 void silc_server_send_notify_leave(SilcServer server,
1184 SilcSocketConnection sock,
1186 SilcChannelEntry channel,
1187 SilcClientID *client_id)
1191 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1192 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1193 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_LEAVE,
1194 1, idp->data, idp->len);
1195 silc_buffer_free(idp);
1198 /* Sends CMODE_CHANGE notify type. This tells that `client_id' changed the
1199 `channel' mode to `mode. The Notify packet is always destined to
1202 void silc_server_send_notify_cmode(SilcServer server,
1203 SilcSocketConnection sock,
1205 SilcChannelEntry channel,
1207 void *id, SilcIdType id_type,
1208 char *cipher, char *hmac,
1212 unsigned char mode[4];
1214 idp = silc_id_payload_encode((void *)id, id_type);
1215 SILC_PUT32_MSB(mode_mask, mode);
1217 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1218 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_CMODE_CHANGE,
1219 5, idp->data, idp->len,
1221 cipher, cipher ? strlen(cipher) : 0,
1222 hmac, hmac ? strlen(hmac) : 0,
1223 passphrase, passphrase ?
1224 strlen(passphrase) : 0);
1225 silc_buffer_free(idp);
1228 /* Sends CUMODE_CHANGE notify type. This tells that `client_id' changed the
1229 `target' client's mode on `channel'. The notify packet is always
1230 destined to the channel. */
1232 void silc_server_send_notify_cumode(SilcServer server,
1233 SilcSocketConnection sock,
1235 SilcChannelEntry channel,
1237 void *id, SilcIdType id_type,
1238 SilcClientID *target)
1240 SilcBuffer idp1, idp2;
1241 unsigned char mode[4];
1243 idp1 = silc_id_payload_encode((void *)id, id_type);
1244 idp2 = silc_id_payload_encode((void *)target, SILC_ID_CLIENT);
1245 SILC_PUT32_MSB(mode_mask, mode);
1247 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1249 SILC_NOTIFY_TYPE_CUMODE_CHANGE, 3,
1250 idp1->data, idp1->len,
1252 idp2->data, idp2->len);
1253 silc_buffer_free(idp1);
1254 silc_buffer_free(idp2);
1257 /* Sends SIGNOFF notify type. This tells that `client_id' client has
1258 left SILC network. This function is used only between server and router
1259 traffic. This is not used to send the notify to the channel for
1260 client. The `message may be NULL. */
1262 void silc_server_send_notify_signoff(SilcServer server,
1263 SilcSocketConnection sock,
1265 SilcClientID *client_id,
1270 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1271 silc_server_send_notify(server, sock, broadcast,
1272 SILC_NOTIFY_TYPE_SIGNOFF,
1273 message ? 2 : 1, idp->data, idp->len,
1274 message, message ? strlen(message): 0);
1275 silc_buffer_free(idp);
1278 /* Sends TOPIC_SET notify type. This tells that `id' changed
1279 the `channel's topic to `topic'. The Notify packet is always destined
1280 to the channel. This function is used to send the topic set notifies
1283 void silc_server_send_notify_topic_set(SilcServer server,
1284 SilcSocketConnection sock,
1286 SilcChannelEntry channel,
1287 void *id, SilcIdType id_type,
1292 idp = silc_id_payload_encode(id, id_type);
1293 silc_server_send_notify_dest(server, sock, broadcast,
1294 (void *)channel->id, SILC_ID_CHANNEL,
1295 SILC_NOTIFY_TYPE_TOPIC_SET,
1297 idp->data, idp->len,
1298 topic, topic ? strlen(topic) : 0);
1299 silc_buffer_free(idp);
1302 /* Send KICKED notify type. This tells that the `client_id' on `channel'
1303 was kicked off the channel. The `comment' may indicate the reason
1304 for the kicking. This function is used only between server and router
1307 void silc_server_send_notify_kicked(SilcServer server,
1308 SilcSocketConnection sock,
1310 SilcChannelEntry channel,
1311 SilcClientID *client_id,
1316 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1317 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1318 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_KICKED,
1319 comment ? 2 : 1, idp->data, idp->len,
1320 comment, comment ? strlen(comment) : 0);
1321 silc_buffer_free(idp);
1324 /* Send KILLED notify type. This tells that the `client_id' client was
1325 killed from the network. The `comment' may indicate the reason
1328 void silc_server_send_notify_killed(SilcServer server,
1329 SilcSocketConnection sock,
1331 SilcClientID *client_id,
1336 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1337 silc_server_send_notify_dest(server, sock, broadcast, (void *)client_id,
1338 SILC_ID_CLIENT, SILC_NOTIFY_TYPE_KILLED,
1339 comment ? 2 : 1, idp->data, idp->len,
1340 comment, comment ? strlen(comment) : 0);
1341 silc_buffer_free(idp);
1344 /* Sends UMODE_CHANGE notify type. This tells that `client_id' client's
1345 user mode in the SILC Network was changed. This function is used to
1346 send the packet between routers as broadcast packet. */
1348 void silc_server_send_notify_umode(SilcServer server,
1349 SilcSocketConnection sock,
1351 SilcClientID *client_id,
1355 unsigned char mode[4];
1357 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1358 SILC_PUT32_MSB(mode_mask, mode);
1360 silc_server_send_notify(server, sock, broadcast,
1361 SILC_NOTIFY_TYPE_UMODE_CHANGE, 2,
1362 idp->data, idp->len,
1364 silc_buffer_free(idp);
1367 /* Sends BAN notify type. This tells that ban has been either `add'ed
1368 or `del'eted on the `channel. This function is used to send the packet
1369 between routers as broadcast packet. */
1371 void silc_server_send_notify_ban(SilcServer server,
1372 SilcSocketConnection sock,
1374 SilcChannelEntry channel,
1375 char *add, char *del)
1379 idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1380 silc_server_send_notify(server, sock, broadcast,
1381 SILC_NOTIFY_TYPE_BAN, 3,
1382 idp->data, idp->len,
1383 add, add ? strlen(add) : 0,
1384 del, del ? strlen(del) : 0);
1385 silc_buffer_free(idp);
1388 /* Sends INVITE notify type. This tells that invite has been either `add'ed
1389 or `del'eted on the `channel. The sender of the invite is the `client_id'.
1390 This function is used to send the packet between routers as broadcast
1393 void silc_server_send_notify_invite(SilcServer server,
1394 SilcSocketConnection sock,
1396 SilcChannelEntry channel,
1397 SilcClientID *client_id,
1398 char *add, char *del)
1400 SilcBuffer idp, idp2;
1402 idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1403 idp2 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1404 silc_server_send_notify(server, sock, broadcast,
1405 SILC_NOTIFY_TYPE_INVITE, 5,
1406 idp->data, idp->len,
1407 channel->channel_name, strlen(channel->channel_name),
1408 idp2->data, idp2->len,
1409 add, add ? strlen(add) : 0,
1410 del, del ? strlen(del) : 0);
1411 silc_buffer_free(idp);
1412 silc_buffer_free(idp2);
1415 /* Sends notify message destined to specific entity. */
1417 void silc_server_send_notify_dest(SilcServer server,
1418 SilcSocketConnection sock,
1421 SilcIdType dest_id_type,
1422 SilcNotifyType type,
1430 packet = silc_notify_payload_encode(type, argc, ap);
1431 silc_server_packet_send_dest(server, sock, SILC_PACKET_NOTIFY,
1432 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1433 dest_id, dest_id_type,
1434 packet->data, packet->len, FALSE);
1435 silc_buffer_free(packet);
1439 /* Sends notify message to a channel. The notify message sent is
1440 distributed to all clients on the channel. If `route_notify' is TRUE
1441 then the notify may be routed to primary route or to some other routers.
1442 If FALSE it is assured that the notify is sent only locally. If `sender'
1443 is provided then the packet is not sent to that connection since it
1444 originally came from it. */
1446 void silc_server_send_notify_to_channel(SilcServer server,
1447 SilcSocketConnection sender,
1448 SilcChannelEntry channel,
1450 SilcNotifyType type,
1458 packet = silc_notify_payload_encode(type, argc, ap);
1459 silc_server_packet_send_to_channel(server, sender, channel,
1460 SILC_PACKET_NOTIFY, route_notify,
1461 packet->data, packet->len, FALSE);
1462 silc_buffer_free(packet);
1466 /* Send notify message to all channels the client has joined. It is quaranteed
1467 that the message is sent only once to a client (ie. if a client is joined
1468 on two same channel it will receive only one notify message). Also, this
1469 sends only to local clients (locally connected if we are server, and to
1470 local servers if we are router). If `sender' is provided the packet is
1471 not sent to that client at all. */
1473 void silc_server_send_notify_on_channels(SilcServer server,
1474 SilcClientEntry sender,
1475 SilcClientEntry client,
1476 SilcNotifyType type,
1480 SilcSocketConnection sock = NULL;
1481 SilcPacketContext packetdata;
1483 SilcClientEntry *sent_clients = NULL;
1484 uint32 sent_clients_count = 0;
1485 SilcServerEntry *routed = NULL;
1486 uint32 routed_count = 0;
1487 SilcHashTableList htl, htl2;
1488 SilcChannelEntry channel;
1489 SilcChannelClientEntry chl, chl2;
1490 SilcIDListData idata;
1492 unsigned char *data;
1494 bool force_send = FALSE;
1497 SILC_LOG_DEBUG(("Start"));
1499 if (!silc_hash_table_count(client->channels))
1503 packet = silc_notify_payload_encode(type, argc, ap);
1504 data = packet->data;
1505 data_len = packet->len;
1507 /* Set the packet context pointers. */
1508 packetdata.flags = 0;
1509 packetdata.type = SILC_PACKET_NOTIFY;
1510 packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
1511 packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
1512 packetdata.src_id_type = SILC_ID_SERVER;
1514 silc_hash_table_list(client->channels, &htl);
1515 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
1516 channel = chl->channel;
1518 /* Send the message to all clients on the channel's client list. */
1519 silc_hash_table_list(channel->user_list, &htl2);
1520 while (silc_hash_table_get(&htl2, NULL, (void *)&chl2)) {
1523 if (sender && c == sender)
1526 /* Check if we have sent the packet to this client already */
1527 for (k = 0; k < sent_clients_count; k++)
1528 if (sent_clients[k] == c)
1530 if (k < sent_clients_count)
1533 /* If we are router and if this client has router set it is not
1534 locally connected client and we will route the message to the
1535 router set in the client. */
1536 if (c && c->router && server->server_type == SILC_ROUTER) {
1537 /* Check if we have sent the packet to this route already */
1538 for (k = 0; k < routed_count; k++)
1539 if (routed[k] == c->router)
1541 if (k < routed_count)
1544 /* Get data used in packet header encryption, keys and stuff. */
1545 sock = (SilcSocketConnection)c->router->connection;
1546 idata = (SilcIDListData)c->router;
1549 SILC_LOG_DEBUG(("*****************"));
1550 SILC_LOG_DEBUG(("client->router->id %s",
1551 silc_id_render(c->router->id, SILC_ID_SERVER)));
1552 SILC_LOG_DEBUG(("client->router->connection->user_data->id %s",
1553 silc_id_render(((SilcServerEntry)sock->user_data)->id, SILC_ID_SERVER)));
1556 packetdata.dst_id = silc_id_id2str(c->router->id, SILC_ID_SERVER);
1557 packetdata.dst_id_len = silc_id_get_len(c->router->id, SILC_ID_SERVER);
1558 packetdata.dst_id_type = SILC_ID_SERVER;
1560 /* Send the packet */
1561 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1565 data, data_len, FALSE,
1568 silc_free(packetdata.dst_id);
1570 /* We want to make sure that the packet is routed to same router
1571 only once. Mark this route as sent route. */
1572 routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
1573 routed[routed_count++] = c->router;
1580 /* Send to locally connected client */
1583 /* Get data used in packet header encryption, keys and stuff. */
1584 sock = (SilcSocketConnection)c->connection;
1585 idata = (SilcIDListData)c;
1587 packetdata.dst_id = silc_id_id2str(c->id, SILC_ID_CLIENT);
1588 packetdata.dst_id_len = silc_id_get_len(c->id, SILC_ID_CLIENT);
1589 packetdata.dst_id_type = SILC_ID_CLIENT;
1591 /* Send the packet */
1592 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1596 data, data_len, FALSE,
1599 silc_free(packetdata.dst_id);
1601 /* Make sure that we send the notify only once per client. */
1602 sent_clients = silc_realloc(sent_clients, sizeof(*sent_clients) *
1603 (sent_clients_count + 1));
1604 sent_clients[sent_clients_count++] = c;
1610 silc_free(sent_clients);
1611 silc_free(packetdata.src_id);
1612 silc_buffer_free(packet);
1616 /* Sends New ID Payload to remote end. The packet is used to distribute
1617 information about new registered clients, servers, channel etc. usually
1618 to routers so that they can keep these information up to date.
1619 If the argument `broadcast' is TRUE then the packet is sent as
1620 broadcast packet. */
1622 void silc_server_send_new_id(SilcServer server,
1623 SilcSocketConnection sock,
1625 void *id, SilcIdType id_type,
1630 SILC_LOG_DEBUG(("Start"));
1632 idp = silc_id_payload_encode(id, id_type);
1633 silc_server_packet_send(server, sock, SILC_PACKET_NEW_ID,
1634 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1635 idp->data, idp->len, FALSE);
1637 /* Send to backup routers if this is being broadcasted to primary
1639 if (server->router && server->router->connection &&
1640 sock == server->router->connection && broadcast)
1641 silc_server_backup_send(server, NULL, SILC_PACKET_NEW_ID, 0,
1642 idp->data, idp->len, FALSE, TRUE);
1644 silc_buffer_free(idp);
1647 /* Send New Channel Payload to notify about newly created channel in the
1648 SILC network. Normal server nevers sends this packet. Router uses this
1649 to notify other routers in the network about new channel. This packet
1652 void silc_server_send_new_channel(SilcServer server,
1653 SilcSocketConnection sock,
1657 uint32 channel_id_len,
1662 uint32 name_len = strlen(channel_name);
1664 SILC_LOG_DEBUG(("Start"));
1666 cid = silc_id_id2str(channel_id, SILC_ID_CHANNEL);
1670 /* Encode the channel payload */
1671 packet = silc_channel_payload_encode(channel_name, name_len,
1672 cid, channel_id_len, mode);
1674 silc_server_packet_send(server, sock, SILC_PACKET_NEW_CHANNEL,
1675 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1676 packet->data, packet->len, FALSE);
1678 /* Send to backup routers if this is being broadcasted to primary
1680 if (server->router && server->router->connection &&
1681 sock == server->router->connection && broadcast)
1682 silc_server_backup_send(server, NULL, SILC_PACKET_NEW_CHANNEL, 0,
1683 packet->data, packet->len, FALSE, TRUE);
1686 silc_buffer_free(packet);
1689 /* Send Channel Key payload to distribute the new channel key. Normal server
1690 sends this to router when new client joins to existing channel. Router
1691 sends this to the local server who sent the join command in case where
1692 the channel did not exist yet. Both normal and router servers uses this
1693 also to send this to locally connected clients on the channel. This
1694 must not be broadcasted packet. Routers do not send this to each other.
1695 If `sender is provided then the packet is not sent to that connection since
1696 it originally came from it. */
1698 void silc_server_send_channel_key(SilcServer server,
1699 SilcSocketConnection sender,
1700 SilcChannelEntry channel,
1701 unsigned char route)
1704 unsigned char *chid;
1707 SILC_LOG_DEBUG(("Start"));
1709 chid = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
1713 /* Encode channel key packet */
1714 tmp_len = strlen(channel->channel_key->cipher->name);
1715 packet = silc_channel_key_payload_encode(silc_id_get_len(channel->id,
1718 channel->channel_key->cipher->name,
1719 channel->key_len / 8, channel->key);
1720 silc_server_packet_send_to_channel(server, sender, channel,
1721 SILC_PACKET_CHANNEL_KEY,
1722 route, packet->data, packet->len,
1724 silc_buffer_free(packet);
1728 /* Generic function to send any command. The arguments must be sent already
1729 encoded into correct form in correct order. */
1731 void silc_server_send_command(SilcServer server,
1732 SilcSocketConnection sock,
1733 SilcCommand command,
1742 packet = silc_command_payload_encode_vap(command, ident, argc, ap);
1743 silc_server_packet_send(server, sock, SILC_PACKET_COMMAND, 0,
1744 packet->data, packet->len, TRUE);
1745 silc_buffer_free(packet);
1749 /* Generic function to send any command reply. The arguments must be sent
1750 already encoded into correct form in correct order. */
1752 void silc_server_send_command_reply(SilcServer server,
1753 SilcSocketConnection sock,
1754 SilcCommand command,
1755 SilcCommandStatus status,
1764 packet = silc_command_reply_payload_encode_vap(command, status, ident,
1766 silc_server_packet_send(server, sock, SILC_PACKET_COMMAND_REPLY, 0,
1767 packet->data, packet->len, TRUE);
1768 silc_buffer_free(packet);
1772 /* Send the heartbeat packet. */
1774 void silc_server_send_heartbeat(SilcServer server,
1775 SilcSocketConnection sock)
1777 silc_server_packet_send(server, sock, SILC_PACKET_HEARTBEAT, 0,
1781 /* Generic function to relay packet we've received. This is used to relay
1782 packets to a client but generally can be used to other purposes as well. */
1784 void silc_server_relay_packet(SilcServer server,
1785 SilcSocketConnection dst_sock,
1789 SilcPacketContext *packet,
1792 silc_buffer_push(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1793 + packet->dst_id_len + packet->padlen);
1795 silc_packet_send_prepare(dst_sock, 0, 0, packet->buffer->len);
1796 silc_buffer_put(dst_sock->outbuf, packet->buffer->data, packet->buffer->len);
1798 /* Re-encrypt packet */
1799 silc_packet_encrypt(cipher, hmac, sequence, dst_sock->outbuf,
1800 packet->buffer->len);
1802 /* Send the packet */
1803 silc_server_packet_send_real(server, dst_sock, force_send);
1805 silc_buffer_pull(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1806 + packet->dst_id_len + packet->padlen);
1809 /* Routine used to send the connection authentication packet. */
1811 void silc_server_send_connection_auth_request(SilcServer server,
1812 SilcSocketConnection sock,
1814 SilcAuthMethod auth_meth)
1818 packet = silc_buffer_alloc(4);
1819 silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1820 silc_buffer_format(packet,
1821 SILC_STR_UI_SHORT(conn_type),
1822 SILC_STR_UI_SHORT(auth_meth),
1825 silc_server_packet_send(server, sock, SILC_PACKET_CONNECTION_AUTH_REQUEST,
1826 0, packet->data, packet->len, FALSE);
1827 silc_buffer_free(packet);
1830 /* Purge the outgoing packet queue to the network if there is data. This
1831 function can be used to empty the packet queue. It is guaranteed that
1832 after this function returns the outgoing data queue is empty. */
1834 void silc_server_packet_queue_purge(SilcServer server,
1835 SilcSocketConnection sock)
1837 if (sock && SILC_IS_OUTBUF_PENDING(sock) &&
1838 (SILC_IS_DISCONNECTED(sock) == FALSE)) {
1839 server->stat.packets_sent++;
1841 if (sock->outbuf->data - sock->outbuf->head)
1842 silc_buffer_push(sock->outbuf, sock->outbuf->data - sock->outbuf->head);
1844 silc_packet_send(sock, TRUE);
1846 SILC_SET_CONNECTION_FOR_INPUT(server->schedule, sock->sock);
1847 SILC_UNSET_OUTBUF_PENDING(sock);
1848 silc_buffer_clear(sock->outbuf);